├── .gitignore ├── 01_simple_feedforward_neural_network.ipynb ├── 02_using_metrics_in_eager_mode.ipynb ├── 03_save_and_restore_model.ipynb ├── 04_text_data_to_tfrecords.ipynb ├── 05_images_to_tfrecords.ipynb ├── 06_read_data_in_batches_from_tfrecords.ipynb ├── 07_convolutional_neural_networks_for_emotion_recognition.ipynb ├── 08_dynamic_recurrent_neural_networks_for_sequence_classification.ipynb ├── 09_recurrent_neural_networks_for_time_series_regression.ipynb ├── README.md ├── data_utils.py ├── datasets ├── aclImdb │ ├── length_reviews.pkl │ ├── test.tfrecords │ ├── train.tfrecords │ └── word2idx.pkl ├── dummy_images │ ├── dummy.tfrecords │ ├── id0_0.jpeg │ ├── id1_0.jpeg │ ├── id2_2.jpeg │ ├── id3_4.jpeg │ ├── id4_6.jpeg │ ├── id5_2.jpeg │ ├── id6_4.jpeg │ ├── id7_3.jpeg │ ├── id8_3.jpeg │ └── id9_2.jpeg ├── dummy_text │ ├── dummy.tfrecords │ ├── neg │ │ ├── 0_3.txt │ │ ├── 1_1.txt │ │ └── 2_1.txt │ ├── pos │ │ ├── 0_9.txt │ │ ├── 1_7.txt │ │ └── 2_9.txt │ └── word2idx.pkl ├── get_imdb_dataset.sh └── load_forecasting │ └── spain_hourly_entsoe.csv ├── models_checkpoints ├── DemandRNN │ ├── -0.data-00000-of-00001 │ ├── -0.index │ └── checkpoint ├── EmotionCNN │ ├── -0.data-00000-of-00001 │ ├── -0.index │ └── checkpoint ├── ImdbRNN │ ├── -0.data-00000-of-00001 │ ├── -0.index │ └── checkpoint └── SimpleNN │ ├── -1.data-00000-of-00001 │ ├── -1.index │ └── checkpoint └── tutorials_graphics ├── 01_flowchart.png ├── 02_flowchart.png ├── 03_flowchart.png ├── 04_flowchart.png ├── 05_flowchart.png ├── images2tfrecords.png ├── moving_windows_samples.png ├── readbatches.png ├── rnn_imdb.png ├── rnn_regression.png ├── save_restore_model.png └── text2tfrecords.png /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | .static_storage/ 57 | .media/ 58 | local_settings.py 59 | 60 | # Flask stuff: 61 | instance/ 62 | .webassets-cache 63 | 64 | # Scrapy stuff: 65 | .scrapy 66 | 67 | # Sphinx documentation 68 | docs/_build/ 69 | 70 | # PyBuilder 71 | target/ 72 | 73 | # Jupyter Notebook 74 | .ipynb_checkpoints 75 | 76 | # pyenv 77 | .python-version 78 | 79 | # celery beat schedule file 80 | celerybeat-schedule 81 | 82 | # SageMath parsed files 83 | *.sage.py 84 | 85 | # Environments 86 | .env 87 | .venv 88 | env/ 89 | venv/ 90 | ENV/ 91 | env.bak/ 92 | venv.bak/ 93 | 94 | # Spyder project settings 95 | .spyderproject 96 | .spyproject 97 | 98 | # Rope project settings 99 | .ropeproject 100 | 101 | # mkdocs documentation 102 | /site 103 | 104 | # mypy 105 | .mypy_cache/ 106 | 107 | # notebook checkpoints 108 | .ipynb_checkpoints 109 | 110 | # ignore data folder 111 | datasets/* 112 | !datasets/get_imdb_dataset.sh 113 | !datasets/load_forecasting 114 | !datasets/dummy_text 115 | !datasets/dummy_images 116 | !datasets/aclImdb 117 | datasets/aclImdb/* 118 | !datasets/aclImdb/length_reviews.pkl 119 | !datasets/aclImdb/word2idx.pkl 120 | !datasets/aclImdb/train.tfrecords 121 | !datasets/aclImdb/test.tfrecords 122 | -------------------------------------------------------------------------------- /01_simple_feedforward_neural_network.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# How to: Build a simple neural network with TensorFlow Eager\n", 8 | "\n", 9 | "Hello everyone! In this tutorial we are going to build a simple feedforward neural network\n", 10 | "using the imperative mode of TensorFlow. Hope you will find it useful! If you have any suggestions on how I can improve the code, please let me know. \n", 11 | "\n", 12 | "### Tutorial steps:\n", 13 | "----\n", 14 | "\n", 15 | "![img](tutorials_graphics/01_flowchart.png)\n", 16 | "\n", 17 | "**Version used: TensorFlow 1.7**" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "## Step 1: Import useful libraries and enable eager mode\n", 25 | "----" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "# Import TensorFlow and TensorFlow Eager\n", 35 | "import tensorflow as tf\n", 36 | "import tensorflow.contrib.eager as tfe\n", 37 | "\n", 38 | "# Import function to generate toy classication problem\n", 39 | "from sklearn.datasets import make_moons\n", 40 | "import numpy as np\n", 41 | "\n", 42 | "# Import library for plots\n", 43 | "import matplotlib.pyplot as plt\n", 44 | "%matplotlib inline" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 3, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "# Enable eager mode. Once activated it cannot be reversed! Run just once.\n", 54 | "tfe.enable_eager_execution()" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "## Step 2: Generate toy dataset for binary classification\n", 62 | "----\n", 63 | "We will generate a toy dataset, to train our network. I chose the make_moons function from sklearn. I believe it is perfect for our task, as the classes are not linearly separable so a neural network will be very useful." 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 4, 69 | "metadata": {}, 70 | "outputs": [], 71 | "source": [ 72 | "# Generate toy dataset for classification\n", 73 | "# X is a matrix of n_samples x n_features and represents the input features\n", 74 | "# y is a vector with length n_samples and represents our targets\n", 75 | "X, y = make_moons(n_samples=100, noise=0.1, random_state=2018)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "## Step 3: Visualize generated dataset\n", 83 | "----" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 5, 89 | "metadata": {}, 90 | "outputs": [ 91 | { 92 | "data": { 93 | "image/png": "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\n", 94 | "text/plain": [ 95 | "" 96 | ] 97 | }, 98 | "metadata": {}, 99 | "output_type": "display_data" 100 | } 101 | ], 102 | "source": [ 103 | "plt.scatter(X[:,0], X[:,1], c=y, cmap=plt.cm.autumn)\n", 104 | "plt.xlabel('First feature')\n", 105 | "plt.ylabel('Second feature')\n", 106 | "plt.title('Toy classification problem')\n", 107 | "plt.show()" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "## Step 4: Build a single hidden layer neural network (Linear -> ReLU -> Linear output)\n", 115 | "----\n", 116 | "Our first trial is a simple neural network with a single hidden layer. The easiest way to build neural networks models with TensorFlow Eager is with classes. During initialization, you define the layers needed to run a forward-pass through the model.\n", 117 | "\n", 118 | "As this is a classification problem, we will be using the softmax cross-entropy loss. Normally, we would have to one-hot encode our targets. To avoid this, we will be using the sparse softmax loss, which takes as an input the raw targets. No need for further processing! HOORAY :).\n" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 15, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "class simple_nn(tf.keras.Model):\n", 128 | " def __init__(self):\n", 129 | " super(simple_nn, self).__init__()\n", 130 | " \"\"\" Define here the layers used during the forward-pass \n", 131 | " of the neural network.\n", 132 | " \"\"\" \n", 133 | " # Hidden layer.\n", 134 | " self.dense_layer = tf.layers.Dense(10, activation=tf.nn.relu)\n", 135 | " # Output layer. No activation.\n", 136 | " self.output_layer = tf.layers.Dense(2, activation=None)\n", 137 | " \n", 138 | " def predict(self, input_data):\n", 139 | " \"\"\" Runs a forward-pass through the network. \n", 140 | " Args:\n", 141 | " input_data: 2D tensor of shape (n_samples, n_features). \n", 142 | " Returns:\n", 143 | " logits: unnormalized predictions.\n", 144 | " \"\"\"\n", 145 | " hidden_activations = self.dense_layer(input_data)\n", 146 | " logits = self.output_layer(hidden_activations)\n", 147 | " return logits\n", 148 | " \n", 149 | " def loss_fn(self, input_data, target):\n", 150 | " \"\"\" Defines the loss function used during \n", 151 | " training. \n", 152 | " \"\"\"\n", 153 | " logits = self.predict(input_data)\n", 154 | " loss = tf.losses.sparse_softmax_cross_entropy(labels=target, logits=logits)\n", 155 | " return loss\n", 156 | " \n", 157 | " def grads_fn(self, input_data, target):\n", 158 | " \"\"\" Dynamically computes the gradients of the loss value\n", 159 | " with respect to the parameters of the model, in each\n", 160 | " forward pass.\n", 161 | " \"\"\"\n", 162 | " with tfe.GradientTape() as tape:\n", 163 | " loss = self.loss_fn(input_data, target)\n", 164 | " return tape.gradient(loss, self.variables)\n", 165 | " \n", 166 | " def fit(self, input_data, target, optimizer, num_epochs=500, verbose=50):\n", 167 | " \"\"\" Function to train the model, using the selected optimizer and\n", 168 | " for the desired number of epochs.\n", 169 | " \"\"\"\n", 170 | " for i in range(num_epochs):\n", 171 | " grads = self.grads_fn(input_data, target)\n", 172 | " optimizer.apply_gradients(zip(grads, self.variables))\n", 173 | " if (i==0) | ((i+1)%verbose==0):\n", 174 | " print('Loss at epoch %d: %f' %(i+1, self.loss_fn(input_data, target).numpy()))" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "## Step 5: Train the model with gradient descent\n", 182 | "----\n", 183 | "Use backpropagation to train the variables of our model. Feel free to play with the learning rate and the number of epochs." 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 16, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [ 192 | "X_tensor = tf.constant(X)\n", 193 | "y_tensor = tf.constant(y)" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 17, 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "Loss at epoch 1: 0.653288\n", 206 | "Loss at epoch 50: 0.283921\n", 207 | "Loss at epoch 100: 0.260529\n", 208 | "Loss at epoch 150: 0.244092\n", 209 | "Loss at epoch 200: 0.221653\n", 210 | "Loss at epoch 250: 0.186211\n", 211 | "Loss at epoch 300: 0.139418\n", 212 | "Loss at epoch 350: 0.103654\n", 213 | "Loss at epoch 400: 0.078874\n", 214 | "Loss at epoch 450: 0.062550\n", 215 | "Loss at epoch 500: 0.051096\n" 216 | ] 217 | } 218 | ], 219 | "source": [ 220 | "optimizer = tf.train.GradientDescentOptimizer(5e-1)\n", 221 | "model = simple_nn()\n", 222 | "model.fit(X_tensor, y_tensor, optimizer, num_epochs=500, verbose=50)" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "## Step 7: Plot decision boundary\n", 230 | "----\n", 231 | "The code for visualizing the decision boundary of our model has been inspired from [this tutorial](http://scikit-learn.org/stable/auto_examples/svm/plot_iris.html#sphx-glr-auto-examples-svm-plot-iris-py)." 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 11, 237 | "metadata": {}, 238 | "outputs": [ 239 | { 240 | "data": { 241 | "image/png": "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\n", 242 | "text/plain": [ 243 | "" 244 | ] 245 | }, 246 | "metadata": {}, 247 | "output_type": "display_data" 248 | } 249 | ], 250 | "source": [ 251 | "# Create a mesh to plot in\n", 252 | "x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n", 253 | "y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n", 254 | "xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),\n", 255 | " np.arange(y_min, y_max, 0.01))\n", 256 | "\n", 257 | "# Predict target for each sample xx, yy\n", 258 | "Z = np.argmax(model.predict(tf.constant(np.c_[xx.ravel(), yy.ravel()])).numpy(), axis=1)\n", 259 | "\n", 260 | "# Put the result into a color plot\n", 261 | "Z = Z.reshape(xx.shape)\n", 262 | "fig = plt.figure()\n", 263 | "plt.contourf(xx, yy, Z, cmap=plt.cm.autumn, alpha=0.8)\n", 264 | "\n", 265 | "# Plot our training points\n", 266 | "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.autumn, edgecolors='k')\n", 267 | "plt.xlim(xx.min(), xx.max())\n", 268 | "plt.ylim(yy.min(), yy.max())\n", 269 | "plt.xlabel('First feature', fontsize=15)\n", 270 | "plt.ylabel('Second feature', fontsize=15)\n", 271 | "plt.title('Toy classification problem', fontsize=15)\n", 272 | "plt.show()" 273 | ] 274 | } 275 | ], 276 | "metadata": { 277 | "kernelspec": { 278 | "display_name": "Python 3", 279 | "language": "python", 280 | "name": "python3" 281 | }, 282 | "language_info": { 283 | "codemirror_mode": { 284 | "name": "ipython", 285 | "version": 3 286 | }, 287 | "file_extension": ".py", 288 | "mimetype": "text/x-python", 289 | "name": "python", 290 | "nbconvert_exporter": "python", 291 | "pygments_lexer": "ipython3", 292 | "version": "3.6.4" 293 | } 294 | }, 295 | "nbformat": 4, 296 | "nbformat_minor": 2 297 | } 298 | -------------------------------------------------------------------------------- /03_save_and_restore_model.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# How to save and restore a trained model\n", 8 | "\n", 9 | "After scrolling through the posts of [reddit.com/r/learnmachinelearning](https://www.reddit.com/r/learnmachinelearning/), I've realized that the major bottlenecks of a machine learning project occur in the data input pipeline and in the final stage of the model, where you have to save the model and make predictions on new data.\n", 10 | "So I thought that it would be useful to make a simple and straightforward tutorial to show you how you could save and restore a model that you have built with Tensorflow Eager.\n", 11 | "\n", 12 | "### Tutorial flowchart\n", 13 | "----\n", 14 | "\n", 15 | "![img](tutorials_graphics/save_restore_model.png)" 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "## Import here useful libraries" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 2, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "# Import TensorFlow and TensorFlow Eager\n", 32 | "import tensorflow as tf\n", 33 | "import tensorflow.contrib.eager as tfe\n", 34 | "\n", 35 | "# Import function to generate toy classication problem\n", 36 | "from sklearn.datasets import make_moons" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "# Enable eager mode. Once activated it cannot be reversed! Run just once.\n", 46 | "tfe.enable_eager_execution()" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## Part I: Build a simple neural network model for binary classification" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 4, 59 | "metadata": {}, 60 | "outputs": [], 61 | "source": [ 62 | "class simple_nn(tf.keras.Model):\n", 63 | " def __init__(self):\n", 64 | " super(simple_nn, self).__init__()\n", 65 | " \"\"\" Define here the layers used during the forward-pass \n", 66 | " of the neural network.\n", 67 | " \"\"\" \n", 68 | " # Hidden layer.\n", 69 | " self.dense_layer = tf.layers.Dense(10, activation=tf.nn.relu)\n", 70 | " # Output layer. No activation.\n", 71 | " self.output_layer = tf.layers.Dense(2, activation=None)\n", 72 | " \n", 73 | " def predict(self, input_data):\n", 74 | " \"\"\" Runs a forward-pass through the network. \n", 75 | " Args:\n", 76 | " input_data: 2D tensor of shape (n_samples, n_features). \n", 77 | " Returns:\n", 78 | " logits: unnormalized predictions.\n", 79 | " \"\"\"\n", 80 | " hidden_activations = self.dense_layer(input_data)\n", 81 | " logits = self.output_layer(hidden_activations)\n", 82 | " return logits\n", 83 | " \n", 84 | " def loss_fn(self, input_data, target):\n", 85 | " \"\"\" Defines the loss function used during \n", 86 | " training. \n", 87 | " \"\"\"\n", 88 | " logits = self.predict(input_data)\n", 89 | " loss = tf.losses.sparse_softmax_cross_entropy(labels=target, logits=logits)\n", 90 | " return loss\n", 91 | " \n", 92 | " def grads_fn(self, input_data, target):\n", 93 | " \"\"\" Dynamically computes the gradients of the loss value\n", 94 | " with respect to the parameters of the model, in each\n", 95 | " forward pass.\n", 96 | " \"\"\"\n", 97 | " with tfe.GradientTape() as tape:\n", 98 | " loss = self.loss_fn(input_data, target)\n", 99 | " return tape.gradient(loss, self.variables)\n", 100 | " \n", 101 | " def fit(self, input_data, target, optimizer, num_epochs=500, verbose=50):\n", 102 | " \"\"\" Function to train the model, using the selected optimizer and\n", 103 | " for the desired number of epochs.\n", 104 | " \"\"\"\n", 105 | " for i in range(num_epochs):\n", 106 | " grads = self.grads_fn(input_data, target)\n", 107 | " optimizer.apply_gradients(zip(grads, self.variables))\n", 108 | " if (i==0) | ((i+1)%verbose==0):\n", 109 | " print('Loss at epoch %d: %f' %(i+1, self.loss_fn(input_data, target).numpy()))" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "## Part II: Train model " 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 9, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "# Generate toy dataset for classification\n", 126 | "# X is a matrix of n_samples x n_features and represents the input features\n", 127 | "# y is a vector with length n_samples and represents our targets\n", 128 | "X, y = make_moons(n_samples=100, noise=0.1, random_state=2018)\n", 129 | "X_train, y_train = tf.constant(X[:80,:]), tf.constant(y[:80])\n", 130 | "X_test, y_test = tf.constant(X[80:,:]), tf.constant(y[80:])" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 10, 136 | "metadata": {}, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "Loss at epoch 1: 0.658276\n", 143 | "Loss at epoch 50: 0.302146\n", 144 | "Loss at epoch 100: 0.268594\n", 145 | "Loss at epoch 150: 0.247425\n", 146 | "Loss at epoch 200: 0.229143\n", 147 | "Loss at epoch 250: 0.197839\n", 148 | "Loss at epoch 300: 0.143365\n", 149 | "Loss at epoch 350: 0.098039\n", 150 | "Loss at epoch 400: 0.070781\n", 151 | "Loss at epoch 450: 0.053753\n", 152 | "Loss at epoch 500: 0.042401\n" 153 | ] 154 | } 155 | ], 156 | "source": [ 157 | "optimizer = tf.train.GradientDescentOptimizer(5e-1)\n", 158 | "model = simple_nn()\n", 159 | "model.fit(X_train, y_train, optimizer, num_epochs=500, verbose=50)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "## Part III: Save trained model" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 11, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [ 175 | "# Specify checkpoint directory\n", 176 | "checkpoint_directory = 'models_checkpoints/SimpleNN/'\n", 177 | "# Create model checkpoint\n", 178 | "checkpoint = tfe.Checkpoint(optimizer=optimizer,\n", 179 | " model=model,\n", 180 | " optimizer_step=tf.train.get_or_create_global_step())" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 12, 186 | "metadata": {}, 187 | "outputs": [ 188 | { 189 | "data": { 190 | "text/plain": [ 191 | "'models_checkpoints/SimpleNN/-1'" 192 | ] 193 | }, 194 | "execution_count": 12, 195 | "metadata": {}, 196 | "output_type": "execute_result" 197 | } 198 | ], 199 | "source": [ 200 | "# Save trained model\n", 201 | "checkpoint.save(file_prefix=checkpoint_directory)" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "## Part IV: Restore trained model\n" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 13, 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [ 217 | "# Reinitialize model instance\n", 218 | "model = simple_nn()\n", 219 | "optimizer = tf.train.GradientDescentOptimizer(5e-1)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 14, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "# Specify checkpoint directory\n", 229 | "checkpoint_directory = 'models_checkpoints/SimpleNN/'\n", 230 | "# Create model checkpoint\n", 231 | "checkpoint = tfe.Checkpoint(optimizer=optimizer,\n", 232 | " model=model,\n", 233 | " optimizer_step=tf.train.get_or_create_global_step())" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 15, 239 | "metadata": {}, 240 | "outputs": [ 241 | { 242 | "data": { 243 | "text/plain": [ 244 | "" 245 | ] 246 | }, 247 | "execution_count": 15, 248 | "metadata": {}, 249 | "output_type": "execute_result" 250 | } 251 | ], 252 | "source": [ 253 | "# Restore model from latest chekpoint\n", 254 | "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_directory))" 255 | ] 256 | }, 257 | { 258 | "cell_type": "markdown", 259 | "metadata": {}, 260 | "source": [ 261 | "## Part V: Check if the model was restored correctly" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 16, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "name": "stdout", 271 | "output_type": "stream", 272 | "text": [ 273 | "Loss at epoch 1: 0.042220\n" 274 | ] 275 | } 276 | ], 277 | "source": [ 278 | "model.fit(X_train, y_train, optimizer, num_epochs=1)" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "The loss seems to be consistent with the loss we obtained in the last epoch of previous training :)!" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": {}, 291 | "source": [ 292 | "## Part VI: Make predictions on new data" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 17, 298 | "metadata": {}, 299 | "outputs": [], 300 | "source": [ 301 | "logits_test = model.predict(X_test)" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": 18, 307 | "metadata": {}, 308 | "outputs": [ 309 | { 310 | "name": "stdout", 311 | "output_type": "stream", 312 | "text": [ 313 | "tf.Tensor(\n", 314 | "[[ 1.54352813 -0.83117302]\n", 315 | " [-1.60523365 2.82397487]\n", 316 | " [ 2.87589525 -1.36463485]\n", 317 | " [-1.39461001 2.62404279]\n", 318 | " [ 0.82305161 -0.55651397]\n", 319 | " [ 3.53674391 -2.55593046]\n", 320 | " [-2.97344627 3.46589599]\n", 321 | " [-1.69372442 2.95660466]\n", 322 | " [-1.43226137 2.65357974]\n", 323 | " [ 3.11479995 -1.31765645]\n", 324 | " [-0.65841567 1.60468631]\n", 325 | " [-2.27454367 3.60553595]\n", 326 | " [-1.50170912 2.74410115]\n", 327 | " [ 0.76261479 -0.44574208]\n", 328 | " [ 2.34516959 -1.6859307 ]\n", 329 | " [ 1.92181942 -1.63766352]\n", 330 | " [ 4.06047684 -3.03988941]\n", 331 | " [ 1.00252324 -0.78900484]\n", 332 | " [ 2.79802993 -2.2139734 ]\n", 333 | " [-1.43933035 2.68037059]], shape=(20, 2), dtype=float64)\n" 334 | ] 335 | } 336 | ], 337 | "source": [ 338 | "print(logits_test)" 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": null, 344 | "metadata": {}, 345 | "outputs": [], 346 | "source": [] 347 | } 348 | ], 349 | "metadata": { 350 | "kernelspec": { 351 | "display_name": "Python 3", 352 | "language": "python", 353 | "name": "python3" 354 | }, 355 | "language_info": { 356 | "codemirror_mode": { 357 | "name": "ipython", 358 | "version": 3 359 | }, 360 | "file_extension": ".py", 361 | "mimetype": "text/x-python", 362 | "name": "python", 363 | "nbconvert_exporter": "python", 364 | "pygments_lexer": "ipython3", 365 | "version": "3.6.4" 366 | } 367 | }, 368 | "nbformat": 4, 369 | "nbformat_minor": 2 370 | } 371 | -------------------------------------------------------------------------------- /04_text_data_to_tfrecords.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Text sequences to TFRecords\n", 8 | "----\n", 9 | "\n", 10 | "Hello everyone! In this tutorial, I am going to show you how can you parse your raw text data to TFRecords. I know that many people struggle with input processing pipelines, especially when you start working on your own personal project. So I really hope it is going to be useful for any of you :)!\n", 11 | "\n", 12 | "### Tutorial flowchart\n", 13 | "----\n", 14 | "![img](tutorials_graphics/text2tfrecords.png)\n", 15 | "\n", 16 | "\n", 17 | "### Dummy IMDB text data\n", 18 | "----\n", 19 | "For practice, I have chosen a few data samples from the Large Movie Review Dataset offered by Stanford." 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "### Import here useful libraries\n" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 2, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "from nltk.tokenize import word_tokenize\n", 36 | "import tensorflow as tf\n", 37 | "import pandas as pd\n", 38 | "import pickle\n", 39 | "import random\n", 40 | "import glob\n", 41 | "import nltk\n", 42 | "import re\n", 43 | "\n", 44 | "try:\n", 45 | " nltk.data.find('tokenizers/punkt')\n", 46 | "except LookupError:\n", 47 | " nltk.download('punkt')" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "### Parse data to TFRecords\n", 55 | "---" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 4, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "def imdb2tfrecords(path_data='datasets/dummy_text/', min_word_frequency=5,\n", 65 | " max_words_review=700):\n", 66 | " '''\n", 67 | " This script processes the data and saves it in the default TensorFlow \n", 68 | " file format: tfrecords.\n", 69 | " \n", 70 | " Args:\n", 71 | " path_data: the path where the imdb data is stored.\n", 72 | " min_word_frequency: the minimum frequency of a word, to keep it\n", 73 | " in the vocabulary.\n", 74 | " max_words_review: the maximum number of words allowed in a review.\n", 75 | " '''\n", 76 | " # Get the filenames of the positive/negative reviews \n", 77 | " pos_files = glob.glob(path_data + 'pos/*')\n", 78 | " neg_files = glob.glob(path_data + 'neg/*')\n", 79 | "\n", 80 | " # Concatenate both positive and negative reviews filenames\n", 81 | " filenames = pos_files + neg_files\n", 82 | " \n", 83 | " # List with all the reviews in the dataset\n", 84 | " reviews = [open(filenames[i],'r').read() for i in range(len(filenames))]\n", 85 | " \n", 86 | " # Remove HTML tags\n", 87 | " reviews = [re.sub(r'<[^>]+>', ' ', review) for review in reviews]\n", 88 | " \n", 89 | " # Tokenize each review in part\n", 90 | " reviews = [word_tokenize(review) for review in reviews]\n", 91 | " \n", 92 | " # Compute the length of each review\n", 93 | " len_reviews = [len(review) for review in reviews]\n", 94 | "\n", 95 | " # Flatten nested list\n", 96 | " reviews = [word for review in reviews for word in review]\n", 97 | " \n", 98 | " # Compute the frequency of each word\n", 99 | " word_frequency = pd.value_counts(reviews)\n", 100 | " \n", 101 | " # Keep only words with frequency higher than minimum\n", 102 | " vocabulary = word_frequency[word_frequency>=min_word_frequency].index.tolist()\n", 103 | " \n", 104 | " # Add Unknown, Start and End token. \n", 105 | " extra_tokens = ['Unknown_token', 'End_token']\n", 106 | " vocabulary += extra_tokens\n", 107 | " \n", 108 | " # Create a word2idx dictionary\n", 109 | " word2idx = {vocabulary[i]: i for i in range(len(vocabulary))}\n", 110 | " \n", 111 | " # Write word vocabulary to disk\n", 112 | " pickle.dump(word2idx, open(path_data + 'word2idx.pkl', 'wb'))\n", 113 | " \n", 114 | " def text2tfrecords(filenames, writer, vocabulary, word2idx,\n", 115 | " max_words_review):\n", 116 | " '''\n", 117 | " Function to parse each review in part and write to disk\n", 118 | " as a tfrecord.\n", 119 | " \n", 120 | " Args:\n", 121 | " filenames: the paths of the review files.\n", 122 | " writer: the writer object for tfrecords.\n", 123 | " vocabulary: list with all the words included in the vocabulary.\n", 124 | " word2idx: dictionary of words and their corresponding indexes.\n", 125 | " '''\n", 126 | " # Shuffle filenames\n", 127 | " random.shuffle(filenames)\n", 128 | " for filename in filenames:\n", 129 | " review = open(filename, 'r').read()\n", 130 | " review = re.sub(r'<[^>]+>', ' ', review)\n", 131 | " review = word_tokenize(review)\n", 132 | " # Reduce review to max words\n", 133 | " review = review[-max_words_review:]\n", 134 | " # Replace words with their equivalent index from word2idx\n", 135 | " review = [word2idx[word] if word in vocabulary else \n", 136 | " word2idx['Unknown_token'] for word in review]\n", 137 | " indexed_review = review + [word2idx['End_token']]\n", 138 | " sequence_length = len(indexed_review)\n", 139 | " target = 1 if filename.split('/')[-2]=='pos' else 0\n", 140 | " # Create a Sequence Example to store our data in\n", 141 | " ex = tf.train.SequenceExample()\n", 142 | " # Add non-sequential features to our example\n", 143 | " ex.context.feature['sequence_length'].int64_list.value.append(sequence_length)\n", 144 | " ex.context.feature['target'].int64_list.value.append(target)\n", 145 | " # Add sequential feature\n", 146 | " token_indexes = ex.feature_lists.feature_list['token_indexes']\n", 147 | " for token_index in indexed_review:\n", 148 | " token_indexes.feature.add().int64_list.value.append(token_index)\n", 149 | " writer.write(ex.SerializeToString())\n", 150 | " \n", 151 | " ########################################################################## \n", 152 | " # Write data to tfrecords.This might take a while.\n", 153 | " ##########################################################################\n", 154 | " writer = tf.python_io.TFRecordWriter(path_data + 'dummy.tfrecords')\n", 155 | " text2tfrecords(filenames, writer, vocabulary, word2idx, \n", 156 | " max_words_review)" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 5, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "imdb2tfrecords(path_data='datasets/dummy_text/')" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "### Parse TFRecords to TF tensors\n", 173 | "----" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 6, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "def parse_imdb_sequence(record):\n", 183 | " '''\n", 184 | " Script to parse imdb tfrecords.\n", 185 | " \n", 186 | " Returns:\n", 187 | " token_indexes: sequence of token indexes present in the review.\n", 188 | " target: the target of the movie review.\n", 189 | " sequence_length: the length of the sequence.\n", 190 | " '''\n", 191 | " context_features = {\n", 192 | " 'sequence_length': tf.FixedLenFeature([], dtype=tf.int64),\n", 193 | " 'target': tf.FixedLenFeature([], dtype=tf.int64),\n", 194 | " }\n", 195 | " sequence_features = {\n", 196 | " 'token_indexes': tf.FixedLenSequenceFeature([], dtype=tf.int64),\n", 197 | " }\n", 198 | " context_parsed, sequence_parsed = tf.parse_single_sequence_example(record, \n", 199 | " context_features=context_features, sequence_features=sequence_features)\n", 200 | " \n", 201 | " return (sequence_parsed['token_indexes'], context_parsed['target'],\n", 202 | " context_parsed['sequence_length'])" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "If you want me to add anything to this tutorial, please let me know and I will be happy to further enhance it :)." 210 | ] 211 | } 212 | ], 213 | "metadata": { 214 | "kernelspec": { 215 | "display_name": "Python 3", 216 | "language": "python", 217 | "name": "python3" 218 | }, 219 | "language_info": { 220 | "codemirror_mode": { 221 | "name": "ipython", 222 | "version": 3 223 | }, 224 | "file_extension": ".py", 225 | "mimetype": "text/x-python", 226 | "name": "python", 227 | "nbconvert_exporter": "python", 228 | "pygments_lexer": "ipython3", 229 | "version": "3.6.4" 230 | } 231 | }, 232 | "nbformat": 4, 233 | "nbformat_minor": 2 234 | } 235 | -------------------------------------------------------------------------------- /05_images_to_tfrecords.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# How to transfer raw image data to TFRecords\n", 8 | "----\n", 9 | "\n", 10 | "Hello everyone! This tutorial, like the previous one, is focused on automatizing the data input pipeline.\n", 11 | "\n", 12 | "Most of the time, our datasets are too big to read in memory so we have to prepare a pipeline for reading the data in batches from hard disk. I always process my raw data (text, images, tabular) to TFRecords as it makes my life so much easier hehe :).\n", 13 | "\n", 14 | "### Tutorial flowchart\n", 15 | "----\n", 16 | "![img](tutorials_graphics/images2tfrecords.png)\n", 17 | "\n", 18 | "This tutorial will cover the following parts:\n", 19 | "* *create a function that reads raw images and transfers them to TFRecords.*\n", 20 | "* *create a function that parses the TFRecords to TF tensors.*\n", 21 | "\n", 22 | "So without any further due, let's get started." 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "### Import here useful libraries\n", 30 | "----" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 2, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "import tensorflow as tf\n", 40 | "import tensorflow.contrib.eager as tfe\n", 41 | "import glob" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 3, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "# Enable eager mode. Once activated it cannot be reversed! Run just once.\n", 51 | "tfe.enable_eager_execution()" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "### Transfer raw images to TFRecords\n", 59 | "----\n", 60 | "\n", 61 | "For this task, we will be using a few images from the FER2013 dataset, that you can find in the **datasets/dummy_images** folder. The emotion label can be found in the filename of the image.\n", 62 | "For example, picture **id7_3.jpg** has the label emotion **3**, which corresponds to the state **'Happy'** as you can see in the dictionary below." 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 4, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "# Get the meaning of each emotion index\n", 72 | "emotion_cat = {0:'Angry', 1:'Disgust', 2:'Fear', 3:'Happy', 4:'Sad', 5:'Surprise', 6:'Neutral'}" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 5, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "def img2tfrecords(path_data='datasets/dummy_images/', image_format='jpeg'):\n", 82 | " ''' Function to transfer raw images, along with their \n", 83 | " target labels, to TFRecords.\n", 84 | " Original source code for helper functions: https://goo.gl/jEhp2B\n", 85 | " \n", 86 | " Args:\n", 87 | " path_data: the location of the raw images\n", 88 | " image_format: the format of the raw images (e.g. 'png', 'jpeg')\n", 89 | " '''\n", 90 | " \n", 91 | " def _int64_feature(value):\n", 92 | " '''Helper function.'''\n", 93 | " return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))\n", 94 | " \n", 95 | " def _bytes_feature(value):\n", 96 | " '''Helper function.'''\n", 97 | " return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\n", 98 | " \n", 99 | " # Get the filename of each image within the directory\n", 100 | " filenames = glob.glob(path_data + '*' + image_format)\n", 101 | " \n", 102 | " # Create a TFRecordWriter\n", 103 | " writer = tf.python_io.TFRecordWriter(path_data + 'dummy.tfrecords')\n", 104 | " \n", 105 | " # Iterate through each image and write it to the TFrecords file.\n", 106 | " for filename in filenames:\n", 107 | " # Read raw image\n", 108 | " img = tf.read_file(filename).numpy()\n", 109 | " # Parse its label from the filename\n", 110 | " label = int(filename.split('_')[-1].split('.')[0])\n", 111 | " # Create an example (image, label)\n", 112 | " example = tf.train.Example(features=tf.train.Features(feature={\n", 113 | " 'label': _int64_feature(label),\n", 114 | " 'image': _bytes_feature(img)}))\n", 115 | " # Write serialized example to TFRecords\n", 116 | " writer.write(example.SerializeToString())" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 6, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "# Transfer raw data to TFRecords\n", 126 | "img2tfrecords()" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "### Parse TFRecords to TF tensors\n", 134 | "----" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 7, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "def parser(record):\n", 144 | " '''Function to parse a TFRecords example'''\n", 145 | " \n", 146 | " # Define here the features you would like to parse\n", 147 | " features = {'image': tf.FixedLenFeature((), tf.string),\n", 148 | " 'label': tf.FixedLenFeature((), tf.int64)}\n", 149 | " \n", 150 | " # Parse example\n", 151 | " parsed = tf.parse_single_example(record, features)\n", 152 | "\n", 153 | " # Decode image \n", 154 | " img = tf.image.decode_image(parsed['image'])\n", 155 | " \n", 156 | " return img, parsed['label']\n" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "If you want me to add anything to this tutorial, please let me know and I will be happy to further enhance it :)." 164 | ] 165 | } 166 | ], 167 | "metadata": { 168 | "kernelspec": { 169 | "display_name": "Python 3", 170 | "language": "python", 171 | "name": "python3" 172 | }, 173 | "language_info": { 174 | "codemirror_mode": { 175 | "name": "ipython", 176 | "version": 3 177 | }, 178 | "file_extension": ".py", 179 | "mimetype": "text/x-python", 180 | "name": "python", 181 | "nbconvert_exporter": "python", 182 | "pygments_lexer": "ipython3", 183 | "version": "3.6.4" 184 | } 185 | }, 186 | "nbformat": 4, 187 | "nbformat_minor": 2 188 | } 189 | -------------------------------------------------------------------------------- /06_read_data_in_batches_from_tfrecords.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# How to read data in batches from TFRecords with TensorFlow Eager\n", 8 | "----\n", 9 | "\n", 10 | "Hello everyone, this tutorial is again focused on the input pipeline. It is quite simple, but I remember when I first started reading data in batches I got stuck in quite a few details so I thought that I might share my methods here. I really hope it will be useful for some of you.\n", 11 | "\n", 12 | "### Tutorials flowchart\n", 13 | "----\n", 14 | "![img](tutorials_graphics/readbatches.png)\n", 15 | "\n", 16 | "We are going to work on two cases:\n", 17 | "* **input data of variable sequence length** - in this case we will pad the batch on the fly to the biggest sequence length.\n", 18 | "* **image data**\n", 19 | "\n", 20 | "\n", 21 | "The data for both cases has been stored as TFRecords. You can have a look at the [**4th**](https://github.com/madalinabuzau/tensorflow-eager-tutorials/blob/master/04_text_data_to_tfrecords.ipynb) and [**5th**](https://github.com/madalinabuzau/tensorflow-eager-tutorials/blob/master/05_images_to_tfrecords.ipynb) tutorial to see how I transfer raw data to TFRecords.\n", 22 | "\n", 23 | "So, let's jump right into coding :)!" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "### Import here useful libraries\n", 31 | "----" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 2, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "# Import library for data visualization\n", 41 | "import matplotlib.pyplot as plt\n", 42 | "\n", 43 | "# Make the plots appear inline in the notebook\n", 44 | "%matplotlib inline\n", 45 | "\n", 46 | "# Import TensorFlow and TensorFlow Eager\n", 47 | "import tensorflow as tf\n", 48 | "import tensorflow.contrib.eager as tfe" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 3, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "# Enable eager mode. Once activated it cannot be reversed! Run just once.\n", 58 | "tfe.enable_eager_execution()" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "### Part 1: Reading data of variable sequence length\n", 66 | "----\n", 67 | "The first part of this tutorial shows you how to read input data that comes in different lengths. In our case, we used dummy IMDB reviews from the Large Movie Database. As you can imagine, each review has a different number of words. Therefore, when we will be reading a batch of data we will pad the sequences to the maximum sequence length within a batch.\n", 68 | "\n", 69 | "To see how I obtained sequences of word indexes, along with the label and the sequence length please see [this tutorial](https://github.com/madalinabuzau/tensorflow-eager-tutorials/blob/master/04_text_data_to_tfrecords.ipynb)." 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "### 1.1. Create function to parse each TFRecord\n", 77 | "----" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 4, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [ 86 | "def parse_imdb_sequence(record):\n", 87 | " '''\n", 88 | " Script to parse imdb tfrecords.\n", 89 | " \n", 90 | " Returns:\n", 91 | " token_indexes: sequence of token indexes present in the review.\n", 92 | " target: the target of the movie review.\n", 93 | " sequence_length: the length of the sequence.\n", 94 | " '''\n", 95 | " context_features = {\n", 96 | " 'sequence_length': tf.FixedLenFeature([], dtype=tf.int64),\n", 97 | " 'target': tf.FixedLenFeature([], dtype=tf.int64),\n", 98 | " }\n", 99 | " sequence_features = {\n", 100 | " 'token_indexes': tf.FixedLenSequenceFeature([], dtype=tf.int64),\n", 101 | " }\n", 102 | " context_parsed, sequence_parsed = tf.parse_single_sequence_example(record, \n", 103 | " context_features=context_features, sequence_features=sequence_features)\n", 104 | " \n", 105 | " return (sequence_parsed['token_indexes'], context_parsed['target'],\n", 106 | " context_parsed['sequence_length'])" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "### 1.2. Create dataset iterator\n", 114 | "----\n", 115 | "\n", 116 | "As you can see in the function above, after parsing each record, we return a sequence of word indexes, the target of the review and the sequence length. In the method *padded_batch* we only pad the first element of the record: the sequence of word indexes. The target and sequence length do not need to be padded as they are just a single number, in each example. Thus, the padded_shapes will be:\n", 117 | "* [None] -> pad the sequences to the largest dimension, unknown yet, therefore None.\n", 118 | "* [ ] -> no padding for the target.\n", 119 | "* [ ] -> no padding for the sequence length.\n" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 5, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "# Select here the batch size\n", 129 | "batch_size = 2\n", 130 | "\n", 131 | "# Create dataset from TFRecords\n", 132 | "dataset = tf.data.TFRecordDataset('datasets/dummy_text/dummy.tfrecords')\n", 133 | "dataset = dataset.map(parse_imdb_sequence).shuffle(buffer_size=10000)\n", 134 | "dataset = dataset.padded_batch(batch_size, padded_shapes=([None],[],[]))" 135 | ] 136 | }, 137 | { 138 | "cell_type": "markdown", 139 | "metadata": {}, 140 | "source": [ 141 | "### 1.3. Iterate through data once \n", 142 | "----" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 6, 148 | "metadata": {}, 149 | "outputs": [ 150 | { 151 | "name": "stdout", 152 | "output_type": "stream", 153 | "text": [ 154 | "tf.Tensor([0 1], shape=(2,), dtype=int64)\n", 155 | "tf.Tensor([1 0], shape=(2,), dtype=int64)\n", 156 | "tf.Tensor([0 1], shape=(2,), dtype=int64)\n" 157 | ] 158 | } 159 | ], 160 | "source": [ 161 | "for review, target, sequence_length in tfe.Iterator(dataset):\n", 162 | " print(target)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 7, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "name": "stdout", 172 | "output_type": "stream", 173 | "text": [ 174 | "(2, 145)\n", 175 | "(2, 139)\n", 176 | "(2, 171)\n" 177 | ] 178 | } 179 | ], 180 | "source": [ 181 | "for review, target, sequence_length in tfe.Iterator(dataset):\n", 182 | " print(review.shape)" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": 8, 188 | "metadata": {}, 189 | "outputs": [ 190 | { 191 | "name": "stdout", 192 | "output_type": "stream", 193 | "text": [ 194 | "tf.Tensor([137 151], shape=(2,), dtype=int64)\n", 195 | "tf.Tensor([139 171], shape=(2,), dtype=int64)\n", 196 | "tf.Tensor([145 124], shape=(2,), dtype=int64)\n" 197 | ] 198 | } 199 | ], 200 | "source": [ 201 | "for review, target, sequence_length in tfe.Iterator(dataset):\n", 202 | " print(sequence_length)" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "### Part 2: Read images (and their labels) in batches\n", 210 | "----\n", 211 | "\n", 212 | "In the second part of the tutorial, we are going to visualize the images stored as TFRecords, by reading them in batches. These images are a small subsample from the FER2013 dataset." 213 | ] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "### 2.1. Create function to parse each record and decode image\n", 220 | "----" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": 9, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [ 229 | "def parser(record):\n", 230 | " '''\n", 231 | " Function to parse a TFRecords example. \n", 232 | " \n", 233 | " Returns:\n", 234 | " img: decoded image.\n", 235 | " label: the corresponding label of the image. \n", 236 | " '''\n", 237 | " \n", 238 | " # Define here the features you would like to parse\n", 239 | " features = {'image': tf.FixedLenFeature((), tf.string),\n", 240 | " 'label': tf.FixedLenFeature((), tf.int64)}\n", 241 | " \n", 242 | " # Parse example\n", 243 | " parsed = tf.parse_single_example(record, features)\n", 244 | "\n", 245 | " # Decode image \n", 246 | " img = tf.image.decode_image(parsed['image'])\n", 247 | " \n", 248 | " return img, parsed['label']" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "### 2.2. Create dataset iterator\n", 256 | "----" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": 10, 262 | "metadata": {}, 263 | "outputs": [], 264 | "source": [ 265 | "# Select here the batch size\n", 266 | "batch_size = 5\n", 267 | "\n", 268 | "# Create dataset from TFRecords\n", 269 | "dataset = tf.data.TFRecordDataset('datasets/dummy_images/dummy.tfrecords')\n", 270 | "dataset = dataset.map(parser).shuffle(buffer_size=10000)\n", 271 | "dataset = dataset.batch(batch_size)" 272 | ] 273 | }, 274 | { 275 | "cell_type": "markdown", 276 | "metadata": {}, 277 | "source": [ 278 | "### 2.3. Iterate through dataset once. Visualize images." 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": 11, 284 | "metadata": {}, 285 | "outputs": [ 286 | { 287 | "data": { 288 | "image/png": "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\n", 289 | "text/plain": [ 290 | "" 291 | ] 292 | }, 293 | "metadata": {}, 294 | "output_type": "display_data" 295 | }, 296 | { 297 | "data": { 298 | "image/png": "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\n", 299 | "text/plain": [ 300 | "" 301 | ] 302 | }, 303 | "metadata": {}, 304 | "output_type": "display_data" 305 | } 306 | ], 307 | "source": [ 308 | "# Dictionary that stores the correspondence between integer labels and the emotions\n", 309 | "emotion_cat = {0:'Angry', 1:'Disgust', 2:'Fear', 3:'Happy', 4:'Sad', 5:'Surprise', 6:'Neutral'}\n", 310 | "\n", 311 | "# Go through the dataset once\n", 312 | "for image, label in tfe.Iterator(dataset):\n", 313 | " # Create a subplot for each batch of images\n", 314 | " f, axarr = plt.subplots(1, int(image.shape[0]), figsize=(14, 6))\n", 315 | " # Plot images\n", 316 | " for i in range(image.shape[0]):\n", 317 | " axarr[i].imshow(image[i,:,:,0], cmap='gray')\n", 318 | " axarr[i].set_title('Emotion: %s' %emotion_cat[label[i].numpy()])" 319 | ] 320 | }, 321 | { 322 | "cell_type": "markdown", 323 | "metadata": {}, 324 | "source": [ 325 | "Please let me know if you would like me to add anything to this tutorial. I will do my best to add it :)!" 326 | ] 327 | } 328 | ], 329 | "metadata": { 330 | "kernelspec": { 331 | "display_name": "Python 3", 332 | "language": "python", 333 | "name": "python3" 334 | }, 335 | "language_info": { 336 | "codemirror_mode": { 337 | "name": "ipython", 338 | "version": 3 339 | }, 340 | "file_extension": ".py", 341 | "mimetype": "text/x-python", 342 | "name": "python", 343 | "nbconvert_exporter": "python", 344 | "pygments_lexer": "ipython3", 345 | "version": "3.6.4" 346 | } 347 | }, 348 | "nbformat": 4, 349 | "nbformat_minor": 2 350 | } 351 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Simple tutorials on deep learning using TensorFlow Eager 2 | 3 | This repo aims to help people who would like to start getting hands-on experience with deep learning using the TensorFlow Eager mode. TensorFlow Eager mode lets you build neural networks as easy as you would do with Numpy, with the huge advantage that it provides automatic differentiation (no more handwritten backprop. YAAAY!). It can ran also on GPUs making the neural networks training significantly faster. 4 | 5 | I will try to make the tutorials accessible for everyone, thus I will try to work on problems that do not require a GPU to work on. 6 | 7 | **TensorFlow Version used in the tutorials - 1.7** 8 | 9 | ### List of tutorials available: 10 | #### Getting started 11 | --- 12 | * **01. Build a simple neural network** - This tutorial shows you how to build and train a one-hidden layer neural network using the Eager mode of TensorFlow, on a synthetically generated dataset. 13 | 14 | 15 | * **02. Using metrics in Eager mode** - This tutorial shows you how to use metrics 16 | that are compatible with Eager mode, for three types of machine learning problems (multi-classification, imbalanced dataset and regression). 17 | 18 | 19 | #### Simple but useful stuff 20 | --- 21 | * **03. Save and restore a trained model** - Simple tutorial on how you can save a trained model and restore it at a later time to make predictions on new data. 22 | 23 | 24 | * **04. Transfer text data to TFRecords** - This tutorial shows you how to store text data of variable sequence length to TFRecords. The data can be easily padded 25 | on the fly, within a batch, when reading the dataset with an iterator. 26 | 27 | 28 | * **05. Transfer image data to TFRecords** - Easy and simple tutorial on how to transfew image data and its metadata (e.g. target) to TFRecords. 29 | 30 | 31 | * **06. How to read TFRecords data in batches** - This tutorial shows you how to read either variable length sequence data or image data, in batches, from TFRecords. 32 | 33 | 34 | #### Convolutional neural networks 35 | ---- 36 | * **07. Build a CNN for emotion recognition** - This tutorial shows you how to build a CNN from scratch using the TensorFlow Eager API and the FER2013 dataset. At the end of the tutorial you will be able to test the network on yourself using a webcam. Very fun exercise! 37 | 38 | 39 | #### Recurrent neural networks 40 | ---- 41 | * **08. Build a dynamic RNN for sequence classification** - Learn how to work with variable sequence input data. This tutorial shows you how to build a dynamic RNN using the TensorFlow Eager API and the Stanford Large Movie Review Dataset. 42 | 43 | 44 | * **09. Build a RNN for time series regression** - Learn how to build a RNN for timeseries forecasting. 45 | 46 | 47 | 48 | Requests for tutorials: 49 | ---- 50 | * If you have any requests for a specific tutorial please let me know. 51 | 52 | Improvement advice: 53 | ---- 54 | * Please let me know if you have any suggestions to improve these tutorials. The aim is to help you getting a good grasp of this framework but I am also looking to improve my programming skills so any feedback will be really appreciated :)! 55 | -------------------------------------------------------------------------------- /data_utils.py: -------------------------------------------------------------------------------- 1 | ''' 2 | This script contains several functions used for data processing. 3 | ''' 4 | 5 | ############################################################################# 6 | # Import here useful libraries 7 | ############################################################################# 8 | from nltk.tokenize import word_tokenize 9 | import tensorflow as tf 10 | import pandas as pd 11 | import pickle 12 | import random 13 | import glob 14 | import nltk 15 | import re 16 | 17 | try: 18 | nltk.data.find('tokenizers/punkt') 19 | except LookupError: 20 | nltk.download('punkt') 21 | 22 | 23 | def imdb2tfrecords(path_data='datasets/aclImdb/', min_word_frequency=5, 24 | max_words_review=700): 25 | ''' 26 | This script processes the data and saves it in the default TensorFlow 27 | file format: tfrecords. 28 | 29 | Args: 30 | path_data: the path where the imdb data is stored. 31 | min_word_frequency: the minimum frequency of a word, to keep it 32 | in the vocabulary. 33 | max_words_review: the maximum number of words allowed in a review. 34 | ''' 35 | # Get the filenames of the positive/negative reviews we will use 36 | # for training the RNN 37 | train_pos_files = glob.glob(path_data + 'train/pos/*') 38 | train_neg_files = glob.glob(path_data + 'train/neg/*') 39 | 40 | # Concatenate both positive and negative reviews filenames 41 | train_files = train_pos_files + train_neg_files 42 | 43 | # List with all the reviews in the train dataset 44 | reviews = [open(train_files[i],'r').read() for i in range(len(train_files))] 45 | 46 | # Remove HTML tags 47 | reviews = [re.sub(r'<[^>]+>', ' ', review) for review in reviews] 48 | 49 | # Tokenize each review in part 50 | reviews = [word_tokenize(review) for review in reviews] 51 | 52 | # Compute the length of each review 53 | len_reviews = [len(review) for review in reviews] 54 | pickle.dump(len_reviews, open(path_data + 'length_reviews.pkl', 'wb')) 55 | 56 | # Flatten nested list 57 | reviews = [word for review in reviews for word in review] 58 | 59 | # Compute the frequency of each word 60 | word_frequency = pd.value_counts(reviews) 61 | 62 | # Keep only words with frequency higher than minimum 63 | vocabulary = word_frequency[word_frequency>=min_word_frequency].index.tolist() 64 | 65 | # Add Unknown, Start and End token. 66 | extra_tokens = ['Unknown_token', 'End_token'] 67 | vocabulary += extra_tokens 68 | 69 | # Create a word2idx dictionary 70 | word2idx = {vocabulary[i]: i for i in range(len(vocabulary))} 71 | 72 | # Write word vocabulary to disk 73 | pickle.dump(word2idx, open(path_data + 'word2idx.pkl', 'wb')) 74 | 75 | def text2tfrecords(filenames, writer, vocabulary, word2idx, 76 | max_words_review): 77 | ''' 78 | Function to parse each review in part and write to disk 79 | as a tfrecord. 80 | 81 | Args: 82 | filenames: the paths of the review files. 83 | writer: the writer object for tfrecords. 84 | vocabulary: list with all the words included in the vocabulary. 85 | word2idx: dictionary of words and their corresponding indexes. 86 | ''' 87 | # Shuffle filenames 88 | random.shuffle(filenames) 89 | for filename in filenames: 90 | review = open(filename, 'r').read() 91 | review = re.sub(r'<[^>]+>', ' ', review) 92 | review = word_tokenize(review) 93 | # Reduce review to max words 94 | review = review[-max_words_review:] 95 | # Replace words with their equivalent index from word2idx 96 | review = [word2idx[word] if word in vocabulary else 97 | word2idx['Unknown_token'] for word in review] 98 | indexed_review = review + [word2idx['End_token']] 99 | sequence_length = len(indexed_review) 100 | target = 1 if filename.split('/')[-2]=='pos' else 0 101 | # Create a Sequence Example to store our data in 102 | ex = tf.train.SequenceExample() 103 | # Add non-sequential features to our example 104 | ex.context.feature['sequence_length'].int64_list.value.append(sequence_length) 105 | ex.context.feature['target'].int64_list.value.append(target) 106 | # Add sequential feature 107 | token_indexes = ex.feature_lists.feature_list['token_indexes'] 108 | for token_index in indexed_review: 109 | token_indexes.feature.add().int64_list.value.append(token_index) 110 | writer.write(ex.SerializeToString()) 111 | 112 | ########################################################################## 113 | # Write train data to tfrecords.This might take a while (~10 minutes) 114 | ########################################################################## 115 | train_writer = tf.python_io.TFRecordWriter(path_data + 'train.tfrecords') 116 | text2tfrecords(train_files, train_writer, vocabulary, word2idx, 117 | max_words_review) 118 | 119 | ########################################################################## 120 | # Get the filenames of the reviews we will use for testing the RNN 121 | ########################################################################## 122 | test_pos_files = glob.glob(path_data + 'test/pos/*') 123 | test_neg_files = glob.glob(path_data + 'test/neg/*') 124 | test_files = test_pos_files + test_neg_files 125 | 126 | ########################################################################## 127 | # Write test data to tfrecords (~10 minutes) 128 | ########################################################################## 129 | test_writer = tf.python_io.TFRecordWriter('datasets/aclImdb/test.tfrecords') 130 | text2tfrecords(test_files, test_writer, vocabulary, word2idx, 131 | max_words_review) 132 | 133 | 134 | def parse_imdb_sequence(record): 135 | ''' 136 | Script to parse imdb tfrecords. 137 | 138 | Returns: 139 | token_indexes: sequence of token indexes present in the review. 140 | target: the target of the movie review. 141 | sequence_length: the length of the sequence. 142 | ''' 143 | context_features = { 144 | 'sequence_length': tf.FixedLenFeature([], dtype=tf.int64), 145 | 'target': tf.FixedLenFeature([], dtype=tf.int64), 146 | } 147 | sequence_features = { 148 | 'token_indexes': tf.FixedLenSequenceFeature([], dtype=tf.int64), 149 | } 150 | context_parsed, sequence_parsed = tf.parse_single_sequence_example(record, 151 | context_features=context_features, sequence_features=sequence_features) 152 | 153 | return (sequence_parsed['token_indexes'], context_parsed['target'], 154 | context_parsed['sequence_length']) 155 | 156 | 157 | 158 | -------------------------------------------------------------------------------- /datasets/aclImdb/length_reviews.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/aclImdb/length_reviews.pkl -------------------------------------------------------------------------------- /datasets/aclImdb/test.tfrecords: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/aclImdb/test.tfrecords -------------------------------------------------------------------------------- /datasets/aclImdb/train.tfrecords: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/aclImdb/train.tfrecords -------------------------------------------------------------------------------- /datasets/aclImdb/word2idx.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/aclImdb/word2idx.pkl -------------------------------------------------------------------------------- /datasets/dummy_images/dummy.tfrecords: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/dummy.tfrecords -------------------------------------------------------------------------------- /datasets/dummy_images/id0_0.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id0_0.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id1_0.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id1_0.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id2_2.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id2_2.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id3_4.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id3_4.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id4_6.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id4_6.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id5_2.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id5_2.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id6_4.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id6_4.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id7_3.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id7_3.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id8_3.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id8_3.jpeg -------------------------------------------------------------------------------- /datasets/dummy_images/id9_2.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_images/id9_2.jpeg -------------------------------------------------------------------------------- /datasets/dummy_text/dummy.tfrecords: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_text/dummy.tfrecords -------------------------------------------------------------------------------- /datasets/dummy_text/neg/0_3.txt: -------------------------------------------------------------------------------- 1 | Story of a man who has unnatural feelings for a pig. Starts out with a opening scene that is a terrific example of absurd comedy. A formal orchestra audience is turned into an insane, violent mob by the crazy chantings of it's singers. Unfortunately it stays absurd the WHOLE time with no general narrative eventually making it just too off putting. Even those from the era should be turned off. The cryptic dialogue would make Shakespeare seem easy to a third grader. On a technical level it's better than you might think with some good cinematography by future great Vilmos Zsigmond. Future stars Sally Kirkland and Frederic Forrest can be seen briefly. -------------------------------------------------------------------------------- /datasets/dummy_text/neg/1_1.txt: -------------------------------------------------------------------------------- 1 | Robert DeNiro plays the most unbelievably intelligent illiterate of all time. This movie is so wasteful of talent, it is truly disgusting. The script is unbelievable. The dialog is unbelievable. Jane Fonda's character is a caricature of herself, and not a funny one. The movie moves at a snail's pace, is photographed in an ill-advised manner, and is insufferably preachy. It also plugs in every cliche in the book. Swoozie Kurtz is excellent in a supporting role, but so what?

Equally annoying is this new IMDB rule of requiring ten lines for every review. When a movie is this worthless, it doesn't require ten lines of text to let other readers know that it is a waste of time and tape. Avoid this movie. -------------------------------------------------------------------------------- /datasets/dummy_text/neg/2_1.txt: -------------------------------------------------------------------------------- 1 | I saw the capsule comment said "great acting." In my opinion, these are two great actors giving horrible performances, and with zero chemistry with one another, for a great director in his all-time worst effort. Robert De Niro has to be the most ingenious and insightful illiterate of all time. Jane Fonda's performance uncomfortably drifts all over the map as she clearly has no handle on this character, mostly because the character is so poorly written. Molasses-like would be too swift an adjective for this film's excruciating pacing. Although the film's intent is to be an uplifting story of curing illiteracy, watching it is a true "bummer." I give it 1 out of 10, truly one of the worst 20 movies for its budget level that I have ever seen. -------------------------------------------------------------------------------- /datasets/dummy_text/pos/0_9.txt: -------------------------------------------------------------------------------- 1 | Bromwell High is a cartoon comedy. It ran at the same time as some other programs about school life, such as "Teachers". My 35 years in the teaching profession lead me to believe that Bromwell High's satire is much closer to reality than is "Teachers". The scramble to survive financially, the insightful students who can see right through their pathetic teachers' pomp, the pettiness of the whole situation, all remind me of the schools I knew and their students. When I saw the episode in which a student repeatedly tried to burn down the school, I immediately recalled ......... at .......... High. A classic line: INSPECTOR: I'm here to sack one of your teachers. STUDENT: Welcome to Bromwell High. I expect that many adults of my age think that Bromwell High is far fetched. What a pity that it isn't! -------------------------------------------------------------------------------- /datasets/dummy_text/pos/1_7.txt: -------------------------------------------------------------------------------- 1 | If you like adult comedy cartoons, like South Park, then this is nearly a similar format about the small adventures of three teenage girls at Bromwell High. Keisha, Natella and Latrina have given exploding sweets and behaved like bitches, I think Keisha is a good leader. There are also small stories going on with the teachers of the school. There's the idiotic principal, Mr. Bip, the nervous Maths teacher and many others. The cast is also fantastic, Lenny Henry's Gina Yashere, EastEnders Chrissie Watts, Tracy-Ann Oberman, Smack The Pony's Doon Mackichan, Dead Ringers' Mark Perry and Blunder's Nina Conti. I didn't know this came from Canada, but it is very good. Very good! -------------------------------------------------------------------------------- /datasets/dummy_text/pos/2_9.txt: -------------------------------------------------------------------------------- 1 | Bromwell High is nothing short of brilliant. Expertly scripted and perfectly delivered, this searing parody of a students and teachers at a South London Public School leaves you literally rolling with laughter. It's vulgar, provocative, witty and sharp. The characters are a superbly caricatured cross section of British society (or to be more accurate, of any society). Following the escapades of Keisha, Latrina and Natella, our three "protagonists" for want of a better term, the show doesn't shy away from parodying every imaginable subject. Political correctness flies out the window in every episode. If you enjoy shows that aren't afraid to poke fun of every taboo subject imaginable, then Bromwell High will not disappoint! -------------------------------------------------------------------------------- /datasets/dummy_text/word2idx.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/datasets/dummy_text/word2idx.pkl -------------------------------------------------------------------------------- /datasets/get_imdb_dataset.sh: -------------------------------------------------------------------------------- 1 | # Get the IMDB sentiment analysis dataset 2 | wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz 3 | # Unzip the file 4 | tar -xzvf aclImdb_v1.tar.gz 5 | # Remove the archive 6 | rm aclImdb_v1.tar.gz 7 | -------------------------------------------------------------------------------- /models_checkpoints/DemandRNN/-0.data-00000-of-00001: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/DemandRNN/-0.data-00000-of-00001 -------------------------------------------------------------------------------- /models_checkpoints/DemandRNN/-0.index: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/DemandRNN/-0.index -------------------------------------------------------------------------------- /models_checkpoints/DemandRNN/checkpoint: -------------------------------------------------------------------------------- 1 | model_checkpoint_path: "-0" 2 | all_model_checkpoint_paths: "-0" 3 | -------------------------------------------------------------------------------- /models_checkpoints/EmotionCNN/-0.data-00000-of-00001: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/EmotionCNN/-0.data-00000-of-00001 -------------------------------------------------------------------------------- /models_checkpoints/EmotionCNN/-0.index: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/EmotionCNN/-0.index -------------------------------------------------------------------------------- /models_checkpoints/EmotionCNN/checkpoint: -------------------------------------------------------------------------------- 1 | model_checkpoint_path: "-0" 2 | all_model_checkpoint_paths: "-0" 3 | -------------------------------------------------------------------------------- /models_checkpoints/ImdbRNN/-0.data-00000-of-00001: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/ImdbRNN/-0.data-00000-of-00001 -------------------------------------------------------------------------------- /models_checkpoints/ImdbRNN/-0.index: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/ImdbRNN/-0.index -------------------------------------------------------------------------------- /models_checkpoints/ImdbRNN/checkpoint: -------------------------------------------------------------------------------- 1 | model_checkpoint_path: "-0" 2 | all_model_checkpoint_paths: "-0" 3 | -------------------------------------------------------------------------------- /models_checkpoints/SimpleNN/-1.data-00000-of-00001: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/SimpleNN/-1.data-00000-of-00001 -------------------------------------------------------------------------------- /models_checkpoints/SimpleNN/-1.index: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/models_checkpoints/SimpleNN/-1.index -------------------------------------------------------------------------------- /models_checkpoints/SimpleNN/checkpoint: -------------------------------------------------------------------------------- 1 | model_checkpoint_path: "-1" 2 | all_model_checkpoint_paths: "-1" 3 | -------------------------------------------------------------------------------- /tutorials_graphics/01_flowchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/01_flowchart.png -------------------------------------------------------------------------------- /tutorials_graphics/02_flowchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/02_flowchart.png -------------------------------------------------------------------------------- /tutorials_graphics/03_flowchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/03_flowchart.png -------------------------------------------------------------------------------- /tutorials_graphics/04_flowchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/04_flowchart.png -------------------------------------------------------------------------------- /tutorials_graphics/05_flowchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/05_flowchart.png -------------------------------------------------------------------------------- /tutorials_graphics/images2tfrecords.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/images2tfrecords.png -------------------------------------------------------------------------------- /tutorials_graphics/moving_windows_samples.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/moving_windows_samples.png -------------------------------------------------------------------------------- /tutorials_graphics/readbatches.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/readbatches.png -------------------------------------------------------------------------------- /tutorials_graphics/rnn_imdb.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/rnn_imdb.png -------------------------------------------------------------------------------- /tutorials_graphics/rnn_regression.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/rnn_regression.png -------------------------------------------------------------------------------- /tutorials_graphics/save_restore_model.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/save_restore_model.png -------------------------------------------------------------------------------- /tutorials_graphics/text2tfrecords.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/madalinabuzau/tensorflow-eager-tutorials/383950cc8b7c9b99217b5edf268e623fcec4932f/tutorials_graphics/text2tfrecords.png --------------------------------------------------------------------------------