├── .gitignore ├── Create custom layer.ipynb ├── Graph Mode vs Eager Mode.ipynb ├── Introduction - Simple Neural Network.ipynb ├── Quick Draw CNN.ipynb ├── README.md ├── RNN - Text Generator.ipynb ├── Subclassing API.ipynb ├── Train a model.ipynb ├── images ├── architecture_rnn.png ├── categorical_cross_entropy.gif ├── cnn.png ├── rnn_letter.png ├── rnn_vocab.png └── simple_nn.png ├── others ├── Simple neural network Saved.ipynb ├── Simple neural network-Error-Function.ipynb ├── Simple neural network-Normalized.ipynb ├── Simple neural network-Validation-Test.ipynb └── Simple neural network.ipynb └── rnn_dataset └── victorhugo.txt /.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 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | 106 | quick_draw_dataset/ 107 | -------------------------------------------------------------------------------- /Create custom layer.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Create your own layer\n", 8 | "\n", 9 | "We are going to create a cusom layer. The goal of this layer is to create a multi layer perceptron. By doing so, we can also learn how to use some low level operation with tensorflow 2.0." 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "import tensorflow as tf\n", 19 | "import numpy as np" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "## Be sure to used Tensorflow 2.0" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 2, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "## Multi Layer Perceptron\n", 43 | "\n", 44 | "This layer has no real purpose and should never be used in production. This is just an example to show how to create a custom layer. " 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 26, 50 | "metadata": {}, 51 | "outputs": [ 52 | { 53 | "data": { 54 | "text/plain": [ 55 | "array([[0.5, 0.5],\n", 56 | " [0.5, 0.5],\n", 57 | " [0.5, 0.5],\n", 58 | " [0.5, 0.5],\n", 59 | " [0.5, 0.5]], dtype=float32)" 60 | ] 61 | }, 62 | "execution_count": 26, 63 | "metadata": {}, 64 | "output_type": "execute_result" 65 | } 66 | ], 67 | "source": [ 68 | "class MlpLayer(tf.keras.layers.Layer):\n", 69 | "\n", 70 | " def __init__(self, units, activations, **kwargs):\n", 71 | " super(MlpLayer, self).__init__(**kwargs)\n", 72 | " # Set the property to the layer\n", 73 | " self.units = units\n", 74 | " self.activations_list = activations\n", 75 | " self.weights_list = []\n", 76 | "\n", 77 | " # The build method will be called once\n", 78 | " # we know the shape of the previous Layer: input_shape\n", 79 | " def build(self, input_shape):\n", 80 | " # Create trainable weights variables for this layer.\n", 81 | " # We create matrix of weights for each layer\n", 82 | " # Each weight have this shape: (previous_layer_size, layer_size)\n", 83 | " i = 0\n", 84 | " for units in self.units:\n", 85 | " weights = self.add_weight(\n", 86 | " name='weights-%s' % i,\n", 87 | " shape=(input_shape[1], units),\n", 88 | " initializer='uniform',\n", 89 | " trainable=True\n", 90 | " )\n", 91 | " i += 1\n", 92 | " self.weights_list.append(weights)\n", 93 | " input_shape = (None, units)\n", 94 | " super(MlpLayer, self).build(input_shape)\n", 95 | " \n", 96 | " def call(self, x):\n", 97 | " output = x\n", 98 | "\n", 99 | " # We go through each weight to compute the dot product between the previous\n", 100 | " # activation and the weight of the layer.\n", 101 | " # At the first pass, the previous activation is just the variable \"x\": The input vector\n", 102 | " for weights, activation in zip(self.weights_list, self.activations_list):\n", 103 | " # We can still used low level operations as tf.matmul, tf.nn.relu... \n", 104 | " output = tf.matmul(output, weights)\n", 105 | "\n", 106 | " if activation == \"relu\":\n", 107 | " output = tf.nn.relu(output)\n", 108 | " elif activation == \"sigmoid\":\n", 109 | " output = tf.nn.sigmoid(output)\n", 110 | " elif activation == \"softmax\":\n", 111 | " output = tf.nn.softmax(output)\n", 112 | " \n", 113 | " return output\n", 114 | "\n", 115 | " # By adding the get_config method you can then save your model with the custom layer\n", 116 | " # and retrieve the model with the same parameters\n", 117 | " def get_config(self):\n", 118 | " config = {\n", 119 | " 'units': self.units,\n", 120 | " \"activations\": self.activations_list\n", 121 | " }\n", 122 | " # Retrieve the config from the parent layer\n", 123 | " base_config = super(MlpLayer, self).get_config()\n", 124 | " # Return the final config\n", 125 | " return dict(list(base_config.items()) + list(config.items()))\n", 126 | "\n", 127 | "# Flatten\n", 128 | "model = tf.keras.models.Sequential()\n", 129 | "\n", 130 | "# Add the layers\n", 131 | "model.add(MlpLayer([4 , 2], [\"relu\", \"softmax\"]))\n", 132 | "model.predict(np.zeros((5, 10)))" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 27, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [ 141 | "model.save(\"custom_layer_in_model.h5\")" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 28, 147 | "metadata": {}, 148 | "outputs": [ 149 | { 150 | "name": "stderr", 151 | "output_type": "stream", 152 | "text": [ 153 | "W0302 09:41:52.265264 139932001146688 hdf5_format.py:224] No training configuration found in save file: the model was *not* compiled. Compile it manually.\n" 154 | ] 155 | } 156 | ], 157 | "source": [ 158 | "custom_objects={'MlpLayer': MlpLayer}\n", 159 | "loaded_model = tf.keras.models.load_model(\"custom_layer_in_model.h5\", custom_objects=custom_objects)" 160 | ] 161 | } 162 | ], 163 | "metadata": { 164 | "kernelspec": { 165 | "display_name": "Python 3", 166 | "language": "python", 167 | "name": "python3" 168 | }, 169 | "language_info": { 170 | "codemirror_mode": { 171 | "name": "ipython", 172 | "version": 3 173 | }, 174 | "file_extension": ".py", 175 | "mimetype": "text/x-python", 176 | "name": "python", 177 | "nbconvert_exporter": "python", 178 | "pygments_lexer": "ipython3", 179 | "version": "3.6.7" 180 | } 181 | }, 182 | "nbformat": 4, 183 | "nbformat_minor": 2 184 | } 185 | -------------------------------------------------------------------------------- /Graph Mode vs Eager Mode.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Eager Mode" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 2, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "Limited tf.compat.v2.summary API due to missing TensorBoard installation\n", 20 | "Limited tf.summary API due to missing TensorBoard installation\n" 21 | ] 22 | } 23 | ], 24 | "source": [ 25 | "import tensorflow as tf\n", 26 | "import numpy as np" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "Everything is eager by default in tensorflow 2.0" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 8, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "data": { 43 | "text/plain": [ 44 | "" 45 | ] 46 | }, 47 | "execution_count": 8, 48 | "metadata": {}, 49 | "output_type": "execute_result" 50 | } 51 | ], 52 | "source": [ 53 | "a = np.array([1., 2.])\n", 54 | "b = np.array([2., 5.])\n", 55 | "\n", 56 | "tf.add(a, b)" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "## Graph Model : AutoGraph\n", 64 | "As tensorflow suggest (https://www.youtube.com/watch?v=jh4ITuOytE4), we can use Autograph to automatically convert eager function to graph function by using the tf.function decorator\n", 65 | "\n", 66 | "The following code first compiles inside the function into graph code before to execute it. Note that if you remove the @tf.function decorator the code will work perfectly but will not be executed in graph mode." 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 9, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "tf.Tensor([3. 7.], shape=(2,), dtype=float64)\n" 79 | ] 80 | } 81 | ], 82 | "source": [ 83 | "@tf.function\n", 84 | "def add_fc(a, b):\n", 85 | " return tf.add(a, b)\n", 86 | "\n", 87 | "print (add_fc(a, b))" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "The following code show the code generated to create the graph" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 11, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "name": "stdout", 104 | "output_type": "stream", 105 | "text": [ 106 | "from __future__ import print_function\n", 107 | "\n", 108 | "def tf__add_fc(a, b):\n", 109 | " try:\n", 110 | " with ag__.function_scope('add_fc'):\n", 111 | " do_return = False\n", 112 | " retval_ = None\n", 113 | " do_return = True\n", 114 | " retval_ = ag__.converted_call('add', tf, ag__.ConversionOptions(recursive=True, verbose=0, strip_decorators=(ag__.convert, ag__.do_not_convert, ag__.converted_call), force_conversion=False, optional_features=ag__.Feature.ALL, internal_convert_user_code=True), (a, b), {})\n", 115 | " return retval_\n", 116 | " except:\n", 117 | " ag__.rewrite_graph_construction_error(ag_source_map__)\n", 118 | "\n", 119 | "\n", 120 | "\n", 121 | "tf__add_fc.autograph_info__ = {}\n", 122 | "\n" 123 | ] 124 | } 125 | ], 126 | "source": [ 127 | "def add_fc(a, b):\n", 128 | " return tf.add(a, b)\n", 129 | "\n", 130 | "print(tf.autograph.to_code(add_fc))" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "# Graph mode and eager mode with a keras model" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 23, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [ 146 | "# Flatten\n", 147 | "model = tf.keras.models.Sequential()\n", 148 | "# Add layers\n", 149 | "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n", 150 | "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n", 151 | "model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "By calling model.predict you get a numpy array but the output is not differentiable" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 24, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "data": { 168 | "text/plain": [ 169 | "array([[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]], dtype=float32)" 170 | ] 171 | }, 172 | "execution_count": 24, 173 | "metadata": {}, 174 | "output_type": "execute_result" 175 | } 176 | ], 177 | "source": [ 178 | "model_output = model.predict(np.zeros((1, 30)))\n", 179 | "model_output" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "By calling model(), eager execution is used and the output is differentiable" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 25, 192 | "metadata": {}, 193 | "outputs": [ 194 | { 195 | "data": { 196 | "text/plain": [ 197 | "" 198 | ] 199 | }, 200 | "execution_count": 25, 201 | "metadata": {}, 202 | "output_type": "execute_result" 203 | } 204 | ], 205 | "source": [ 206 | "model_output = model(np.zeros((1, 30)))\n", 207 | "model_output" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "Of course, you can execute the model in graph mode by using the @tf.function decorator" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 28, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "name": "stdout", 224 | "output_type": "stream", 225 | "text": [ 226 | "tf.Tensor([[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]], shape=(1, 10), dtype=float32)\n" 227 | ] 228 | } 229 | ], 230 | "source": [ 231 | "@tf.function\n", 232 | "def predict(x):\n", 233 | " return model(x)\n", 234 | "\n", 235 | "model_output = predict(np.zeros((1, 30)))\n", 236 | "print(model_output)" 237 | ] 238 | } 239 | ], 240 | "metadata": { 241 | "kernelspec": { 242 | "display_name": "Python 3", 243 | "language": "python", 244 | "name": "python3" 245 | }, 246 | "language_info": { 247 | "codemirror_mode": { 248 | "name": "ipython", 249 | "version": 3 250 | }, 251 | "file_extension": ".py", 252 | "mimetype": "text/x-python", 253 | "name": "python", 254 | "nbconvert_exporter": "python", 255 | "pygments_lexer": "ipython3", 256 | "version": "3.6.7" 257 | } 258 | }, 259 | "nbformat": 4, 260 | "nbformat_minor": 2 261 | } 262 | -------------------------------------------------------------------------------- /Introduction - Simple Neural Network.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Import" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "Limited tf.compat.v2.summary API due to missing TensorBoard installation\n", 20 | "Limited tf.summary API due to missing TensorBoard installation\n" 21 | ] 22 | } 23 | ], 24 | "source": [ 25 | "# Matplotlib\n", 26 | "import matplotlib.pyplot as plt\n", 27 | "# Tensorflow\n", 28 | "import tensorflow as tf\n", 29 | "# Numpy and Pandas\n", 30 | "import numpy as np\n", 31 | "import pandas as pd\n", 32 | "# Ohter import\n", 33 | "import sys" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "## Be sure to used Tensorflow 2.0" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 2, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "## Load the dataset: Fashion MNIST" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "![](https://storage.googleapis.com/kaggle-datasets-images/2243/3791/9384af51de8baa77f6320901f53bd26b/dataset-cover.png)" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 3, 69 | "metadata": { 70 | "scrolled": true 71 | }, 72 | "outputs": [ 73 | { 74 | "name": "stdout", 75 | "output_type": "stream", 76 | "text": [ 77 | "(10000, 784)\n", 78 | "(10000,)\n" 79 | ] 80 | } 81 | ], 82 | "source": [ 83 | "from sklearn.preprocessing import StandardScaler\n", 84 | "\n", 85 | "# Fashio MNIST\n", 86 | "fashion_mnist = tf.keras.datasets.fashion_mnist\n", 87 | "(images, targets), (images_test, targets_test) = fashion_mnist.load_data()\n", 88 | "\n", 89 | "# Get only a subpart of the dataset\n", 90 | "images = images[:10000]\n", 91 | "targets = targets [:10000]\n", 92 | "\n", 93 | "# Reshape the dataset and convert to float\n", 94 | "images = images.reshape(-1, 784)\n", 95 | "images = images.astype(float)\n", 96 | "images_test = images_test.reshape(-1, 784)\n", 97 | "images_test = images_test.astype(float)\n", 98 | "\n", 99 | "scaler = StandardScaler()\n", 100 | "images = scaler.fit_transform(images)\n", 101 | "images_test = scaler.transform(images_test)\n", 102 | "\n", 103 | "print(images.shape)\n", 104 | "print(targets.shape)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "## Plot one of the data" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 4, 117 | "metadata": {}, 118 | "outputs": [ 119 | { 120 | "data": { 121 | "image/png": "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\n", 122 | "text/plain": [ 123 | "
" 124 | ] 125 | }, 126 | "metadata": { 127 | "needs_background": "light" 128 | }, 129 | "output_type": "display_data" 130 | } 131 | ], 132 | "source": [ 133 | "targets_names = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\", \"Sandal\", \n", 134 | " \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"\n", 135 | "]\n", 136 | "# Plot one image\n", 137 | "plt.imshow(np.reshape(images[11], (28, 28)), cmap=\"binary\")\n", 138 | "plt.title(targets_names[targets[11]])\n", 139 | "plt.show()" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "# Create the model\n", 147 | "![](images/simple_nn.png)" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "# Create the model" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 5, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "name": "stdout", 164 | "output_type": "stream", 165 | "text": [ 166 | "[[0.25206915 0.0344908 0.02238493 0.03746236 0.2455979 0.23861533\n", 167 | " 0.01474024 0.03629072 0.05204329 0.06630526]] [9]\n" 168 | ] 169 | } 170 | ], 171 | "source": [ 172 | "# Flatten\n", 173 | "model = tf.keras.models.Sequential()\n", 174 | "\n", 175 | "# Add the layers\n", 176 | "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n", 177 | "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n", 178 | "model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n", 179 | "\n", 180 | "model_output = model.predict(images[0:1])\n", 181 | "print(model_output, targets[0:1])" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "## Model Summary" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 6, 194 | "metadata": {}, 195 | "outputs": [ 196 | { 197 | "name": "stdout", 198 | "output_type": "stream", 199 | "text": [ 200 | "Model: \"sequential\"\n", 201 | "_________________________________________________________________\n", 202 | "Layer (type) Output Shape Param # \n", 203 | "=================================================================\n", 204 | "dense (Dense) multiple 200960 \n", 205 | "_________________________________________________________________\n", 206 | "dense_1 (Dense) multiple 32896 \n", 207 | "_________________________________________________________________\n", 208 | "dense_2 (Dense) multiple 1290 \n", 209 | "=================================================================\n", 210 | "Total params: 235,146\n", 211 | "Trainable params: 235,146\n", 212 | "Non-trainable params: 0\n", 213 | "_________________________________________________________________\n" 214 | ] 215 | } 216 | ], 217 | "source": [ 218 | "model.summary()" 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "## Compile the model" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 7, 231 | "metadata": {}, 232 | "outputs": [], 233 | "source": [ 234 | "# Compile the model\n", 235 | "model.compile(\n", 236 | " loss=\"sparse_categorical_crossentropy\",\n", 237 | " optimizer=\"sgd\",\n", 238 | " metrics=[\"accuracy\"]\n", 239 | ")" 240 | ] 241 | }, 242 | { 243 | "cell_type": "markdown", 244 | "metadata": {}, 245 | "source": [ 246 | "## Train the model" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": 8, 252 | "metadata": {}, 253 | "outputs": [ 254 | { 255 | "name": "stdout", 256 | "output_type": "stream", 257 | "text": [ 258 | "Train on 8000 samples, validate on 2000 samples\n", 259 | "Epoch 1/10\n", 260 | "8000/8000 [==============================] - 1s 84us/sample - loss: 1.7367 - accuracy: 0.4266 - val_loss: 1.2768 - val_accuracy: 0.6140\n", 261 | "Epoch 2/10\n", 262 | "8000/8000 [==============================] - 1s 69us/sample - loss: 1.0865 - accuracy: 0.6686 - val_loss: 0.9738 - val_accuracy: 0.6945\n", 263 | "Epoch 3/10\n", 264 | "8000/8000 [==============================] - 1s 64us/sample - loss: 0.8831 - accuracy: 0.7150 - val_loss: 0.8430 - val_accuracy: 0.7285\n", 265 | "Epoch 4/10\n", 266 | "8000/8000 [==============================] - 1s 64us/sample - loss: 0.7809 - accuracy: 0.7383 - val_loss: 0.7681 - val_accuracy: 0.7500\n", 267 | "Epoch 5/10\n", 268 | "8000/8000 [==============================] - 1s 68us/sample - loss: 0.7166 - accuracy: 0.7600 - val_loss: 0.7181 - val_accuracy: 0.7605\n", 269 | "Epoch 6/10\n", 270 | "8000/8000 [==============================] - 1s 64us/sample - loss: 0.6711 - accuracy: 0.7739 - val_loss: 0.6818 - val_accuracy: 0.7725\n", 271 | "Epoch 7/10\n", 272 | "8000/8000 [==============================] - 0s 59us/sample - loss: 0.6364 - accuracy: 0.7825 - val_loss: 0.6530 - val_accuracy: 0.7760\n", 273 | "Epoch 8/10\n", 274 | "8000/8000 [==============================] - 0s 57us/sample - loss: 0.6085 - accuracy: 0.7909 - val_loss: 0.6300 - val_accuracy: 0.7810\n", 275 | "Epoch 9/10\n", 276 | "8000/8000 [==============================] - 0s 61us/sample - loss: 0.5855 - accuracy: 0.7962 - val_loss: 0.6110 - val_accuracy: 0.7855\n", 277 | "Epoch 10/10\n", 278 | "8000/8000 [==============================] - 1s 68us/sample - loss: 0.5652 - accuracy: 0.8026 - val_loss: 0.5952 - val_accuracy: 0.7915\n" 279 | ] 280 | } 281 | ], 282 | "source": [ 283 | "history = model.fit(images, targets, epochs=10, validation_split=0.2)" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 10, 289 | "metadata": {}, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8leWd9/HP75yTfSU7EELYIYAgRAW1IgqKTivtU9tKHTtjO7W2tk61tmPb6TLO06l9zdMZl9rFuj0+rVKn1q0WV6x7VVBQ9s0EwpYQQvY91/PHfYAEA4TkJCfnnO/79corZ7nv6/xylO99neu+znWbcw4REYkuvnAXICIioadwFxGJQgp3EZEopHAXEYlCCncRkSikcBcRiUIKdxGRKKRwl6hnZmVmtijcdYgMJYW7iEgUUrhLzDKzL5vZNjM7aGZPmtmo4ONmZv9tZpVmVmdmH5jZjOBzl5rZBjOrN7PdZnZTeP8Kkd4p3CUmmdkFwE+BzwIjgXJgefDpi4DzgMlARnCb6uBz9wJfcc6lATOAlUNYtkifBcJdgEiYXAnc55x7F8DMvgvUmFkx0A6kAVOBt51zG7vt1w6UmNla51wNUDOkVYv0kXruEqtG4fXWAXDONeD1zkc751YCvwDuAirN7G4zSw9u+mngUqDczF42s/lDXLdInyjcJVbtAcYevmNmKUA2sBvAOXeHc24uUII3PPPt4OPvOOeWAnnA48AjQ1y3SJ8o3CVWxJlZ4uEf4GHgajObbWYJwH8AbznnyszsDDM7y8zigEagBegys3gzu9LMMpxz7UAd0BW2v0jkBBTuEiv+AjR3+zkf+AHwKLAXmABcEdw2Hfgt3nh6Od5wzX8Gn7sKKDOzOuBavLF7kWHHdLEOEZHoo567iEgUUriLiEQhhbuISBRSuIuIRKGwfUM1JyfHFRcXh+vlRUQi0urVqw8453JPtl3Ywr24uJhVq1aF6+VFRCKSmZWffCsNy4iIRCWFu4hIFFK4i4hEoWG15G97ezsVFRW0tLSEu5Qhk5iYSGFhIXFxceEuRUSiyLAK94qKCtLS0iguLsbMwl3OoHPOUV1dTUVFBePGjQt3OSISRYbVsExLSwvZ2dkxEewAZkZ2dnZMfVIRkaExrMIdiJlgPyzW/l4RGRrDLtxPpqW9kz2HmunSapYiIscVceHe1tHFgYZWGls7Qt52dXU1s2fPZvbs2RQUFDB69Ogj99va2vrUxtVXX83mzZtDXpuIyKkYVidU+yI1IYDPjLrmdtISQzvDJDs7mzVr1gDw4x//mNTUVG666aYe2zjncM7h8/V+XLz//vtDWpOISH9EXM/d5zPSEgPUtXQwVBca2bZtGyUlJVx55ZVMnz6dvXv3cs0111BaWsr06dO55ZZbjmx77rnnsmbNGjo6OsjMzOTmm29m1qxZzJ8/n8rKyiGpV0Rk2Pbc/+2p9WzYU9frcx1djtb2TpLi/fhO4YRkyah0fvSJ6f2qZ9OmTTz44IOUlpYCcOutt5KVlUVHRwcLFy7k8ssvp6SkpMc+tbW1LFiwgFtvvZUbb7yR++67j5tvvrlfry8icioirucO4Pd5gd7RNXQnVSdMmHAk2AEefvhh5syZw5w5c9i4cSMbNmz4yD5JSUlccsklAMydO5eysrKhKldEYtyw7bmfrIe9vaqBzi7H5Py0IaknJSXlyO2tW7dy++238/bbb5OZmcnf//3f9zpXPT4+/shtv99PR0foTwKLiPQmInvuAOmJcbS0d9La0Tnkr11XV0daWhrp6ens3buXZ599dshrEBE5kWHbcz+Z9KQAe2uhrrmD3DT/kL72nDlzKCkpYerUqYwdO5ZzzjlnSF9fRORkbKhmnByrtLTUHXuxjo0bNzJt2rQ+t7Flfz1+nzEhNzXU5Q2pU/27RSR2mdlq51zpybaL2GEZ8IZmmlo76ejsCncpIiLDSmSHe1IAh6O+RScqRUS6i+hwT4rzE+f3UdfSHu5SRESGlYgOdzPv26r1LR10DeGcdxGR4S6iwx0gPSmOLudoGISFxEREIlXEh/uRhcQ0NCMickTEh7vPQreQ2MKFCz/yhaTbbruNr371q8fdJzU1sqdhikh0ivhwB29opqOzi+a2gX1bddmyZSxfvrzHY8uXL2fZsmUDaldEZKhFRbinJQQwBj40c/nll/P0008fuTBHWVkZe/bs4fTTT+fCCy9kzpw5zJw5kyeeeCIUZYuIDJrhu/zAipth3wd92jQATGzv9IZl4k/wJxXMhEtuPe7TWVlZnHnmmaxYsYKlS5eyfPlyPvvZz5KUlMRjjz1Geno6Bw4cYN68eVx22WW6/qmIDFtR0XMHCPiMLseAr63afWjm8JCMc47vfe97nHbaaSxatIjdu3ezf//+UJQtIjIoTtpzN7P7gI8Dlc65GcfZ5nzgNiAOOOCcWzDgyk7Qw+6N6+hkx756RmYkkZuW0O+XXbp0KTfccAPvvvsuTU1NzJ07lwceeICqqipWr15NXFwcxcXFvS7xKyIyXPSl5/4AsOR4T5pZJvBL4DLn3HTgM6Ep7dTEB/wkxvkHPO6emprKwoUL+eIXv3jkRGptbS15eXnExcXx0ksvUV5eHoqSRUQGzUnD3Tn3CnDwBJt8HviTc25ncPuwXSjUW0isY8ALiS1btoy1a9ceCfcrr7ySVatWMXPmTB588EGmTp0ainJFRAZNKE6oTgbizOyvQBpwu3Puwd42NLNrgGsAioqKQvDSPaUnBaish7qWDrJS4k++w3F88pOf7DFnPicnhzfffLPXbRsaGvr9OiIigyUUJ1QDwFzg74CLgR+Y2eTeNnTO3e2cK3XOlebm5obgpXs6vJBYvb6tKiIxLhQ99wqg2jnXCDSa2SvALGBLCNo+JWZGemKAmqZ2urocPp+mKopIbApFz/0J4FwzC5hZMnAWsLG/jQ10CYFIW0gsXFfCEpHo1pepkA8D5wM5ZlYB/AhvyiPOuV875zaa2TPA+0AXcI9zbl1/iklMTKS6uprs7Ox+f0EoJSGAP7iQWHpSXL/aGCrOOaqrq0lMTAx3KSISZYbVNVTb29upqKgY8Bzyg41ttHZ0UZCeyHD/EmliYiKFhYXExQ3vA5GIDA99vYbqsFp+IC4ujnHjxg24nSfW7Oaf/7iGR796NnPHjghBZSIikSVqlh/o7vwpeQR8xvMbtESAiMSmqAz3jKQ4zhqfxQsbFe4iEpuiMtwBFk/LZ1tlAx8eaAx3KSIiQy5qw31RST4Az2/YF+ZKRESGXtSGe+GIZKaNTNe4u4jEpKgNd4DFJfmsLq+huqE13KWIiAypqA73i0ry6XLw4qawLVQpIhIWUR3u00elMyojUUMzIhJzojrczYxFJfm8urWK5rbOcJcjIjJkojrcwRt3b2nv4rVtB8JdiojIkIn6cD9rXDZpCQFNiRSRmBL14R4f8HH+1Dxe3FhJZ5eW1xWR2BD14Q7e0Ex1YxtrdtWEuxQRkSERE+F+/pRc4vzGc5o1IyIxIibCPT0xjnnjszUlUkRiRkyEO8CiafnsqGpke1VDuEsRERl0sRPuRxYSU+9dRKJfzIT76Mwkpo/SQmIiEhtiJtzBmzXz7s4aquq1kJiIRLeYC3fnYOUm9d5FJLrFVLiXjExndGaShmZEJOrFVLibGYtL8nl16wGa2jrCXY6IyKCJqXAHb2imtaOLV7dqITERiV4xF+5njssiPTHACxqaEZEodtJwN7P7zKzSzNadZLszzKzDzC4PXXmhF+f3sXBqHis3aSExEYlefem5PwAsOdEGZuYHfgY8F4KaBt3hhcTe3amFxEQkOp003J1zrwAHT7LZN4BHgYi4WOmCyd5CYpo1IyLRasBj7mY2GvgU8Ks+bHuNma0ys1VVVVUDfel+S+u2kJhzGpoRkegTihOqtwH/4pzrOtmGzrm7nXOlzrnS3NzcELx0/11Uks+HB7SQmIhEp1CEeymw3MzKgMuBX5rZJ0PQ7qA6vJCY1ngXkWg04HB3zo1zzhU754qBPwJfc849PuDKBtnIjCRmjs7QuLuIRKW+TIV8GHgTmGJmFWb2JTO71syuHfzyBtfiknzW7DpEZX1LuEsREQmpwMk2cM4t62tjzrl/HFA1Q2xxST7/9fwWXtxYybIzi8JdjohIyMTcN1S7m1qQRuEILSQmItEnpsP98EJir23TQmIiEl1iOtzBG5pp6+jilS1aSExEokfMh/uZxVlkJMVpaEZEokrMh3vA7+OCqXms3LSfjs6Tfg9LRCQixHy4Ayyalk9NUzury7WQmIhEB4U7sGBKLvF+n4ZmRCRqKNyB1IQA8ydk8/xGLSQmItFB4R60uCSf8uomtlZqITERiXwK96DFwYXENDQjItFA4R6Un57IrMIMrRIpIlFB4d7N4pJ81u46xP46LSQmIpFN4d7N4pICAF7cGBFXCxQROa7IDPe2xkFpdnJ+KkVZyTy/Yd+gtC8iMlQiL9w3PgX/PQMO7gh504cXEnt9ezWNrVpITEQiV+SF+6g50NUBT3wDukK/XMDRhcTCdwFvEZGBirxwzxgNF/8Eyl+DVfeGvPnSsSPITNZCYiIS2SIv3AFOvwomXADP/whqykPadMDv44IpeazcXKmFxEQkYkVmuJvBJ+4A88GT34AQLxmwuCSfQ03tvFOmhcREJDJFZrgDZI6Bi26BD1+G1Q+EtOnzJucSH9BCYiISuSI33AHmXg3jzoPnfgCHdoWs2ZSEAOdMyOb5jfu0kJiIRKTIDnczuOxOcF3w1PUhHZ5ZXFLAroPNbN5fH7I2RUSGSmSHO8CIYlj8b7B9Jbz3u5A1u2haHgDPr9fQjIhEnsgPd4DSL8HYc+HZ70Pt7pA0mZeeyOwxmbywUeEuIpEnOsLd54Old0JnG/z5myEbnllcks/ailotJCYiEeek4W5m95lZpZmtO87zV5rZ+2b2gZm9YWazQl9mH2SNh0U/gq3PwdrlIWnyIq3xLiIRqi899weAJSd4/kNggXNuJvDvwN0hqKt/zvwKjJkHz/wL1A988a+JeakUZycr3EUk4pw03J1zrwAHT/D8G865w9/2+RtQGKLaTp3PB0vvgo5W+PMNAx6eMTMWTcvnze3VNGghMRGJIKEec/8SsOJ4T5rZNWa2ysxWVVUN0sJcORPhgn+FzX+BD/444OYWl+TT1tnFy5u1kJiIRI6QhbuZLcQL93853jbOubudc6XOudLc3NxQvfRHzfsaFJ4BK74NDQO78MbcsSMYkRynNd5FJKKEJNzN7DTgHmCpc646FG0OiM/vDc+0NcHTNw5oeCbg93HB1HxWbqqkXQuJiUiEGHC4m1kR8CfgKufcloGXFCK5U2Dhd72Le6x/bEBNLS7Jp66lg3c+PO6pBxGRYaUvUyEfBt4EpphZhZl9ycyuNbNrg5v8EMgGfmlma8xs1SDWe2rmf8O7uMdfboLGA/1u5rzJOSQEfDynWTMiEiH6MltmmXNupHMuzjlX6Jy71zn3a+fcr4PP/5NzboRzbnbwp3Twy+4jf8Abnmmt9wK+n5LjA5w7MYfnN+zXQmIiEhGi4xuqJ5JfAgu+4w3NbHii380sLsln96FmNu3TQmIiMvxFf7gDnPNNKDgNnv4WNPbvfO+F0/Ix07dVRSQyxEa4++Pgk7+C5hrv26v9kJuWwOljMhXuIhIRYiPcAQpmwHnfhg/+BzY93a8mFpcU8MHuWvbWNoe4OBGR0IqdcAc490bIn+EtTdB06tMaF5d4a7y/oN67iAxzsRXugXj45C+9aZHPfu+Ud5+Qm8q4nBRNiRSRYS+2wh1g5Cz42I2w9mHY8uwp7WpmLC7J5287qqlraR+kAkVEBi72wh28sffcafDUP0PzoVPadXFJPu2dTguJiciwFpvhHkjwhmcaKuG575/SrnOKRpCdEq9ZMyIyrMVmuAOMngPnXO9dVHvbC33eze8zLpiax0ubtZCYiAxfsRvuAAtuhpwp8OT10FLX590Wl+RT39LBWzu0kJiIDE+xHe5xid7aM/V74fkf9Hm3j03KJTHOxwsbNTQjIsNTbIc7wJgzYP51sPoB2P5Sn3ZJivdz7sRcnlm3T7NmRGRYUrgDLPw+ZE/0hmda+7Yw2BfPLaa6sZV/uO9t6hXwIjLMKNwB4pK84ZnaXfDCj/u0y9kTcrhz2Rw+qKjl6vvfoVEX0BaRYUThfljRPJj3VXjnHvjw1T7tsmRGAXcsO533dh3i6gfeoalNAS8iw4PCvbsLfgAjxsGTX4e2xj7tcunMkdz2udmsKjvIlx5YRXNb5yAXKSJycgr37uKTveGZmjJ48ZY+7/aJWaP478/N5q0Pq/mnB9+hpV0BLyLhpXA/VvE5cOY18NavofyNPu+2dPZo/vPyWbyxvZovP7hKAS8iYaVw782FP4LMsfDEddDW1OfdPj23kJ99+jRe23aAa3+3mtYOBbyIhIfCvTcJqXDZnXBwB7z0k1Pa9bOlY/jpp2by181VfO137yrgRSQsFO7HM34BlH4R3rwLdr51SrtecWYRP/nUDF7cVMnXH3qPtg6tQSMiQ0vhfiKLb4GMQm94pv3ULq135VljuWXpdJ7fsJ/rH35Pi4yJyJBSuJ9IQhpcdgdUb4W//vSUd//C/GJ++PESnlm/j28uX0OHAl5EhshJw93M7jOzSjNbd5znzczuMLNtZva+mc0JfZlhNOECmPMFeONOqFh1yrt/8dxx/OvfTePpD/ZywyNrFfAiMiT60nN/AFhygucvASYFf64BfjXwsoaZi/43pI30hmc6Wk9593/62Hi+e8lUnlq7h5v+Zy2dXW4QihQROeqk4e6cewU40cLlS4EHnedvQKaZjQxVgcNCYgZ84nao2gQv/6xfTXxlwQS+ffEUHl+zh2//UQEvIoMrEII2RgO7ut2vCD62NwRtDx+TFsPsK+G122DaJ2DU6afcxHULJ9LZ5fiv57cQ8Bm3/q/T8PlsEIoVkVg3pCdUzewaM1tlZquqqiLwAtMX/wRScuHx66CjrV9NXH/hJK6/cBKPrKrg+49/QJd68CIyCEIR7ruBMd3uFwYf+wjn3N3OuVLnXGlubm4IXnqIJY2AT9wGlevh1f/T72ZuWDSJ6xZO4OG3d/HDJ9fhnAJeREIrFOH+JPCF4KyZeUCtcy66hmS6m3IJnPY5ePXnsPf9fjVhZtx00RS+smA8v/vbTn785HoFvIiE1EnH3M3sYeB8IMfMKoAfAXEAzrlfA38BLgW2AU3A1YNV7LCx5Fbvknx/+jJc8RBkTzjlJsyMm5dMpavL8dtXP8TnM3748RLMNAYvIgN30nB3zi07yfMOuC5kFUWC5Cz4X7+B//lH+NXZsPB7MO868J/a+Wkz43uXTqOjy3H/62UEfN59BbyIDJS+odpfEy6Ar70FEy6E538I9y6C/etPuRkzr8f+hflj+e2rH/KzZzZriEZEBkzhPhDpI+GK38Pl98GhXfCbBfDST095Jo2Z8W+XTefKs4r49cvb+flzWxTwIjIgoZjnHtvMYManYdz58MzN8PKtsPEpWHonjJ57Cs0Y/750Bp1djl+8tA2/z7hh8eTBq1tEopp67qGSkg2f/i0s+wM018A9i+C5H5zSapI+n/Efn5rJZ+YWcvuLW7njxa2DWLCIRDP13ENtyhIYO98L9jfugE1/hst+4V2+rw98PuPWT59Gp/O+yer3GdctnDjIRYtItFHPfTAkZnhLBX/hSejqhAcuhae/Ba31fdrd7zP+8/JZLJ09iv98djO/eXn7IBcsItFG4T6Yxi+Ar70J874G79wLv5wP217o065+n/Hzz8zi46eN5KcrNnHPqzsGuVgRiSYK98EWnwJLfgpfeg7ikuF3n4bHvgpNJ1po0xPw+7jtc7O5dGYB//vpjdz/+odDULCIRAOF+1AZcyZ85RX42E3w/h/grrNgw5Mn3S3g93H7Fadz8fR8/u2pDTz4ZtmglyoikU/hPpTiEuHCH8A1f4W0AnjkKnjkC9BQeeLd/D7uXDaHRdPy+eET6/n9W+VDUq6IRC6FeziMPA2+vBIu/CFsXgF3nQlrl8MJvrgUH/Bx15Wnc8HUPL7/2DqWv71zCAsWkUijcA8Xfxx87Ftw7euQMxke+wr8/jNQW3HcXRICfn555RwWTM7lu499wCOrdh13WxGJbQr3cMudDFevgCU/g/LX4a55sOo+6Or9QtqJcX5+c9Vczp2Yw788+j5/evf4BwMRiV0K9+HA54d518JX34DRc+DPN8CDl0F17/PbE+P83H1VKfPHZ3PT/6zlobd26opOItKDwn04yRoHX3gCPnEH7F0LvzoH3rjT+yLUMZLi/dz7D2cwb3w233vsAy6941WeWbdPC46JCAAWrjAoLS11q1atCstrR4S6PfDnG2HLChhdCkt/AXnTPrJZZ5fjz+/v4fYXtrLjQCPTR6Vz4+LJXDA1T+vCi0QhM1vtnCs96XYK92HMOVj3KKz4DrTUwYLvwDnfhED8Rzbt6Ozi8TV7uOPFrew82MSsMZncuHgy503KUciLRBGFezRpPOAF/LpHIX+G14sfdXqvm7Z3dvHo6gruXLmN3YeaKR07ghsXT+bsiTlDXLSIDAaFezTa9BfvZGtjFZz9DTj/ZohL6nXTto4u/rBqF3et3Ma+uhbmjc/iWxdN4YzirCEuWkRCSeEerZoPwXP/Cu/9P8ie6C0nPHb+cTdvae/k4bd3ctdL2znQ0MrHJuVww+LJzCkaMYRFi0ioKNyj3faX4Knrvcv7zVoGc/8BxpzlXRmqF81tnfzub+X86uXtHGxsY+GUXG5cPIWZhRlDXLiIDITCPRa0NsBL/wGr74f2JsiaALOXwWlXQOaYXndpbO3g/75Zxt2v7OBQUzuLS/K5YdFkSkalD23tItIvCvdY0lrvrTC55iEofw0wGHcezL4Spn0C4pM/skt9Szv3v17Gb1/dQX1LB5fOLOCbiyYzOT9t6OsXkT5TuMeqmjJvEbI1D8GhcohPg+lLvaAvmv+RYZvapnbufW0H971eRmNbB5fNGsX1F05iQm5qeOoXkRNSuMe6ri7Y+QaseRjWPwbtjTBiHMz+PMy6AjKLemxe09jG3a/u4IHXy2jt6ORTpxdy/YUTGZudEqY/QER6E9JwN7MlwO2AH7jHOXfrMc8XAf8XyAxuc7Nz7i8nalPhPoRaG2DjU7Dm91D2qvdY8ce83nzJZd7VooIONLTy679u5//9rZyOLsdn5hby9QsmUjjio0M7IjL0QhbuZuYHtgCLgQrgHWCZc25Dt23uBt5zzv3KzEqAvzjnik/UrsI9TGrKvStBrfm9N4QTnwolS70efdHZ4POWG6qsa+GXf93OQ2/txOH43BljuG7hREZm9D6vXkSGRijDfT7wY+fcxcH73wVwzv202za/AXY4534W3P7nzrmzT9Suwj3MnIOdf/NCfv3j0FYPmWOPDtuMKAZgb20zv1i5jUdW7cLM+PyZRXzt/AnkpSeGt36RGBXKcL8cWOKc+6fg/auAs5xzX++2zUjgOWAEkAIscs6t7qWta4BrAIqKiuaWl+tyccNCWxNs+rMX9DteBhyMPdcL+pKlkJDKroNN/GLlNv74bgVxfuOqeWO5dsEEslMTwl29SEwZ6nC/MdjWz4M993uBGc653q84gXruw1ZtxdHZNge3Q1zy0WGbsedSXtPM7S9u5fH3dpMY5+cfzi7mmo+NZ0TKRxczE5HQG+phmfV4B4Bdwfs7gHnOueNe+VnhPsw5B7vehrUPwbo/QWsdZBR5Qzazl7GtI487XtzKU+/vISU+wBfPKeYfzxlHlkJeZFCFMtwDeCdULwR2451Q/bxzbn23bVYAf3DOPWBm04AXgdHuBI0r3CNIezNsetobttn+EuC8k6+zl7E1ZxH/9cpeVqzbh8/grHHZXDKzgItKCijI0Li8SKiFeirkpcBteNMc73PO/cTMbgFWOeeeDM6Q+S2QCjjgO865507UpsI9QtXuDs62eQiqt0IgCUouY1fRp3jkwFhWbKhiW2UDAKcXZbJkegEXTy+gOEfz5UVCQV9iksHlHOxe7fXmP3gUWmshMQPGnkNVzhmsbJ7MQ2VprN3jBf3UgjSWzChgyYwCpuSn6QIiIv2kcJeh097iXQ5w+0ooew0O7vAeT8ygedQ81vpn8KeD43h0TyadzkdxdjIXzyhgyfQCZhVm4vMp6EX6SuEu4VO7G8pf974N2y3suxIy2JNxOi+3TeUPVUWs6ywiLz2Zi6fnc/GMAs4sziLg1zXbRU5E4S7Dx3HCvi0unQ1xM1jRMIHX2qexP2kCF5aMYsmMAs6emE1CwB/mwkWGH4W7DF91e6Cse9hvB6DJl8JbnVN5rWMq7wdmMmrKGVw8czQLJueSkhAIc9Eiw4PCXSJHt7DvKnsNXzDs60nmb51TWcV0OorOpuT0c1hUMoqM5LgwFywSPgp3iVzBsO8qe5XWrS+TVF/mPeySecdNZV9WKSOmXUDpvPPIy9AUS4ktCneJHnV7cWWvcXD9Sih/jeyWnd7DLpnNCTPpHHsOxXMvpmDyGeDTOL1EN4W7RC1Xt4d977/IgXUvMqLybQq7dgPQYClUjZhDwthScifOIW7kTG+lS59m4Ej0ULhLzNhdvoPNb62g48NXGd+4lvG2F595/1+3+pJpGjGFxMLTSCqcBfkzIL8EEnStWIlMCneJSVX1razZvpuKLe/SvGstaYc2M9nKmWY7SbemI9u1pY8lbuQMrGAm5E/3fkaMUy9fhj2FuwjQ0t7J+j21rC47yI7tm2mpeJ/RrTuY5ttJiX8XxezFh7cytYtLwfJLgmE/42gvPzEjzH+FyFEKd5FeOOfYebCJ1eU1rC6vYV3ZXlzVZqbYTkqsnDmJe5jkykjurD+6U2ZRt7APBn/WOJ28lbBQuIv0UV1LO2t2HmJ1eQ3v7qzhvZ01pLZWMtW3kzMS93Bm8h4munIym8ox1+ntFJcMedOCYX94aKcEkkaE94+RqKdwF+mnzi7H5n31rN5Zw7vBHv7Og00k0Ma0wF4WZ1VyRtJeJrgyRtRvwdd88OjOGWO8oM8rgZxJkDUBsidAcjZoJUwJAYW7SAhV1rccCfrV5TWs210U02/LAAALIElEQVRHW2cX4Jg7opWLcw9wRuIexneVkV63BTuwBbo6jjaQkOEN5WRP8AI/a/zR28lZCn7pM4W7yCA6cqK2vIZVZd5wzoGGNgDSEgLMHZPC/BGNzEiqZrx/H7ltuwkc2uEtmnZoJ3S/vHBihhf2h3v53W8nZ4XpL5ThSuEuMoSOPVH73s5DbKtsCPbuwWdQnJ3C5Pw0puUlMjvtEJMCVeR37MZfswOqt3vBX7vrmODP7NnLP3J7vII/RincRcKso7OLsupGNu9rYPP+erbsq2fz/nrKqhs5/M8uPuBjYm4qUwrSvODPjWdaUg15bRVYzYfB0N8O1cHgp9u/16QRx+nxj9eJ3SimcBcZpprbOtle1cCmffVs2V/P5n3ez766liPbpCUEmBwM/Cn5qUwpSGdKTjxZbXuOBv7B7j3+CnoGf1Yw7MdDRiFkjPZO9qaP9m4nZmqcP0Ip3EUiTG1TO1sq673QD/byN++rp7a5/cg2OakJTD0c+gVe6E/KSyXF1wE1ZcFefjDwD26Hg2VQv6fnyV2A+NRg0AeDP73wmNujIS5pSP9+6RuFu0gUcM5RWd/K5mAv/3Bvf8v+elraj47Nj8lKYkp+2pHhnSkFaYzPSSU+4IOuTmjY710Rq67C6+Ufe7ux8qMvnpztBf7hsM8o7HZAKITUAvDrIipDra/hrv8yIsOYmZGfnkh+eiLnTc498nhnl2PXwaYjY/mbgr9f2lxFZ5fXYQv4jOKcFIqzUyjOTmZsdi5js4spnpLCqMzEnter7WiFut1e0NdWBIM/eLvmQ++qWa11xxTnh7SRwd5+t9Dvflvz+8NGPXeRKNLa0cmOqsYjY/lbKxsor26kvLqJ1o6jPf2AzygckUTRkeBPYWxWMsU5yRSOSCYxrpelFVrqggeAYI+/++3aCu8iK52tPfcJJHphnz4KUvMhrQBS87zb3X8017/P1HMXiUEJAT/TRqYzbWR6j8e7urzhncNBX1bdSPnBJsqrG3mvvIb61qNj8mYwMj3RC/xg8BdnJ1OUnczY7Emk5k3r/cWdg8YD3qyeI58Cgrfr9sDuVVC/HzqaP7qvLy4Y+nnecM/hA0DaMQeB1DydC+gj9dxFYpxzjpqmdsqqG9l5OPirm44cCKob23psn5OaEAz9ZMZmpVCcc7Tnn5kch52oB+4ctDVAQyXU7/POBTRUQsO+4O/93gGgYT80VtFjBtBhCRleyPf6KeDw4/nejKEoXMI5pCdUzWwJcDvgB+5xzt3ayzafBX6M919jrXPu8ydqU+EuEhnqW9qDYd9E+cFGyg8Ef1c3sbe2pce26YkBinNSKMpKpjg7haLs4O+sZHLTEvD7TmHopbMDmqqPCf5ut7sfFNoaPrq/LwApeT0/BaTkeucBevuJT4mIoaGQhbuZ+YEtwGKgAngHWOac29Btm0nAI8AFzrkaM8tzzvVy+v0ohbtI5Gtp72TXwSbKuvX0y6ob2XmwiYqa5iMnd8Eb589PT2RUZiIjM5IYlZnEqMxERmUkMTL4+6Q9/+NpbegW+N2Df3/PTwmNB+Dwyp7H8iccDfqU3g4AWZCc0/N+IKGf71z/hXLM/Uxgm3NuR7Dh5cBSYEO3bb4M3OWcqwE4WbCLSHRIjPMzKT+NSfkfvWxhe2cXu2uaKT/YxK6DTeytbWbPoRb2HGrmvV01rFi3l/bOnp3LpDj/kaA/fBAYnemF/8jgY8nxvcRWQqr3kz3hxAU7By213ieCpoPB3weCv6t7Pr5njfe75dDx24tP80I+JaeXA0H2MQeDbEjKHLLrAPQl3EcDu7rdrwDOOmabyQBm9jre0M2PnXPPHNuQmV0DXANQVFTUn3pFJELE+X3eVMyclF6f7+pyHGhsZc+hFvYeamZPrRf8e2ub2X2ohb9urqKqoZVjBxcyk+OCod/zE8Dh8M9PTyTOf5yxdjMvYJMyT34gOKyzA5prjjkAHDjmAFHtnSOo3OTdbm88TmPmLQ0x/zo476a+vX4/hWq2TACYBJwPFAKvmNlM51yPQ55z7m7gbvCGZUL02iISgXw+Iy8tkby0RGaPyex1m7aOLvbXeaG/J9jzP/wJoKKmmXfKanp8gxe8/M5LS/BCP6Nn8BdkJJGfnkBOasLxDwDH8gcgNdf76av25p7Bf+xPzuS+t9VPfQn33cCYbvcLg491VwG85ZxrBz40sy14Yf9OSKoUkZgUH/AxJiuZMVnJx92msbXjSG//2E8AG/fW8cLG/T3m+IN3AMhOSSA/PSH4JbEE8tISj9zOT08kLz2B7JRTPAl8WFxS8Fu9o0993xDpS7i/A0wys3F4oX4FcOxMmMeBZcD9ZpaDN0yzI5SFioj0JiUhwMS8NCbmfXTcH45O9dxzqJl9tS1U1reyv66FyvoW9td5t9+vqKW68aNDQH6fkZMa74V9WmLPg0F6IvnBx0Ykx+Prz0FgEJ003J1zHWb2deBZvPH0+5xz683sFmCVc+7J4HMXmdkGoBP4tnOuejALFxHpCzMjKyWerJR4ZozOOO527Z1dHGhoPRL4lXVHw7+yvpWKmibe3VnDwWPm/QPE+YNDTOkJ5B/+nZ5IXlrCkeUj8tMTyEjq52ygftCXmERETkFrRydV9d5BwDsAtLD/8KeBbgeDY88FgDfMlJ+ewBfmFfPl88b36/W1/ICIyCBICPgpHOGtwXMiLe2dXtjXBw8A3Q4GeemDPz9e4S4iMggS4/wUBdfkCYfoW3hBREQU7iIi0UjhLiIShRTuIiJRSOEuIhKFFO4iIlFI4S4iEoUU7iIiUShsyw+YWRVQ3s/dc4ADISwn0un96Envx1F6L3qKhvdjrHPupOsPhy3cB8LMVvVlbYVYofejJ70fR+m96CmW3g8Ny4iIRCGFu4hIFIrUcL873AUMM3o/etL7cZTei55i5v2IyDF3ERE5sUjtuYuIyAko3EVEolDEhbuZLTGzzWa2zcxuDnc94WRmY8zsJTPbYGbrzeyfw11TuJmZ38zeM7M/h7uWcDOzTDP7o5ltMrONZjY/3DWFi5ndEPw3ss7MHjazxHDXNNgiKtzNzA/cBVwClADLzKwkvFWFVQfwLedcCTAPuC7G3w+AfwY2hruIYeJ24Bnn3FRgFjH6vpjZaOB6oNQ5NwPwA1eEt6rBF1HhDpwJbHPO7XDOtQHLgaVhrilsnHN7nXPvBm/X4/3jHR3eqsLHzAqBvwPuCXct4WZmGcB5wL0Azrk259yh8FYVVgEgycwCQDKwJ8z1DLpIC/fRwK5u9yuI4TDrzsyKgdOBt8JbSVjdBnwH6Ap3IcPAOKAKuD84THWPmaWEu6hwcM7tBv4PsBPYC9Q6554Lb1WDL9LCXXphZqnAo8A3nXN14a4nHMzs40Clc251uGsZJgLAHOBXzrnTgUYgJs9RmdkIvE/444BRQIqZ/X14qxp8kRbuu4Ex3e4XBh+LWWYWhxfsv3fO/Snc9YTROcBlZlaGN1x3gZn9LrwlhVUFUOGcO/xJ7o94YR+LFgEfOueqnHPtwJ+As8Nc06CLtHB/B5hkZuPMLB7vpMiTYa4pbMzM8MZUNzrn/ivc9YSTc+67zrlC51wx3v8XK51zUd87Ox7n3D5gl5lNCT50IbAhjCWF005gnpklB//NXEgMnFwOhLuAU+Gc6zCzrwPP4p3xvs85tz7MZYXTOcBVwAdmtib42Pecc38JY00yfHwD+H2wI7QDuDrM9YSFc+4tM/sj8C7eDLP3iIFlCLT8gIhIFIq0YRkREekDhbuISBRSuIuIRCGFu4hIFFK4i4hEIYW7iEgUUriLiESh/w9uX79GThDOIgAAAABJRU5ErkJggg==\n", 294 | "text/plain": [ 295 | "
" 296 | ] 297 | }, 298 | "metadata": { 299 | "needs_background": "light" 300 | }, 301 | "output_type": "display_data" 302 | }, 303 | { 304 | "data": { 305 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEICAYAAACzliQjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xt4VPW97/H3N/c7ITcCCSHc7yiY4gWsIl5otwVvtdBq7W37dD+17dbe0GNttd17u3u623pOPd2HKmp3a6m11VJF0R5118QLhKsCIgNySQiQSUIu5DK5fM8fawUmIZAJTDKZme/reebJrDVrrXxnHvnk52/95vcTVcUYY0x0iAl1AcYYY4aOhb4xxkQRC31jjIkiFvrGGBNFLPSNMSaKWOgbY0wUsdA3xpgoYqFvIoaIvCEidSKSGOpajBmuLPRNRBCRYuByQIGlQ/h744bqdxkTDBb6JlJ8HngHeBK4o3uniCSLyH+IyAERqReRUhFJdl9bKCJvichxETkkIl9w978hIl/xu8YXRKTUb1tF5GsisgfY4+57xL1Gg4hsEpHL/Y6PFZH7RGSviDS6r48VkUdF5D/834SIrBWRuwfjAzIGLPRN5Pg88Dv3cZ2IjHL3/xS4CLgMyAK+C3SJyDjgJeB/A7nAhcDWAfy+G4CLgRnu9kb3GlnA08AfRSTJfe0eYAXwSSAD+BLQDDwFrBCRGAARyQGuds83ZlBY6JuwJyILgXHAM6q6CdgLfNYN0y8B31TVSlXtVNW3VLUN+CzwN1X9vaq2q2qNqg4k9P9NVWtVtQVAVX/rXqNDVf8DSASmusd+BbhfVXerY5t77AagHljsHrcceENVj57nR2LMGVnom0hwB/CKqnrd7afdfTlAEs4fgd7GnmF/oA75b4jIt0Vkl9uFdBwY4f7+/n7XU8Bt7vPbgP86j5qM6ZfdhDJhze2fvxWIFZEj7u5EIBMYDbQCE4FtvU49BMw/w2VPACl+2/l9HHNyelq3//67OC32HaraJSJ1gPj9ronA+31c57fA+yJyATAdeP4MNRkTFNbSN+HuBqATp2/9QvcxHXgTp59/NfAzERnj3lC91B3S+TvgahG5VUTiRCRbRC50r7kVuElEUkRkEvDlfmpIBzqAaiBORB7A6bvv9hjwIxGZLI45IpINoKoVOPcD/gv4U3d3kTGDxULfhLs7gCdU9aCqHul+AL8EPgesBN7DCdZa4N+BGFU9iHNj9Vvu/q3ABe41fw74gKM43S+/66eG9cDLwIfAAZz/u/Dv/vkZ8AzwCtAAPA4k+73+FDAb69oxQ0BsERVjQktEPo7TzTNO7R+kGWTW0jcmhEQkHvgm8JgFvhkKFvrGhIiITAeO49xw/kWIyzFRwrp3jDEmilhL3xhjosiwG6efk5OjxcXFoS7DGGPCyqZNm7yqmtvfccMu9IuLiykvLw91GcYYE1ZE5EAgx1n3jjHGRBELfWOMiSIW+sYYE0WGXZ9+X9rb26moqKC1tTXUpQyZpKQkCgsLiY+PD3UpxpgIEhahX1FRQXp6OsXFxYhI/yeEOVWlpqaGiooKxo8fH+pyjDERJCy6d1pbW8nOzo6KwAcQEbKzs6Pq/2yMMUMjoNAXkSUisltEPCKyso/Xi0TkdRHZIiLbReSTfq/d6563W0SuO9dCoyXwu0Xb+zXGDI1+u3dEJBZ4FLgGqAA2ishaVd3pd9j9OEvV/UpEZgDrgGL3+XJgJjAG+JuITFHVzmC/EWOMCReqSkNLB8caWzna0MaxxlaONbaRnhTH5y4eN6i/O5A+/fmAR1X3AYjIGmAZ4B/6yqlFI0YAh93ny4A17pqkH4mIx73e20GofcjU1NSweLGzjOmRI0eIjY0lN9f54tuGDRtISEjo9xpf/OIXWblyJVOnTu33WGNMeFJVjje3c6yxjaMNrSd/Vje29Qz4hjbaOrpOO39eUeawCP0Cei4IUQFc3OuYHwKviMjXgVTgar9z3+l1bsE5VRpC2dnZbN3qrJn9wx/+kLS0NL797W/3OEZVUVViYvruMXviiScGvU5jzODo6lLqmn09WuXH/ELd2W6jurENX+fpYZ6eGEdeRiJ56UlcVDSSvIwk8tITT/4c5f5MTRz8sTXB+g0rgCdV9T9E5FLgv0RkVqAni8idwJ0ARUVFQSpp8Hk8HpYuXcrcuXPZsmULr776Kg8++CCbN2+mpaWFz3zmMzzwwAMALFy4kF/+8pfMmjWLnJwcvvrVr/LSSy+RkpLCX/7yF/Ly8kL8boyJPr6OLuqafVQ3OoF9MsBPtsrbqHb3dXSdPiNxRlKcE9gZiVw8PotcN9hH9fqZnBAbgnfXt0BCvxIY67dd6O7z92VgCYCqvi0iSUBOgOeiqquAVQAlJSVnnev5wb/uYOfhhgDKDtyMMRn84FMzz+ncDz74gN/85jeUlJQA8PDDD5OVlUVHRweLFi3illtuYcaMGT3Oqa+v54orruDhhx/mnnvuYfXq1axcedr9cWPMALV3dlF3woe3yUftCR81J9qo6fO5j5qmNhpaO/q8TmZKPKPSnTCflJvjttJPtchHZSSRm55IUvzwCfNABRL6G4HJIjIeJ7CXA5/tdcxBYDHwpLswRBLOItFrgadF5Gc4N3InAxuCVPuwMHHixJOBD/D73/+exx9/nI6ODg4fPszOnTtPC/3k5GQ+8YlPAHDRRRfx5ptvDmnNxoSLjs4uapt9J8Pa29RG7Ynu5z5qewV5fUt7n9eJEchKTSA7NZGs1ARmjMkgJzWBrNREstISyElNIC/DaZnnpieSGBd+YR6ofkNfVTtE5C6cxZ9jgdWqukNEHgLKVXUtzuLSvxaRu3Fu6n7BXfpth4g8g3PTtwP42vmO3DnXFvlgSU1NPfl8z549PPLII2zYsIHMzExuu+22Psfa+9/4jY2NpaOj79aGMZFIVfE2+ThY28zh4y3UNLU5Le8TPmqb3Bb5CSfo+wvx7sf0MRlku8+z0xLJTk1wHmlOsGcmxxMTMwyGQatCWyOcqIamo+7j2Knnafmw+PuDWkJAffqqug5nGKb/vgf8nu8EFpzh3H8B/uU8agwbDQ0NpKenk5GRQVVVFevXr2fJkiWhLsuYIdfU1sGh2mYO1TZzsLaZirqWHs9b2nu2/WIERqZ0h3YC0/MzTj7PdoM8K/XU8xHJ8cQOhxDv1t4KJ475BfixnmHuv7+j5fTzJRbS8qDokkEvNSymYQgX8+bNY8aMGUybNo1x48axYEGffweNCXvtnV0cPt7CwdpmDtW2cKjODfTaZg7VtVB7wtfj+LTEOApHJjM+J5WPT8ll7MhkirJTKMhMISctgcyUhOEV4gBdnXDCe3prvOlYr4A/Cq31fV8jJRtS85xAH3ux8zNtlPvwe548Es4w8i/Yht0auSUlJdp7EZVdu3Yxffr0EFUUOtH6vk3oqSrVjW0cqnNC/aDbau/erqpvwX8wS3ysUJCZzNisFOcxMoWxWcmMHZlCUVYKmSnxof2WuSq0t0DrcWipO/3RXHN6K73ZC3r68EsS0t3AzvML7j7CPDUXYoduwkQR2aSqJf0dZy19Y6JUY2v7yUCvqDvVFXOoroWKumZa23sGXl56IkVZKcwfn8XYkX4Bn5VCfkbS0LTUVaGtoe/gbjne62evR2fbma8bm3AqsDOLoOCiM4R5HiSknvk6YcBC35gI1dmlVNWfaqUfrG3mQM2p53XNPW+SpifFMXZkCpNy01g0NdevxZ5C4cjk4A5P7OpyWt3NtWcI8F6PVr9AP9tYkPgUp6uk+5EzyfmZlNlzf+9HQipEyXxXFvrGhLHuG6b+YX7ADfmKumbaO0/1wcTFCIVuC/2Ts0dT5NcVU5SVwoiUc+yKUHX6tJtrnBBvrun5aKk9fX9LXd9dJ92SRvQM68yis4R25qlj45PO7T1EEQt9Y4axri7laGMrB2tOhbl/i72m1w3TEcnxFGWlMGNMBktm5VOUlcI4N9xHj0giLrafm4Wq4GvyC+g+Qry5BprreoZ61xmGHcfEOzczU7IhJQvyZvhtZzthnZLVM8STRkBM5I6TDzULfWNCrNnXcbJv/UDNiR4t9oq6Fnx+E3PFxghjMpMoykrh2pmjKMpKpSgr5eRjREo8dLY7Y8HbGqCtHtoqwNsElQ3ufve1HoFeeyrAO319Fyqxp8I7JdvpOkm5uGeI+7+enAWJ6VHTbRIuLPSNGQKqyv6aZrZXHGdv9algP1jbTHVjG6Ak4SOdFvISfUzKUJamd1KY38nopHZGJfrIjm8nQ1qIbW86Fd77G2G3f5g3Qkcgi+/IqXBOyYas8VAwr48A9wvxxIwhG1ZoBo+FfoAWLVrEypUrue66U+vA/OIXv2D37t386le/6vOctLQ0mpqahqpEM4wcb/ax9dBxth46jmf/AdortzPWt5fpMQeZSwOL49rIjG0lXVpJSWsmofMEMf43KBvdR28x8ZCU4bSgE9OdIE7Lh+zJPfedfH6GffEpFuBRykI/QCtWrGDNmjU9Qn/NmjX85Cc/CWFVZjjwdXTxwZEGth6spWLvTtort5HV9CEz5ACfiTnAaKl1DoyH9pRRxGYWEJM4qo9gDiC04xJD+2ZN2LPQD9Att9zC/fffj8/nIyEhgf3793P48GHmzp3L4sWLqauro729nR//+McsW7Ys1OWaQaKqVNS18N5HVVTt2Ux75TbS6z9gKge4WQ6QKs5Y8K64WFoyJ5JQsBgKLoBRsyB/NvGpOSF+BybahV/ov7QSjrwX3Gvmz4ZPPHzWQ7Kyspg/fz4vvfQSy5YtY82aNdx6660kJyfz3HPPkZGRgdfr5ZJLLmHp0qW2xm2EaGxtZ9eevRz5cAO+im2kH9/FhM79XCeHiRVnOGRrfConMqfRVXgbOu5CJH8OMbnTSLXhg2YYCr/QD6HuLp7u0H/88cdRVe677z7+/ve/ExMTQ2VlJUePHiU/Pz/U5ZoB6mhvZ/+H2zn6YTm+yq2kHd9Fcfs+5supeVVq4/M5kTMNb+EtZE8qIW7MHJIyx5Fkf+RNmAi/0O+nRT6Yli1bxt13383mzZtpbm7moosu4sknn6S6uppNmzYRHx9PcXFxn9Mpm2GmrYmafVs48uFGfJXbSKvbRaHvIyaJj0lAO7Ecji+metTHqS+cQ/6Uj5E27kKykkeSFerajTkP4Rf6IZSWlsaiRYv40pe+xIoVKwBnFay8vDzi4+N5/fXXOXDgQIirND10dcLxA/iqdnHUswlfxXbSju8it72SbJRs4LimcjBhIltH3UhCwYXkT/0YYybNYZzdNDURyEJ/gFasWMGNN97ImjVrAPjc5z7Hpz71KWbPnk1JSQnTpk0LcYVRqrMdaj+C6g+gejdUf0BX9W60+kNiu9pIwFm3c3/XKHbFT6A8+1oSCi8gf+rHmDxpKnMS7J+CiQ72X/oA3XDDDfhPR52Tk8Pbb7/d57E2Rn8QtLdCjccJd++Hp0K+Zi90nZpArCY+nx2+fD7ovJqq+CJGTbyAqbPnM3tiIVemWQveRC8LfTM8+U64ob7br/W+G+o+OjVRl8TAyPF05UzlUM4VlNZns7Yyg+1teSTGpLNkTj7XzxnDlyZk9T/njDFRIqDQF5ElwCM4a+Q+pqoP93r958AidzMFyFPVTPe1TqB7jOVBVV0ajMJNhGg53ne41x88dUxMHGRPgvxZMPsWyJlCe/YU3qnP4q87ali/4yj1Le2kJ8Vx3ax8/mnOaBZMyiHegt6Y0/Qb+iISCzwKXANUABtFZK27Li4Aqnq33/FfB+b6XaJFVS8830JVNarGvg+3Fc3O24kaN9TdYPe64d5YdeqYuCRnOoGx82He5yF3qvPImgCx8XR0dvHuR7W8sL2Kl5+roq75EGmJcVw7YxT/MGc0CyfnkBhnszMaczaBtPTnAx5V3QcgImuAZcDOMxy/AvhBcMpzJCUlUVNTQ3Z2dlQEv6pSU1NDUlIYf7mnrQn2rIcdz8GBt52l57rFpzphPuFKN9inOT8zx502pW5nl7Jxfy0vbD/My+8fwdvkIyUhlqunO0F/xZTc4C7uYUyECyT0C4BDftsVwMV9HSgi44DxwGt+u5NEpBzoAB5W1ef7OO9O4E6AoqKi065bWFhIRUUF1dXVAZQbGZKSkigsLAx1GQNzMuifhz2vQkeLs8zclCWQN/1UuGcUnHWyr64uZfPBOl7YXsW696o41thGUnwMi6eN4vo5o7lyah7JCRb0xpyLYN/IXQ48q9pjPbNxqlopIhOA10TkPVXd63+Sqq4CVoGzMHrvi8bHxzN+/Pggl2qCwncCPlwPO5+HD185FfTzbocZN0DRJQEtiKGqbDl0nBfdoK+qbyUhLoZFU3O5fs4YFk/PI8WGVRpz3gL5V1SJM8S5W6G7ry/Lga/571DVSvfnPhF5A6e/f+/pp5qw4TsBe15xum66gz41D+beBjNvgKJLAw769yrreXF7FS9sr6LyeAsJsTF8fEou31syjatnjCIt0YLemGAK5F/URmCyiIzHCfvlwGd7HyQi04CRwNt++0YCzaraJiI5wALA5iIORyeD/nnnZ3szpObC3M85LfpxlwUc9DurGnhhexUvbq/iYG0zcTHC5ZNzuOeaKVw9YxQjks9xrVZjTL/6DX1V7RCRu4D1OEM2V6vqDhF5CChX1bXuocuBNdpz2Ml04P+KSBcQg9Onf6YbwGa48TWfatH7B/0FK2DmjQMK+t1HG0+26D/yniA2RrhsYjZ3LZrEtTNHkZmSMARvyBgjw21oYElJiZaXl4e6jOjVHfQ7n3f66ruDfvpSp+tm3IKAF60+WNPM81srWbvtMJ5jTcQIXDIhm+vnjOG6maPItm/GGhM0IrJJVUv6O846TI0T9J5Xna6bD192gj4lBy5Y7nbdLIDYwP5TOd7s44XtVTy/pZLyA3UAzC/O4kfLZrJk1mhy0y3ojQklC/1o1d7iDKvc8Zzboj/hBP2cz7hdN4EHfVtHJ69/cIw/b67k9d3HaO9UJuWl8Z3rpnLD3AIKMpMH+c0YYwJloR9NuoN+5/Ow+2U36LNhzq1u183CgIO+q0vZdLCOP2+u5MXth2lo7SAnLZHPX1rMjXMLmDkmIyq+SGdMuLHQj3TtLeD526muG18TJGfBnE87XTfFlwcc9AB7q5t4fkslz22ppKKuheT4WK6bOYob5xWyYGK2TWxmzDBnoR+pKsrhnV/1DPpZNztdNwMMem9TG3/ddpjnt1SyraKeGIEFk5whltfNzCfVxtIbEzbsX2ukObYLXvsxfPACJGXCrJv8gj7w8e8tvk5e3XWU5zZX8Pc9Xjq7lBmjM7j/H6bzqQvGMCojjOcFMiaKWehHiroD8Ma/wbY1kJgOi/4HXPJPzvMAdXYp7+yr4bktlbz8/hGa2joYPSKJf7x8AjfOLWBqfuDXMsYMTxb64a7pGPz9p1C+2hk/f9ldsPAeSAl8+e4PjjTw3JZK/rLlMEcaWklLjOOTs/O5YW4Bl4zPJibGbsgaEyks9MNVaz289b/h7f8DHa3OvDdXfA9GFAR0+tGGVv6ytZLnthxmV1UDcTHCFVNyuf/66Vw9fZRNV2xMhLLQDzftLbBhFZT+HFrqnP76RfdDzqR+T21q62D9+0d4bkslZXu9qMKFYzN5cOlMrp8z2r4ha0wUsNAPF53tsOW38N//7qw2NelquOr7MObsi5J1dHbxpsfL81sqeWXHUVraOynKSuHrV03mhgvHMCE3bYjegDFmOLDQH+66umDHn+H1f4HafVA4H25+DIoXnvW0qvoWVv19H3/ddhhvk48RyfHcNK+Am+YVMK9opH1xypgoZaE/XKk6X6r6fw/CkfcgbwasWOOsQtVPYL/8/hG+96fttPg6uWpaHjfOK+DKqbm2fqwxxkJ/WDr4DvztQTj4lrNu7I2rYPYt/c5u2eLr5Ecv7uTpdw8yp3AEjyyfy/ic1CEq2hgTDiz0h5Mj78NrP3K+RZuaB5/8Kcy7A+L6n2t+5+EGvrFmC3urm/jqFRO555opJMTZlAjGmJ4s9IeD2o/g9X+F9/4IiRmw+AG4+KuQ0H8rXVV5omw/D7/0AZkp8fz2yxezYFLOEBRtjAlHFvqh1HgE/vsnsPkpiImHBd90HgF+scrb1Ma3/7iNN3ZXc/X0PH5yywVkpdoKVMaYMwso9EVkCfAIznKJj6nqw71e/zmwyN1MAfJUNdN97Q7gfve1H6vqU8EoPKy11EHZI/DOf0JXu9OF8/HvQMbogC/x3x9W861nttHQ2s5Dy2Zy+yXjbESOMaZf/Ya+iMQCjwLXABXARhFZ67/Wrare7Xf814G57vMs4AdACaDAJvfcuqC+i3Dha4Z3/xPKfgGtDc7N2UX3QdaEgC/R1tHJ/3x5N4+VfsSUUWn87isX25w4xpiABdLSnw94VHUfgIisAZYBZ1rgfAVO0ANcB7yqqrXuua8CS4Dfn0/RYafD53Th/P1/QtNRmHwdLP4+5M8e0GX2Vjfxjd9vYcfhBj5/6Tju++R0my7BGDMggYR+AXDIb7sCuLivA0VkHDAeeO0s5542OYyI3AncCVBUVBRASWGiqwvef9b5YlXdfii6DD79FIy7dECXUVWeKT/ED9fuJCk+hl9/voRrZowanJqNMREt2DdylwPPqmrnQE5S1VXAKoCSkhINck1DT9VZd/b/PQTHdsCo2fC5Z52pEwbY717f3M59z73Hi+9VsWBSNj+79UKby94Yc84CCf1KYKzfdqG7ry/Lga/1OvfKXue+EXh5YaihCv74BTj0DowcDzc/DjNvgpiBj5nf8FEtd/9hK0cbWln5iWncefkEm+bYGHNeAgn9jcBkERmPE+LLgc/2PkhEpgEjgbf9dq8H/lVERrrb1wL3nlfFw1lHGzxzOxzdCdf/HObePqDVqk5eprOL//Wah1++toeirBT+9E+XccHYzEEo2BgTbfoNfVXtEJG7cAI8FlitqjtE5CGgXFXXuocuB9aoqvqdWysiP8L5wwHwUPdN3Yi07jtQsRFu/Q3MWHZOlzhU28w//2Ermw7UcfO8Qh5cNpM0W4PWGBMk4pfRw0JJSYmWl5eHuoyBK18NL9wNl3/L+UbtOfjrtsPc99x7oPDjG2ex7MLAFkQxxhgR2aSqJf0dZ03IYDj4Lqz7Lky6xlmbdoBOtHXwg7U7eHZTBfOKMnlk+VzGZqUMQqHGmGhnoX++GqqcfvwRhXDzr/udCbO37RXH+eaarRyoOcE3rprENxZPJi7WJkozxgwOC/3z0X3jtq0Jbn8ekkf2f46rq0v59Zv7+Okru8lJS+T3/3gJF0/IHsRijTHGQv/8vPRd58btp5+CUTMCPu1YQyv3PLONUo+XT8zK5+Gb5jAiZeCjfIwxZqAs9M9V+ROw6UlYeA/MvCHg0/628yjfdVe1evim2XzmY2NtojRjzJCx0D8XhzY4wzMnXQ1X3d//8UBreyf/tm4XT719gBmjM/hfK+YyKc8WJTfGDC0L/YFqqII/3A4jCpwFygO4cfvh0Ua+/vQWdh9t5MsLx/PdJVNtvVpjTEhY6A9Ehw+e+Ty0NcLtf+73xq2q8tt3D/LjF3aSnhTHk1/8GFdOzRuiYo0x5nQW+gPx0nehYgN8+kkYNfOsh9ae8PG9P23n1Z1HuWJKLj/99AXkpicOTZ3GGHMGFvqB2vQkbHoCFt4NM28866Fvebzc/cxW6k608/3rZ/DFy4ptojRjzLBgoR+IQxvgxW/DxMVw1ffPeuj7lfV87vF3mZCTyuN3fIxZBSOGqEhjjOmfhX5/Go8M6MbtKzuOIMCf/ukyMlNskXJjzPBioX82J2/cNjg3blOy+j2l1OPlgrGZFvjGmGHJJnk5m5e/B4fehWWP9nvjFqChtZ1tFfUsnJQzBMUZY8zAWeifyaannOmSF/wzzLopoFPe3VdLZ5eywELfGDNMWej35dBGWPdtmHjVgObGL/N4SY6PZW6RrXJljBmeLPR7azzqzJyZPtpZ33YAUyWXerzMH59l37Y1xgxbAYW+iCwRkd0i4hGRlWc45lYR2SkiO0Tkab/9nSKy1X2s7evcYaP7xm1rPSx/OqAbt92O1LfiOdZk/fnGmGGt39E7IhILPApcA1QAG0Vkraru9DtmMs6C5wtUtU5E/OcaaFHVC4Nc9+B4eSUcegdueQLyZw3o1DKPF8D6840xw1ogLf35gEdV96mqD1gD9F71+x+BR1W1DkBVjwW3zCGw+TdQ/jgs+GbAN279lXm8ZKcmMC0/fRCKM8aY4Agk9AuAQ37bFe4+f1OAKSJSJiLviMgSv9eSRKTc3d/nxPMicqd7THl1dfWA3kBQVJTDi9+CCYtg8Q8GfLqqUurxctmkHJtuwRgzrAXry1lxwGTgSqAQ+LuIzFbV48A4Va0UkQnAayLynqru9T9ZVVcBqwBKSko0SDUFpvEo/OE258btLasHvMYtgOdYE8ca21g4yZY7NMYMb4G09CuBsX7bhe4+fxXAWlVtV9WPgA9x/gigqpXuz33AG8Dc86w5eDp88Mc7oOU4LP/dgG7c+iu1/nxjTJgIJPQ3ApNFZLyIJADLgd6jcJ7HaeUjIjk43T37RGSkiCT67V8A7GS4WH8vHHwblv0S8mef82XKPF6Ks1MoHJkSxOKMMSb4+g19Ve0A7gLWA7uAZ1R1h4g8JCJL3cPWAzUishN4HfiOqtYA04FyEdnm7n/Yf9RPSG3+L9j4GFz2DZh9yzlfpr2zi3f21bJwsrXyjTHDX0B9+qq6DljXa98Dfs8VuMd9+B/zFnDuTejBUrEJXrwHJlx5Tjdu/W2vOE5TW4eNzzfGhIXo+0buyRu3+c54/Njzu5dduqcGEbh0goW+MWb4i66plU/euK2Dr7x6zjdu/ZV5vMwpGMGIlPggFGiMMYMrulr66+8Lyo3bbifaOth8sM5G7Rhjwkb0hP6W38LGX8NlXz+vG7f+NnxUS0eXWn++MSZsREfoV26CF+6B8VfA4h8G7bJv7vGSGBfDvHEjg3ZNY4wZTJEf+k3HYM1tkD4KPv3ked+49VfmTqWcFG9TKRtjwkNkh35nOzzj3rj9zLl/47Yvxxpb2X200frzjTFhJbJH76y/Dw6+5SzpSujLAAAPYUlEQVSGMnpOUC/9lqcGwPrzjTFhJXJb+lt+BxtWwaV3Be3Grb9Sj5fMlHhmjM4I+rWNMWawRGboV26CF+52btxe/WDQL6+qlHm8LJhoUykbY8JL5IV+UzX84XZIGxWUb9z2ZZ/3BFX1rdafb4wJO5HVp9/Z7nzjtrkWvrweUgdnfvvupRGtP98YE24iK/TX/w84UAY3PQajLxi0X1O6x8vYrGSKsm0qZWNMeImc7p3qD52pki+9C+Z8etB+TUdnF2/vq7FWvjEmLEVOSz93ijOJWv7gtfAB3qusp7G1w/rzjTFhKXJCH6DgokH/Fd39+ZdNtNA3xoSfyOneGSKlHi8zx2SQlZoQ6lKMMWbALPQHoNnXweYDx60/3xgTtgIKfRFZIiK7RcQjIivPcMytIrJTRHaIyNN+++8QkT3u445gFR4KG/fX4evssv58Y0zY6rdPX0RigUeBa4AKYKOIrPVf4FxEJgP3AgtUtU5E8tz9WcAPgBJAgU3uuXXBfyuDr8zjJSEuhvnjgzdxmzHGDKVAWvrzAY+q7lNVH7AGWNbrmH8EHu0Oc1U95u6/DnhVVWvd114FlgSn9KFXusdLybiRNpWyMSZsBRL6BcAhv+0Kd5+/KcAUESkTkXdEZMkAzkVE7hSRchEpr66uDrz6IVTT1MbOqgbr2jHGhLVg3ciNAyYDVwIrgF+LSGagJ6vqKlUtUdWS3NzcIJUUXG/ttamUjTHhL5DQrwTG+m0Xuvv8VQBrVbVdVT8CPsT5IxDIuWGhzOMlIymOWQUjQl2KMcacs0BCfyMwWUTGi0gCsBxY2+uY53Fa+YhIDk53zz5gPXCtiIwUkZHAte6+sKKqvLnHy2UTc4i1qZSNMWGs39BX1Q7gLpyw3gU8o6o7ROQhEVnqHrYeqBGRncDrwHdUtUZVa4Ef4fzh2Ag85O4LKwdqmqk83sKCyda1Y4wJbwFNw6Cq64B1vfY94PdcgXvcR+9zVwOrz6/M0Cq1qZSNMRHCvpEbgDKPl4LMZIptKmVjTJiz0O9HZ5fy1t4aFkzKRsT6840x4c1Cvx87DtdT39Ju4/ONMRHBQr8fpTaVsjEmgljo96PM42Vafjq56YmhLsUYY86bhf5ZtLZ3snF/nY3aMcZEDAv9syjfX4evo8vG5xtjIoaF/lmUerzExwrzi20qZWNMZLDQP4syj5e5RSNJTYyspYSNMdHLQv8M6k74eP9wvfXnG2MiioX+Gby9rwZVbHy+MSaiWOifQanHS1piHBcU2lTKxpjIYaF/BmUeL5dMyCYu1j4iY0zksETrw6HaZg7UNHO5DdU0xkQYC/0+lLlTL1h/vjEm0ljo96HU4yU/I4mJuamhLsUYY4LKQr+XrpNTKefYVMrGmIgTUOiLyBIR2S0iHhFZ2cfrXxCRahHZ6j6+4vdap9/+3mvrDjs7qxqoPeFj4eTsUJdijDFB1+9XTUUkFngUuAaoADaKyFpV3dnr0D+o6l19XKJFVS88/1KHxsn+fJtK2RgTgQJp6c8HPKq6T1V9wBpg2eCWFTqlHi9TRqWRl5EU6lKMMSboAgn9AuCQ33aFu6+3m0Vku4g8KyJj/fYniUi5iLwjIjf09QtE5E73mPLq6urAqw8yZyrlWhu1Y4yJWMG6kftXoFhV5wCvAk/5vTZOVUuAzwK/EJGJvU9W1VWqWqKqJbm5uUEqaeA2H6yjtb3L5tsxxkSsQEK/EvBvuRe6+05S1RpVbXM3HwMu8nut0v25D3gDmHse9Q6qMo+X2Bjh4gl2E9cYE5kCCf2NwGQRGS8iCcByoMcoHBEZ7be5FNjl7h8pIonu8xxgAdD7BvCwUeqpYe7YTNJsKmVjTITqN91UtUNE7gLWA7HAalXdISIPAeWquhb4hogsBTqAWuAL7unTgf8rIl04f2Ae7mPUz7BQ39zOexXH+fpVk0NdijHGDJqAmrSqug5Y12vfA37P7wXu7eO8t4DZ51njkHh7Xw1dCgttvh1jTASzb+S6yjxeUhNiuXBsZqhLMcaYQWOh7yrzeLl4QjbxNpWyMSaCWcIBlcdb2Oc9YePzjTERz0KfU1Mv2Ph8Y0yks9DHCf2ctESmjEoLdSnGGDOooj70VZUyj5eFk7JtKmVjTMSL+tDffbQRb5PP+vONMVEh6kO/dI8tjWiMiR5RH/plHi8TclMZk5kc6lKMMWbQRXXo+zq6ePejWi63Vr4xJkpEdehvOVhHs6/TunaMMVEjqkO/zOMlRuCSiTaVsjEmOkR16Jd6vFwwNpOMpPhQl2KMMUMiakO/obWdbRX19i1cY0xUidrQf3dfLZ1dav35xpioErWhX+bxkhwfy9wim0rZGBM9ojb0Sz1e5o/PIjEuNtSlGGPMkAko9EVkiYjsFhGPiKzs4/UviEi1iGx1H1/xe+0OEdnjPu4IZvHn6kh9K55jTdafb4yJOv0ulygiscCjwDVABbBRRNb2sdbtH1T1rl7nZgE/AEoABTa559YFpfpz1D2VsvXnG2OiTSAt/fmAR1X3qaoPWAMsC/D61wGvqmqtG/SvAkvOrdTgKfN4yU5NYFp+eqhLMcaYIRVI6BcAh/y2K9x9vd0sIttF5FkRGTuQc0XkThEpF5Hy6urqAEs/N6pKqcfLZZNyiImxqZSNMdElWDdy/woUq+ocnNb8UwM5WVVXqWqJqpbk5uYGqaS+eY41cayxjYWT7Fu4xpjoE0joVwJj/bYL3X0nqWqNqra5m48BFwV67lArtf58Y0wUCyT0NwKTRWS8iCQAy4G1/geIyGi/zaXALvf5euBaERkpIiOBa919IVPm8VKcnULhyJRQlmGMMSHR7+gdVe0QkbtwwjoWWK2qO0TkIaBcVdcC3xCRpUAHUAt8wT23VkR+hPOHA+AhVa0dhPcRkPbOLt7ZV8uyC8eEqgRjjAmpfkMfQFXXAet67XvA7/m9wL1nOHc1sPo8agya7RXHaWrrsPH5xpioFVXfyC3dU4MIXGpTKRtjolRUhX6Zx8vsghFkpiSEuhRjjAmJqAn9E20dbD5YZ6N2jDFRLWpCf8NHtXR0qfXnG2OiWtSE/pt7vCTGxXDRuJGhLsUYY0ImakK/zJ1KOSneplI2xkSvqAj9Y42t7D7aaP35xpioFxWh/5anBsD6840xUS8qQr/U4yUzJZ4ZozNCXYoxxoRUxIe+qlLm8bJgok2lbIwxER/6+7wnqKpvtf58Y4whCkK/e2lE6883xpgoCP3SPV7GZiVTlG1TKRtjTESHfkdnF2/vq7FWvjHGuCI69N+rrKextcP6840xxhXRod/dn3/ZRAt9Y4yBCA/9Uo+XmWMyyEq1qZSNMQYCDH0RWSIiu0XEIyIrz3LczSKiIlLibheLSIuIbHUf/xmswvvT7Otg84Hj1p9vjDF++l0uUURigUeBa4AKYKOIrFXVnb2OSwe+Cbzb6xJ7VfXCINUbsI376/B1dll/vjHG+AmkpT8f8KjqPlX1AWuAZX0c9yPg34HWINZ3zso8XhJiY/hYcVaoSzHGmGEjkNAvAA75bVe4+04SkXnAWFV9sY/zx4vIFhH5bxG5/NxLHZjSPV4uGjeS5ASbStkYY7qd941cEYkBfgZ8q4+Xq4AiVZ0L3AM8LSKnzXomIneKSLmIlFdXV59vSdQ0tbGzqoGFk61rxxhj/AUS+pXAWL/tQndft3RgFvCGiOwHLgHWikiJqrapag2Aqm4C9gJTev8CVV2lqiWqWpKbm3tu78TPW3udqZStP98YY3oKJPQ3ApNFZLyIJADLgbXdL6pqvarmqGqxqhYD7wBLVbVcRHLdG8GIyARgMrAv6O+ilzKPl/SkOGYXjBjsX2WMMWGl39E7qtohIncB64FYYLWq7hCRh4ByVV17ltM/DjwkIu1AF/BVVa0NRuFnqZc393i5bGI2sTaVsjHG9NBv6AOo6jpgXa99D5zh2Cv9nv8J+NN51DdgB2qaqTzewlevnDiUv9YYY8JCxH0jt9SmUjbGmDOKuNAv83gpyEym2KZSNsaY00RU6Hd2KW/trWHBpGxErD/fGGN6i6jQ33G4nvqWdhuqaYwxZxBRoV9qUykbY8xZRVTol3m8TMtPJzc9MdSlGGPMsBQxod/a3snG/XU2ascYY84iYkK/oaWdT8zK56rpeaEuxRhjhq2AvpwVDvIyknhk+dxQl2GMMcNaxLT0jTHG9M9C3xhjooiFvjHGRBELfWOMiSIW+sYYE0Us9I0xJopY6BtjTBSx0DfGmCgiqhrqGnoQkWrgwHlcIgfwBqmccGefRU/2efRkn8cpkfBZjFPV3P4OGnahf75EpFxVS0Jdx3Bgn0VP9nn0ZJ/HKdH0WVj3jjHGRBELfWOMiSKRGPqrQl3AMGKfRU/2efRkn8cpUfNZRFyfvjHGmDOLxJa+McaYM7DQN8aYKBIxoS8iS0Rkt4h4RGRlqOsJJREZKyKvi8hOEdkhIt8MdU2hJiKxIrJFRF4IdS2hJiKZIvKsiHwgIrtE5NJQ1xRKInK3++/kfRH5vYgkhbqmwRQRoS8iscCjwCeAGcAKEZkR2qpCqgP4lqrOAC4BvhblnwfAN4FdoS5imHgEeFlVpwEXEMWfi4gUAN8ASlR1FhALLA9tVYMrIkIfmA94VHWfqvqANcCyENcUMqpapaqb3eeNOP+oC0JbVeiISCHwD8Bjoa4l1ERkBPBx4HEAVfWp6vHQVhVycUCyiMQBKcDhENczqCIl9AuAQ37bFURxyPkTkWJgLvBuaCsJqV8A3wW6Ql3IMDAeqAaecLu7HhOR1FAXFSqqWgn8FDgIVAH1qvpKaKsaXJES+qYPIpIG/An4Z1VtCHU9oSAi1wPHVHVTqGsZJuKAecCvVHUucAKI2ntgIjISp1dgPDAGSBWR20Jb1eCKlNCvBMb6bRe6+6KWiMTjBP7vVPXPoa4nhBYAS0VkP06331Ui8tvQlhRSFUCFqnb/n9+zOH8EotXVwEeqWq2q7cCfgctCXNOgipTQ3whMFpHxIpKAcyNmbYhrChkREZw+212q+rNQ1xNKqnqvqhaqajHOfxevqWpEt+TORlWPAIdEZKq7azGwM4QlhdpB4BIRSXH/3Swmwm9sx4W6gGBQ1Q4RuQtYj3P3fbWq7ghxWaG0ALgdeE9Etrr77lPVdSGsyQwfXwd+5zaQ9gFfDHE9IaOq74rIs8BmnFFvW4jwKRlsGgZjjIkikdK9Y4wxJgAW+sYYE0Us9I0xJopY6BtjTBSx0DfGmChioW+MMVHEQt8YY6LI/wexdS60QGyfXwAAAABJRU5ErkJggg==\n", 306 | "text/plain": [ 307 | "
" 308 | ] 309 | }, 310 | "metadata": { 311 | "needs_background": "light" 312 | }, 313 | "output_type": "display_data" 314 | } 315 | ], 316 | "source": [ 317 | "loss_curve = history.history[\"loss\"]\n", 318 | "acc_curve = history.history[\"accuracy\"]\n", 319 | "\n", 320 | "loss_val_curve = history.history[\"val_loss\"]\n", 321 | "acc_val_curve = history.history[\"val_accuracy\"]\n", 322 | "\n", 323 | "plt.plot(loss_curve, label=\"Train\")\n", 324 | "plt.plot(loss_val_curve, label=\"Val\")\n", 325 | "plt.legend(loc='upper left')\n", 326 | "plt.title(\"Loss\")\n", 327 | "plt.show()\n", 328 | "\n", 329 | "plt.plot(acc_curve, label=\"Train\")\n", 330 | "plt.plot(acc_val_curve, label=\"Val\")\n", 331 | "plt.legend(loc='upper left')\n", 332 | "plt.title(\"Accuracy\")\n", 333 | "plt.show()" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": 11, 339 | "metadata": {}, 340 | "outputs": [ 341 | { 342 | "name": "stdout", 343 | "output_type": "stream", 344 | "text": [ 345 | "10000/10000 [==============================] - 0s 35us/sample - loss: 0.6163 - accuracy: 0.7856\n", 346 | "Test Loss 0.6163142968177795\n", 347 | "Test Accuracy 0.7856\n" 348 | ] 349 | } 350 | ], 351 | "source": [ 352 | "loss, acc = model.evaluate(images_test, targets_test)\n", 353 | "print(\"Test Loss\", loss)\n", 354 | "print(\"Test Accuracy\", acc)" 355 | ] 356 | } 357 | ], 358 | "metadata": { 359 | "kernelspec": { 360 | "display_name": "Python 3", 361 | "language": "python", 362 | "name": "python3" 363 | }, 364 | "language_info": { 365 | "codemirror_mode": { 366 | "name": "ipython", 367 | "version": 3 368 | }, 369 | "file_extension": ".py", 370 | "mimetype": "text/x-python", 371 | "name": "python", 372 | "nbconvert_exporter": "python", 373 | "pygments_lexer": "ipython3", 374 | "version": "3.6.7" 375 | } 376 | }, 377 | "nbformat": 4, 378 | "nbformat_minor": 2 379 | } 380 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Tensorflow2.0 - Examples 2 | Jupyter notebooks to help you started with tensorflow 2.0. The repository includes notebooks to start with simple NN, understand autograph, learn how to train models, CNN to analyze images with tf.data and RNN to generate text! 3 | 4 | $> pip install tensorflow 5 | 6 | ## To get started 7 | 8 | 1. If your are new into Tensorflow2.0 or you love to use some old fashion Tensorflow then you might want to start with this notebook: Introduction - Simple Neural Network.ipynb With tensorflow2.0 it is higly recommend to use the tf.keras module if possible. This notebook will give you a first example with the Fashion MNIST Dataset. 9 | 10 | 2. Now that you are familar with tf.keras you can check the difference between eager mode and grah mode in this notebook: 11 | Graph Mode vs Eager Mode.ipynb. 12 | 13 | 3. Training a model has never been so easy. Let's check how you can do it with this notebook: 14 | Train a model.ipynb 15 | 16 | 4. Learn how to use the Subclassing API to built your model: 17 | Subclassing API 18 | 19 | 5. Learn how to create a custom Layer with low level operations: Create your own layer 20 | 21 | ## Projects examples 22 | 23 | 6. Learn how to create a CNN model to analayse the QuickDraw dataset. You will use autograph, the model subclassing API and tf.data: Quick Draw CNN.ipynb 24 | 25 | 7. Learn how to generate text with an RNN. You will use a simple custom keras layer and autograph: RNN - Text Generator.ipynb 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /Subclassing API.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Subclassing API - Tensorflow 2.0" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 15, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import tensorflow as tf\n", 17 | "import numpy as np" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "## Be sure to used Tensorflow 2.0" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 16, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "### Import the dataset" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 17, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "from sklearn.preprocessing import StandardScaler\n", 50 | "# Fashio MNIST\n", 51 | "fashion_mnist = tf.keras.datasets.fashion_mnist\n", 52 | "(images, targets), (_, _) = fashion_mnist.load_data()\n", 53 | "# Get only a subpart of the dataset\n", 54 | "images = images[:10000]\n", 55 | "targets = targets [:10000]\n", 56 | "# Reshape the dataset and convert to float\n", 57 | "images = images.reshape(-1, 784)\n", 58 | "images = images.astype(float)\n", 59 | "# Normalize images\n", 60 | "scaler = StandardScaler()\n", 61 | "images = scaler.fit_transform(images)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "## Create a model using the SubClassing API\n", 69 | "The following call is not working because self.output is already set by the parent: tf.keras.Model" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 19, 75 | "metadata": {}, 76 | "outputs": [ 77 | { 78 | "name": "stdout", 79 | "output_type": "stream", 80 | "text": [ 81 | "e= can't set attribute\n" 82 | ] 83 | } 84 | ], 85 | "source": [ 86 | "class CustomModel(tf.keras.Model):\n", 87 | " \n", 88 | " def __init__(self):\n", 89 | " super(CustomModel, self).__init__()\n", 90 | "\n", 91 | " # First in the init method you need to instanciate the layers you will use\n", 92 | " self.first_layer = tf.keras.layers.Dense(64)\n", 93 | " # WARNING: DO NOT CALL ONE OF YOUR CLASS VARIABLE: output\n", 94 | " self.output = tf.keras.layers.Dense(10, activation='softmax', name=\"d1\")\n", 95 | "\n", 96 | " def call(self, x):\n", 97 | " # Then in the call method you can execute your operations\n", 98 | " layer1_out = self.first_layer(x)\n", 99 | " output = self.output_layer(layer1_out)\n", 100 | " return output\n", 101 | "\n", 102 | "try:\n", 103 | " model = CustomModel()\n", 104 | "except Exception as e:\n", 105 | " print(\"e=\", e)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 26, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "data": { 115 | "text/plain": [ 116 | "array([[0.07368525, 0.01174379, 0.03136529, 0.01404753, 0.15259095,\n", 117 | " 0.14582336, 0.19374155, 0.26966166, 0.07976336, 0.02757731]],\n", 118 | " dtype=float32)" 119 | ] 120 | }, 121 | "execution_count": 26, 122 | "metadata": {}, 123 | "output_type": "execute_result" 124 | } 125 | ], 126 | "source": [ 127 | "class CustomModel(tf.keras.Model):\n", 128 | " \n", 129 | " def __init__(self):\n", 130 | " super(CustomModel, self).__init__() \n", 131 | " # First in the init method you need to instanciate the layers you will use\n", 132 | " self.first_layer = tf.keras.layers.Dense(64, activation=\"relu\", name=\"first_layer\")\n", 133 | " self.output_layer = tf.keras.layers.Dense(10, activation='softmax', name=\"output_layer\")\n", 134 | "\n", 135 | " def call(self, x):\n", 136 | " # Then in the call method you can execute your operations\n", 137 | " prev = self.first_layer(x)\n", 138 | " out = self.output_layer(prev)\n", 139 | " return out\n", 140 | "\n", 141 | "model = CustomModel()\n", 142 | "model.predict(images[0:1])" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "The cell above is now working: We can call model.predict as we would do with a basic keras model.
\n", 150 | "The predict method of the parent class called the call method from the CustomModel class" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 27, 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "data": { 160 | "text/plain": [ 161 | "array([[0.07368525, 0.01174379, 0.03136529, 0.01404753, 0.15259095,\n", 162 | " 0.14582336, 0.19374155, 0.26966166, 0.07976336, 0.02757731]],\n", 163 | " dtype=float32)" 164 | ] 165 | }, 166 | "execution_count": 27, 167 | "metadata": {}, 168 | "output_type": "execute_result" 169 | } 170 | ], 171 | "source": [ 172 | "model.predict(images[0:1])" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "### Train the model\n", 180 | "\n", 181 | "The model can be used as a normal keras model. Thus, to train it you just need to compile and to fit the model." 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 28, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [ 190 | "# Compile the model\n", 191 | "model.compile(\n", 192 | " loss=\"sparse_categorical_crossentropy\",\n", 193 | " optimizer=\"sgd\",\n", 194 | " metrics=[\"accuracy\"]\n", 195 | ")" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 29, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "name": "stdout", 205 | "output_type": "stream", 206 | "text": [ 207 | "Epoch 1/10\n", 208 | "10000/10000 [==============================] - 0s 46us/sample - loss: 1.7226 - accuracy: 0.4421\n", 209 | "Epoch 2/10\n", 210 | "10000/10000 [==============================] - 0s 38us/sample - loss: 1.0365 - accuracy: 0.6625\n", 211 | "Epoch 3/10\n", 212 | "10000/10000 [==============================] - 0s 37us/sample - loss: 0.8662 - accuracy: 0.7163\n", 213 | "Epoch 4/10\n", 214 | "10000/10000 [==============================] - 0s 37us/sample - loss: 0.7776 - accuracy: 0.7437\n", 215 | "Epoch 5/10\n", 216 | "10000/10000 [==============================] - 0s 38us/sample - loss: 0.7210 - accuracy: 0.7616\n", 217 | "Epoch 6/10\n", 218 | "10000/10000 [==============================] - 0s 39us/sample - loss: 0.6805 - accuracy: 0.7699\n", 219 | "Epoch 7/10\n", 220 | "10000/10000 [==============================] - 0s 38us/sample - loss: 0.6491 - accuracy: 0.7802\n", 221 | "Epoch 8/10\n", 222 | "10000/10000 [==============================] - 0s 37us/sample - loss: 0.6239 - accuracy: 0.7876\n", 223 | "Epoch 9/10\n", 224 | "10000/10000 [==============================] - 0s 38us/sample - loss: 0.6025 - accuracy: 0.7949\n", 225 | "Epoch 10/10\n", 226 | "10000/10000 [==============================] - 0s 47us/sample - loss: 0.5846 - accuracy: 0.7973\n" 227 | ] 228 | } 229 | ], 230 | "source": [ 231 | "history = model.fit(images, targets, epochs=10)" 232 | ] 233 | } 234 | ], 235 | "metadata": { 236 | "kernelspec": { 237 | "display_name": "Python 3", 238 | "language": "python", 239 | "name": "python3" 240 | }, 241 | "language_info": { 242 | "codemirror_mode": { 243 | "name": "ipython", 244 | "version": 3 245 | }, 246 | "file_extension": ".py", 247 | "mimetype": "text/x-python", 248 | "name": "python", 249 | "nbconvert_exporter": "python", 250 | "pygments_lexer": "ipython3", 251 | "version": "3.6.7" 252 | } 253 | }, 254 | "nbformat": 4, 255 | "nbformat_minor": 2 256 | } 257 | -------------------------------------------------------------------------------- /Train a model.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Train a model" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "Limited tf.compat.v2.summary API due to missing TensorBoard installation\n", 20 | "Limited tf.summary API due to missing TensorBoard installation\n" 21 | ] 22 | } 23 | ], 24 | "source": [ 25 | "import tensorflow as tf\n", 26 | "import numpy as np" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## Be sure to used Tensorflow 2.0" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 2, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "## Start by creating a simple model" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 3, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "# Flatten\n", 59 | "model = tf.keras.models.Sequential()\n", 60 | "# Add layers\n", 61 | "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n", 62 | "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n", 63 | "model.add(tf.keras.layers.Dense(2, activation=\"softmax\"))" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "## Setup the optimizer, loss function and one metrics" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 4, 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [ 79 | "# The loss method\n", 80 | "loss_object = tf.keras.losses.SparseCategoricalCrossentropy()\n", 81 | "# The optimize\n", 82 | "optimizer = tf.keras.optimizers.Adam()\n", 83 | "# This metrics is used to track the progress of the training loss during the training\n", 84 | "train_loss = tf.keras.metrics.Mean(name='train_loss')" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "## Create a method which used autograph to train the model" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 5, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "@tf.function\n", 101 | "def train_step(image, targets):\n", 102 | " with tf.GradientTape() as tape:\n", 103 | " # Make a prediction\n", 104 | " predictions = model(image)\n", 105 | " # Get the error/loss using the loss_object previously defined\n", 106 | " loss = loss_object(targets, predictions)\n", 107 | " # Compute the gradient which respect to the loss\n", 108 | " gradients = tape.gradient(loss, model.trainable_variables)\n", 109 | " # Change the weights of the model\n", 110 | " optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n", 111 | " # The metrics are accumulate over time. You don't need to average it yourself.\n", 112 | " train_loss(loss)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "## Train the model" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 6, 125 | "metadata": {}, 126 | "outputs": [ 127 | { 128 | "name": "stdout", 129 | "output_type": "stream", 130 | "text": [ 131 | "Loss: tf.Tensor(0.1528348, shape=(), dtype=float32)\n", 132 | "Loss: tf.Tensor(0.0039809044, shape=(), dtype=float32)\n", 133 | "Loss: tf.Tensor(0.0005385667, shape=(), dtype=float32)\n", 134 | "Loss: tf.Tensor(0.00018396397, shape=(), dtype=float32)\n", 135 | "Loss: tf.Tensor(0.000104101564, shape=(), dtype=float32)\n", 136 | "Loss: tf.Tensor(7.665776e-05, shape=(), dtype=float32)\n", 137 | "Loss: tf.Tensor(6.355264e-05, shape=(), dtype=float32)\n", 138 | "Loss: tf.Tensor(5.551449e-05, shape=(), dtype=float32)\n", 139 | "Loss: tf.Tensor(4.9656337e-05, shape=(), dtype=float32)\n", 140 | "Loss: tf.Tensor(4.493916e-05, shape=(), dtype=float32)\n" 141 | ] 142 | } 143 | ], 144 | "source": [ 145 | "for epoch in range(0, 10):\n", 146 | " for _ in range(0, 10):\n", 147 | " # Create fake inputs with two class\n", 148 | " # Create fake inputs\n", 149 | " inputs = np.zeros((2, 30))\n", 150 | " inputs[0] -= 1\n", 151 | " inputs[1] = 1\n", 152 | " # Create fake targets\n", 153 | " targets = np.zeros((2, 1))\n", 154 | " targets[0] = 0\n", 155 | " targets[1] = 1\n", 156 | " # Train the model\n", 157 | " train_step(inputs, targets)\n", 158 | " print(\"Loss: %s\" % train_loss.result())\n", 159 | " train_loss.reset_states()" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "# IMPORTANT\n", 167 | "Because we used graph mode during the training we can't anymore used the model with model.predict but only in eager mode." 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 7, 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "name": "stdout", 177 | "output_type": "stream", 178 | "text": [ 179 | "error===> Unknown graph. Aborting.\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "try:\n", 185 | " input_ = np.zeros((1, 30)) + 1\n", 186 | " model.predict(input_)\n", 187 | "except Exception as e:\n", 188 | " print(\"error===>\", e)" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "However, we can still used the eager mode!" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 10, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "data": { 205 | "text/plain": [ 206 | "" 207 | ] 208 | }, 209 | "execution_count": 10, 210 | "metadata": {}, 211 | "output_type": "execute_result" 212 | } 213 | ], 214 | "source": [ 215 | "input_ = np.zeros((1, 30)) + 1\n", 216 | "model(input_)" 217 | ] 218 | } 219 | ], 220 | "metadata": { 221 | "kernelspec": { 222 | "display_name": "Python 3", 223 | "language": "python", 224 | "name": "python3" 225 | }, 226 | "language_info": { 227 | "codemirror_mode": { 228 | "name": "ipython", 229 | "version": 3 230 | }, 231 | "file_extension": ".py", 232 | "mimetype": "text/x-python", 233 | "name": "python", 234 | "nbconvert_exporter": "python", 235 | "pygments_lexer": "ipython3", 236 | "version": "3.6.7" 237 | } 238 | }, 239 | "nbformat": 4, 240 | "nbformat_minor": 2 241 | } 242 | -------------------------------------------------------------------------------- /images/architecture_rnn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thibo73800/tensorflow2.0-examples/75af5fe0a2cc6744c020bb5cc4bbf552f225298f/images/architecture_rnn.png -------------------------------------------------------------------------------- /images/categorical_cross_entropy.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thibo73800/tensorflow2.0-examples/75af5fe0a2cc6744c020bb5cc4bbf552f225298f/images/categorical_cross_entropy.gif -------------------------------------------------------------------------------- /images/cnn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thibo73800/tensorflow2.0-examples/75af5fe0a2cc6744c020bb5cc4bbf552f225298f/images/cnn.png -------------------------------------------------------------------------------- /images/rnn_letter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thibo73800/tensorflow2.0-examples/75af5fe0a2cc6744c020bb5cc4bbf552f225298f/images/rnn_letter.png -------------------------------------------------------------------------------- /images/rnn_vocab.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thibo73800/tensorflow2.0-examples/75af5fe0a2cc6744c020bb5cc4bbf552f225298f/images/rnn_vocab.png -------------------------------------------------------------------------------- /images/simple_nn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thibo73800/tensorflow2.0-examples/75af5fe0a2cc6744c020bb5cc4bbf552f225298f/images/simple_nn.png -------------------------------------------------------------------------------- /others/Simple neural network-Error-Function.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Import" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "Limited tf.compat.v2.summary API due to missing TensorBoard installation\n", 20 | "Limited tf.summary API due to missing TensorBoard installation\n" 21 | ] 22 | } 23 | ], 24 | "source": [ 25 | "# Matplotlib\n", 26 | "import matplotlib.pyplot as plt\n", 27 | "# Tensorflow\n", 28 | "import tensorflow as tf\n", 29 | "# Numpy and Pandas\n", 30 | "import numpy as np\n", 31 | "import pandas as pd\n", 32 | "# Ohter import\n", 33 | "import sys\n", 34 | "\n", 35 | "\n", 36 | "from sklearn.preprocessing import StandardScaler\n" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "## Be sure to used Tensorflow 2.0" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 2, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [ 52 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "## Load the dataset: Fashion MNIST" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "![](https://storage.googleapis.com/kaggle-datasets-images/2243/3791/9384af51de8baa77f6320901f53bd26b/dataset-cover.png)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 3, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "(10000, 784)\n", 79 | "(10000,)\n" 80 | ] 81 | } 82 | ], 83 | "source": [ 84 | "# Fashio MNIST\n", 85 | "fashion_mnist = tf.keras.datasets.fashion_mnist\n", 86 | "(images, targets), (_, _) = fashion_mnist.load_data()\n", 87 | "# Get only a subpart of the dataset\n", 88 | "# Get only a subpart\n", 89 | "images = images[:10000]\n", 90 | "targets = targets [:10000]\n", 91 | "\n", 92 | "images = images.reshape(-1, 784)\n", 93 | "images = images.astype(float)\n", 94 | "scaler = StandardScaler()\n", 95 | "images = scaler.fit_transform(images)\n", 96 | "\n", 97 | "print(images.shape)\n", 98 | "print(targets.shape)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "## Plot one of the data" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 4, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "data": { 115 | "image/png": "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\n", 116 | "text/plain": [ 117 | "
" 118 | ] 119 | }, 120 | "metadata": { 121 | "needs_background": "light" 122 | }, 123 | "output_type": "display_data" 124 | } 125 | ], 126 | "source": [ 127 | "targets_names = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\", \"Sandal\", \n", 128 | " \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"\n", 129 | "]\n", 130 | "# Plot one image\n", 131 | "plt.imshow(images[10].reshape(28, 28), cmap=\"binary\")\n", 132 | "#plt.title(targets_names[targets[10]])\n", 133 | "plt.title(targets_names[targets[10]])\n", 134 | "plt.show()" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 5, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "First line of one image [-0.01426971 -0.02645579 -0.029489 -0.04635542 -0.06156617 -0.07641125\n", 147 | " -0.10509579 -0.16410192 -0.23986957 -0.36929666 -0.57063232 -0.6909092\n", 148 | " -0.7582382 -0.74450346 -0.17093142 0.80572169 0.60465021 0.69474334\n", 149 | " 0.01007169 -0.32085836 -0.20882718 -0.14379861 -0.11434416 -0.09302065\n", 150 | " 0.08584529 -0.04969764 -0.03368099 -0.01591863 -0.0181322 -0.02297209\n", 151 | " -0.03365679 -0.05814043 -0.08287213 -0.13053264 -0.2464668 -0.35905423\n", 152 | " -0.48335079 -0.63909239 -0.83575443 -0.98917162 -1.08347998 -1.07712864\n", 153 | " 0.7931674 1.2496451 1.35025207 1.68512162 1.97595936 1.43181167\n", 154 | " 2.97956664 4.68907298 4.88750284 0.23595608 -0.11565956 0.14562865\n", 155 | " -0.06100298 -0.03312088 -0.01964757 -0.02793878 -0.0481181 -0.07617253\n", 156 | " -0.12670992 -0.26684818 -0.39945708 -0.49720396 -0.62326614 -0.8195795\n", 157 | " -0.99379417 -1.04759214 -1.10371252 -1.10221791 1.08283564 1.22639277\n", 158 | " 1.35310524 1.34234162 1.66433217 2.15862735 2.75297169 3.22113197\n", 159 | " 4.62472272 3.87445967 -0.16599094 0.32418594 -0.087733 -0.0526323\n", 160 | " -0.02862848 -0.04242726 -0.06957184 -0.10501986 -0.21177968 -0.36570732\n", 161 | " -0.50377706 -0.63129117 -0.7545061 -0.92782181 -1.04671762 -1.04884575\n", 162 | " -1.10753111 -1.03315535 1.43294532 1.33033833 1.39162212 1.50249446\n", 163 | " 1.41472555 1.48664927 2.19750146 2.5207204 3.23681206 0.32439317\n", 164 | " -0.22921786 0.08719395 -0.11524194 -0.06595022 -0.03978101 -0.06151816\n", 165 | " -0.09394236 -0.14485093 -0.28258668 -0.45013464 -0.60762152 -0.70866125\n", 166 | " -0.80845132 -0.97106764 -1.06309306 -1.04395211 -1.11950469 -0.35989804\n", 167 | " 1.56262616 1.30932327 1.41614857 1.49002634 1.44030778 1.4974615\n", 168 | " 2.02811047 2.22341936 2.1189369 0.28273308 0.22687411 -0.22359138\n", 169 | " -0.07278968 -0.09631577 -0.05785819 -0.08665899 -0.12303533 -0.19276323\n", 170 | " -0.34094366 -0.53007774 -0.6636926 -0.76166986 -0.85810993 -1.01973474\n", 171 | " -1.10359032 -1.13389127 -1.13797187 0.19728184 1.30491585 1.12589712\n", 172 | " 1.56101992 1.5471799 1.35519155 1.61848413 1.8686844 1.86320923\n", 173 | " 0.84284685 1.09578392 0.74105846 -0.28563328 -0.1131897 -0.11759717\n", 174 | " -0.07138681 -0.10484842 -0.15218768 -0.23983624 -0.39446008 -0.58540856\n", 175 | " -0.70817066 -0.80613957 -0.8912735 -1.04743568 -1.11648233 -1.16203361\n", 176 | " -1.16480491 0.86892733 1.27412159 0.8998086 0.74428789 1.13274167\n", 177 | " 1.14002008 1.64475384 1.22579108 1.87626568 0.72713619 -0.21425058\n", 178 | " -0.44976207 -0.3588039 -0.26052139 -0.14642704 -0.09057754 -0.12852483\n", 179 | " -0.17658578 -0.27962415 -0.43604854 -0.62328729 -0.74417079 -0.83698675\n", 180 | " -0.91538507 -1.05836072 -1.09984451 -1.18744141 -1.19142578 1.24141786\n", 181 | " 1.39079751 1.49192297 1.27955426 1.30948745 1.17061076 0.86607308\n", 182 | " 1.27421913 0.79750725 -0.86719519 -0.69061632 -0.50423389 -0.42229875\n", 183 | " -0.30440602 -0.16353165 -0.09817535 -0.14372941 -0.20517067 -0.30866173\n", 184 | " -0.4655249 -0.65221334 -0.76683863 -0.85659993 -0.93256978 -1.06226401\n", 185 | " -1.15171237 -1.21294298 -0.55403601 1.46120819 0.97836915 1.05122066\n", 186 | " 1.2521523 1.05790293 1.35951983 0.90500191 1.55701257 0.82622186\n", 187 | " -0.93881345 -0.7662494 -0.57465574 -0.48552019 -0.34738009 -0.18855983\n", 188 | " -0.10483514 -0.16127624 -0.22554475 -0.32839989 -0.48754623 -0.66943952\n", 189 | " -0.77552861 -0.86498292 -0.94273549 -1.06015652 -1.18041842 -1.23791689\n", 190 | " 0.42552833 1.46179792 0.99490898 0.75506225 0.87837333 0.82699162\n", 191 | " 1.09938829 0.76830616 1.48553714 -0.13338616 0.50592885 -0.83182562\n", 192 | " -0.65812 -0.54406795 -0.39662058 -0.21430757 -0.11419072 -0.17789518\n", 193 | " -0.23568605 -0.33542269 -0.5026126 -0.67620553 -0.77596799 -0.86788207\n", 194 | " -0.94980187 -1.03197874 -1.22037631 -1.30832137 1.13203817 1.20044543\n", 195 | " 1.26727922 1.22318096 1.33469514 1.2591838 1.27789102 0.95415321\n", 196 | " 1.45083593 -1.14975179 -0.0817779 1.07590662 -0.71352465 -0.61851141\n", 197 | " -0.45102226 -0.23988228 -0.1324622 -0.1914184 -0.23850724 -0.33502594\n", 198 | " -0.50210849 -0.67112987 -0.76673944 -0.8616405 -0.96676107 -1.0848351\n", 199 | " -1.3330483 -0.93497502 1.45610367 1.06754889 1.26636853 1.12103986\n", 200 | " 0.83294083 1.32533583 0.96137914 0.8823002 1.43281281 1.19611371\n", 201 | " -0.78940528 1.86544193 -0.74636813 -0.65262812 -0.50618527 -0.26376513\n", 202 | " -0.14691646 -0.20208667 -0.24647794 -0.34047837 -0.50463299 -0.66562681\n", 203 | " -0.76193944 -0.87453007 -1.02396861 -1.2315534 -1.51364781 -0.22477969\n", 204 | " 1.36864633 0.97874683 1.13715509 1.05688341 0.99487436 1.40832046\n", 205 | " 0.59156431 0.94867054 1.34348434 1.46512153 0.55580094 1.79155088\n", 206 | " 1.05012863 -0.67067287 -0.54930031 -0.2968015 -0.15491047 -0.21450816\n", 207 | " -0.261535 -0.36080841 -0.53730463 -0.70325988 -0.81421065 -0.94111069\n", 208 | " -1.08418556 -1.34365865 -1.53886075 1.09326051 0.72413821 1.27757173\n", 209 | " 1.36520155 1.17770547 1.0023395 1.39555822 0.29493432 1.10901936\n", 210 | " 1.36430898 1.27440447 1.52040376 1.40357315 1.72718391 0.1853037\n", 211 | " -0.57266526 -0.33349732 -0.18106813 -0.27035229 -0.32539614 -0.42952929\n", 212 | " -0.61751986 -0.7906786 -0.89035399 -0.99618473 -1.1655271 -1.43209714\n", 213 | " -0.09950582 1.43909587 0.80004613 0.88559108 1.40804576 1.33663711\n", 214 | " 1.00766279 1.4018325 0.27208395 1.09470572 1.42729615 1.26618628\n", 215 | " 1.41174747 1.45821099 1.71015214 1.01925997 0.4601322 -0.36757044\n", 216 | " -0.24958781 -0.3531048 -0.40241884 -0.49907564 -0.69135965 -0.85359971\n", 217 | " -0.9331706 -1.0059672 -1.2177602 -1.54149264 1.06742005 1.19680318\n", 218 | " 1.16583857 1.04905231 0.80970041 1.20411735 1.24623527 0.93697892\n", 219 | " 0.42037146 1.01432568 1.45360261 1.25038614 1.51241082 1.47613898\n", 220 | " 0.92463771 -0.70060342 -0.62144365 -0.39567218 -0.31147884 -0.40192164\n", 221 | " -0.45021433 -0.54773943 -0.75003079 -0.889456 -0.98063839 -1.07747814\n", 222 | " -1.29340698 -0.73928768 1.42310729 1.18867558 1.29652988 1.37945647\n", 223 | " 1.18486113 0.53438163 0.56912652 1.05669556 0.45154219 0.81022867\n", 224 | " 1.44123053 1.22117476 1.51323768 1.10025946 -0.84443622 -0.71082151\n", 225 | " -0.62981211 -0.41576178 -0.33145798 -0.4375847 -0.49080625 -0.59254976\n", 226 | " -0.79668158 -0.93801891 -1.02130727 -1.11492415 -1.35022588 0.83375288\n", 227 | " 0.9741596 0.4062541 0.82345526 0.99971607 1.41325802 1.38631373\n", 228 | " 0.82115561 1.03621816 1.37633608 1.41019057 1.43307373 1.33830106\n", 229 | " 1.56303358 1.2326212 -0.83324214 -0.68996128 -0.60036851 -0.41411856\n", 230 | " -0.30332172 -0.43661943 -0.50963747 -0.61804526 -0.82143658 -0.95207361\n", 231 | " -1.007129 -1.12351256 -0.74667893 1.42122933 1.13385827 1.18497379\n", 232 | " 0.92903272 0.59292314 0.58084998 0.65192725 1.31203334 1.15530336\n", 233 | " 0.60156289 1.43433833 1.57231525 1.361918 1.57407123 1.10104004\n", 234 | " -0.82047003 -0.6717897 -0.59381484 -0.40266963 -0.27443878 -0.40163268\n", 235 | " -0.47645656 -0.57112574 -0.75359002 -0.90482991 -1.00654795 -1.10010001\n", 236 | " 0.84646653 1.33590939 1.12318718 1.05983988 1.30375784 1.41841835\n", 237 | " 1.3363515 0.78329442 0.72603604 1.06772811 1.03728983 0.94268209\n", 238 | " 1.58352665 1.40736874 1.56396874 0.96402622 -0.79100683 -0.64317699\n", 239 | " -0.55055123 -0.35674061 -0.26298786 -0.36483148 -0.35501478 -0.56550535\n", 240 | " -0.76427867 -0.88093481 -0.95714593 0.26300404 1.49151056 0.60123139\n", 241 | " 1.23314614 1.143365 1.10292773 1.21793326 1.30989735 1.11852481\n", 242 | " 1.34363077 1.37704795 -0.41238875 0.42876074 1.77110004 1.48771853\n", 243 | " 1.67709496 0.81572133 -0.7339355 -0.57912664 -0.47893486 -0.30785098\n", 244 | " -0.2529033 -0.35287467 -0.42241314 -0.53742101 -0.69523159 -0.48322565\n", 245 | " 0.57649233 1.85134507 0.9703557 0.90721107 0.53503501 1.08207286\n", 246 | " 1.22790733 1.24437467 1.30849615 1.11971627 1.34908479 -0.64304466\n", 247 | " -1.38817988 0.69940517 1.86107934 1.56810302 1.7514223 0.72922458\n", 248 | " -0.67125106 -0.50747585 -0.42746762 -0.27689345 -0.21764707 -0.31533525\n", 249 | " 1.09716701 3.09682197 2.34175977 2.00796236 1.85994557 1.78597139\n", 250 | " 1.49141381 0.76297629 1.11039359 0.69358239 1.21783558 1.32207011\n", 251 | " 1.30769119 1.4354789 -0.5426532 -1.36111624 -1.24797109 0.81824301\n", 252 | " 1.96644103 1.71151651 1.86841471 0.54069192 -0.61478549 -0.41894205\n", 253 | " -0.37391927 -0.23491109 -0.18236822 0.34035482 4.02444776 3.30920932\n", 254 | " 2.29452031 1.8472915 1.73635327 1.85955328 1.58154728 1.45891677\n", 255 | " 0.75783736 1.06110739 1.11682494 1.46006007 1.55251473 0.62714951\n", 256 | " -1.26069746 -1.21787971 -1.12506426 0.83640561 2.11376884 1.84866534\n", 257 | " 1.99153545 0.45817771 -0.55353411 -0.33494561 -0.31442902 -0.19052615\n", 258 | " -0.14160236 2.93079659 5.14991601 3.31015404 2.4402553 1.95391685\n", 259 | " 1.96093639 2.10885636 1.66470037 1.5670484 1.42605195 1.03439231\n", 260 | " 0.57767735 1.22668387 1.64488703 -1.0901502 -1.14072666 -1.04099027\n", 261 | " -1.03382637 0.81150532 2.25649299 2.09431908 2.11219737 0.25860424\n", 262 | " -0.50542985 -0.27819146 -0.26277875 -0.15540351 -0.09737914 0.22730653\n", 263 | " 4.98953189 4.07372805 2.88331858 2.24493644 2.21334692 2.30127177\n", 264 | " 1.80874389 1.60351937 1.52082639 1.52471192 1.38291296 1.67601794\n", 265 | " -0.24487056 -0.97710244 -1.02967184 -0.98082293 -0.93945674 0.89027942\n", 266 | " 2.46430504 2.25517974 2.33765721 0.20729654 -0.45056135 -0.14513081\n", 267 | " -0.21182513 -0.11366213 -0.05702124 -0.09821816 -0.1785151 0.31968873\n", 268 | " 1.37577775 1.90665939 2.4520196 2.67288921 2.2232822 1.87944656\n", 269 | " 1.67634924 1.53152839 1.4299862 -0.162791 -0.81210479 -0.85896501\n", 270 | " -0.91661542 -0.87628179 -0.83240929 0.60715159 2.67395709 2.65972227\n", 271 | " 2.0834714 -0.26792583 -0.40009454 -0.14170013 -0.15920537 -0.08310377\n", 272 | " -0.02780774 -0.0459571 -0.09752313 -0.20921424 -0.33708195 -0.41731463\n", 273 | " -0.42712608 0.50525833 1.05313252 1.08014246 0.48423045 -0.21840563\n", 274 | " -0.76160286 -0.69278859 -0.64574229 -0.68429498 -0.73804133 -0.66329112\n", 275 | " -0.60337338 -0.47578426 1.14396189 0.57528488 0.0308716 -0.39704551\n", 276 | " -0.28848398 -0.1579693 -0.0929556 -0.03456268]\n", 277 | "Associated target 9\n" 278 | ] 279 | } 280 | ], 281 | "source": [ 282 | "#print(\"First line of one image\", images[11][0])\n", 283 | "print(\"First line of one image\", images[11])\n", 284 | "print(\"Associated target\", targets[11])" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "# Create the model\n", 292 | "![](images/simple_nn.png)" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": {}, 298 | "source": [ 299 | "# Create the model" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 6, 305 | "metadata": {}, 306 | "outputs": [ 307 | { 308 | "name": "stdout", 309 | "output_type": "stream", 310 | "text": [ 311 | "[[0.17820482 0.05316375 0.07201441 0.1023543 0.02913541 0.17055362\n", 312 | " 0.06326886 0.24632096 0.02520118 0.05978273]] [9]\n" 313 | ] 314 | } 315 | ], 316 | "source": [ 317 | "# Flatten\n", 318 | "model = tf.keras.models.Sequential()\n", 319 | "#model.add(tf.keras.layers.Flatten(input_shape=[28, 28]))\n", 320 | "\n", 321 | "# Add the layers\n", 322 | "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n", 323 | "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n", 324 | "model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n", 325 | "\n", 326 | "model_output = model.predict(images[0:1])\n", 327 | "print(model_output, targets[0:1])" 328 | ] 329 | }, 330 | { 331 | "cell_type": "markdown", 332 | "metadata": {}, 333 | "source": [ 334 | "## Model Summary" 335 | ] 336 | }, 337 | { 338 | "cell_type": "code", 339 | "execution_count": 7, 340 | "metadata": {}, 341 | "outputs": [ 342 | { 343 | "name": "stdout", 344 | "output_type": "stream", 345 | "text": [ 346 | "Model: \"sequential\"\n", 347 | "_________________________________________________________________\n", 348 | "Layer (type) Output Shape Param # \n", 349 | "=================================================================\n", 350 | "dense (Dense) multiple 200960 \n", 351 | "_________________________________________________________________\n", 352 | "dense_1 (Dense) multiple 32896 \n", 353 | "_________________________________________________________________\n", 354 | "dense_2 (Dense) multiple 1290 \n", 355 | "=================================================================\n", 356 | "Total params: 235,146\n", 357 | "Trainable params: 235,146\n", 358 | "Non-trainable params: 0\n", 359 | "_________________________________________________________________\n" 360 | ] 361 | } 362 | ], 363 | "source": [ 364 | "model.summary()" 365 | ] 366 | }, 367 | { 368 | "cell_type": "markdown", 369 | "metadata": {}, 370 | "source": [ 371 | "## Compile the model" 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": 9, 377 | "metadata": {}, 378 | "outputs": [], 379 | "source": [ 380 | "# Compile the model\n", 381 | "model.compile(\n", 382 | " loss=\"sparse_categorical_crossentropy\",\n", 383 | " optimizer=\"sgd\",\n", 384 | " metrics=[\"accuracy\"]\n", 385 | ")" 386 | ] 387 | }, 388 | { 389 | "cell_type": "markdown", 390 | "metadata": {}, 391 | "source": [ 392 | "## Caterogical cross entropy" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": 29, 398 | "metadata": {}, 399 | "outputs": [ 400 | { 401 | "name": "stdout", 402 | "output_type": "stream", 403 | "text": [ 404 | "(5, 784)\n", 405 | "[9 0 0 3 0]\n", 406 | "(5, 10)\n", 407 | "Output [[0.00155602 0.00106303 0.00698406 0.00284724 0.01145798 0.03515041\n", 408 | " 0.01286932 0.0088392 0.04853413 0.8706986 ]\n", 409 | " [0.7814132 0.00516847 0.01360413 0.0021324 0.01019276 0.00489966\n", 410 | " 0.15709291 0.00928725 0.01079097 0.00541825]\n", 411 | " [0.07476368 0.22221217 0.0560216 0.36471143 0.03012619 0.0860177\n", 412 | " 0.05936769 0.04129038 0.03758162 0.02790763]\n", 413 | " [0.24922626 0.1875557 0.11506705 0.19797364 0.03391237 0.02039414\n", 414 | " 0.09415954 0.03401936 0.0236186 0.04407331]\n", 415 | " [0.12672135 0.25767553 0.00981988 0.46853614 0.06494886 0.01375138\n", 416 | " 0.0213926 0.01535748 0.01641455 0.00538218]]\n", 417 | "\n", 418 | "Filtered output [0.8706986 0.7814132 0.07476368 0.19797364 0.12672135]\n", 419 | "\n", 420 | "Log Filtered output [-0.13845943 -0.2466512 -2.5934231 -1.6196214 -2.0657647 ]\n", 421 | "Mean -1.3327839\n", 422 | "Mean 1.3327839\n" 423 | ] 424 | } 425 | ], 426 | "source": [ 427 | "images_test = images[:5]\n", 428 | "labels_test = targets[:5]\n", 429 | "\n", 430 | "print(images_test.shape)\n", 431 | "print(labels_test)\n", 432 | "\n", 433 | "outputs_test = model.predict(images_test)\n", 434 | "\n", 435 | "print(outputs_test.shape)\n", 436 | "print(\"Output\", outputs_test)\n", 437 | "\n", 438 | "#print(\"\\nLabels\", labels_test)\n", 439 | "\n", 440 | "filtered_outputs_test = outputs_test[np.arange(5), labels_test]\n", 441 | "print(\"\\nFiltered output\", filtered_outputs_test)\n", 442 | "\n", 443 | "log_filtered_output = np.log(filtered_outputs_test)\n", 444 | "print(\"\\nLog Filtered output\", log_filtered_output)\n", 445 | "\n", 446 | "print(\"Mean\", log_filtered_output.mean())\n", 447 | "print(\"Mean\", -log_filtered_output.mean())" 448 | ] 449 | }, 450 | { 451 | "cell_type": "markdown", 452 | "metadata": {}, 453 | "source": [ 454 | "## Train the model" 455 | ] 456 | }, 457 | { 458 | "cell_type": "code", 459 | "execution_count": 28, 460 | "metadata": {}, 461 | "outputs": [ 462 | { 463 | "name": "stdout", 464 | "output_type": "stream", 465 | "text": [ 466 | "10000/10000==============================] - 1s 60us/sample - loss: 1.0488 - acc: 0.6868\n" 467 | ] 468 | } 469 | ], 470 | "source": [ 471 | "history = model.fit(images, targets, epochs=1)" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": 42, 477 | "metadata": {}, 478 | "outputs": [ 479 | { 480 | "data": { 481 | "image/png": "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\n", 482 | "text/plain": [ 483 | "
" 484 | ] 485 | }, 486 | "metadata": { 487 | "needs_background": "light" 488 | }, 489 | "output_type": "display_data" 490 | }, 491 | { 492 | "data": { 493 | "image/png": "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\n", 494 | "text/plain": [ 495 | "
" 496 | ] 497 | }, 498 | "metadata": { 499 | "needs_background": "light" 500 | }, 501 | "output_type": "display_data" 502 | } 503 | ], 504 | "source": [ 505 | "loss_curve = history.history[\"loss\"]\n", 506 | "acc_curve = history.history[\"accuracy\"]\n", 507 | "\n", 508 | "plt.plot(loss_curve)\n", 509 | "plt.title(\"Loss\")\n", 510 | "plt.show()\n", 511 | "\n", 512 | "plt.plot(acc_curve)\n", 513 | "plt.title(\"Accuracy\")\n", 514 | "plt.show()" 515 | ] 516 | } 517 | ], 518 | "metadata": { 519 | "kernelspec": { 520 | "display_name": "Python 3", 521 | "language": "python", 522 | "name": "python3" 523 | }, 524 | "language_info": { 525 | "codemirror_mode": { 526 | "name": "ipython", 527 | "version": 3 528 | }, 529 | "file_extension": ".py", 530 | "mimetype": "text/x-python", 531 | "name": "python", 532 | "nbconvert_exporter": "python", 533 | "pygments_lexer": "ipython3", 534 | "version": "3.6.7" 535 | } 536 | }, 537 | "nbformat": 4, 538 | "nbformat_minor": 2 539 | } 540 | -------------------------------------------------------------------------------- /others/Simple neural network-Normalized.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Import" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 4, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "# Matplotlib\n", 17 | "import matplotlib.pyplot as plt\n", 18 | "# Tensorflow\n", 19 | "import tensorflow as tf\n", 20 | "# Numpy and Pandas\n", 21 | "import numpy as np\n", 22 | "import pandas as pd\n", 23 | "# Ohter import\n", 24 | "import sys\n", 25 | "\n", 26 | "\n", 27 | "from sklearn.preprocessing import StandardScaler" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "## Be sure to used Tensorflow 2.0" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 5, 40 | "metadata": {}, 41 | "outputs": [], 42 | "source": [ 43 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "## Load the dataset: Fashion MNIST" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "![](https://storage.googleapis.com/kaggle-datasets-images/2243/3791/9384af51de8baa77f6320901f53bd26b/dataset-cover.png)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 7, 63 | "metadata": {}, 64 | "outputs": [ 65 | { 66 | "name": "stdout", 67 | "output_type": "stream", 68 | "text": [ 69 | "-1.0476880134421886e-18\n", 70 | "1.0000000000000007\n" 71 | ] 72 | } 73 | ], 74 | "source": [ 75 | "# Fashio MNIST\n", 76 | "fashion_mnist = tf.keras.datasets.fashion_mnist\n", 77 | "(images, targets), (_, _) = fashion_mnist.load_data()\n", 78 | "# Get only a subpart of the dataset\n", 79 | "# Get only a subpart\n", 80 | "images = images[:10000]\n", 81 | "targets = targets [:10000]\n", 82 | "\n", 83 | "# flatten\n", 84 | "images = images.reshape(-1, 784)\n", 85 | "images = images.astype(float)\n", 86 | "\n", 87 | "scaler = StandardScaler()\n", 88 | "\n", 89 | "images = scaler.fit_transform(images)\n", 90 | "\n", 91 | "print(images.mean())\n", 92 | "print(images.std())" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## Plot one of the data" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 8, 105 | "metadata": {}, 106 | "outputs": [ 107 | { 108 | "data": { 109 | "image/png": "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\n", 110 | "text/plain": [ 111 | "
" 112 | ] 113 | }, 114 | "metadata": { 115 | "needs_background": "light" 116 | }, 117 | "output_type": "display_data" 118 | } 119 | ], 120 | "source": [ 121 | "targets_names = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\", \"Sandal\", \n", 122 | " \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"\n", 123 | "]\n", 124 | "# Plot one image\n", 125 | "plt.imshow(images[10].reshape(28, 28), cmap=\"binary\")\n", 126 | "#plt.title(targets_names[targets[10]])\n", 127 | "plt.title(targets_names[targets[10]])\n", 128 | "plt.show()" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 9, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "First line of one image [-0.01426971 -0.02645579 -0.029489 -0.04635542 -0.06156617 -0.07641125\n", 141 | " -0.10509579 -0.16410192 -0.23986957 -0.36929666 -0.57063232 -0.6909092\n", 142 | " -0.7582382 -0.74450346 -0.17093142 0.80572169 0.60465021 0.69474334\n", 143 | " 0.01007169 -0.32085836 -0.20882718 -0.14379861 -0.11434416 -0.09302065\n", 144 | " 0.08584529 -0.04969764 -0.03368099 -0.01591863 -0.0181322 -0.02297209\n", 145 | " -0.03365679 -0.05814043 -0.08287213 -0.13053264 -0.2464668 -0.35905423\n", 146 | " -0.48335079 -0.63909239 -0.83575443 -0.98917162 -1.08347998 -1.07712864\n", 147 | " 0.7931674 1.2496451 1.35025207 1.68512162 1.97595936 1.43181167\n", 148 | " 2.97956664 4.68907298 4.88750284 0.23595608 -0.11565956 0.14562865\n", 149 | " -0.06100298 -0.03312088 -0.01964757 -0.02793878 -0.0481181 -0.07617253\n", 150 | " -0.12670992 -0.26684818 -0.39945708 -0.49720396 -0.62326614 -0.8195795\n", 151 | " -0.99379417 -1.04759214 -1.10371252 -1.10221791 1.08283564 1.22639277\n", 152 | " 1.35310524 1.34234162 1.66433217 2.15862735 2.75297169 3.22113197\n", 153 | " 4.62472272 3.87445967 -0.16599094 0.32418594 -0.087733 -0.0526323\n", 154 | " -0.02862848 -0.04242726 -0.06957184 -0.10501986 -0.21177968 -0.36570732\n", 155 | " -0.50377706 -0.63129117 -0.7545061 -0.92782181 -1.04671762 -1.04884575\n", 156 | " -1.10753111 -1.03315535 1.43294532 1.33033833 1.39162212 1.50249446\n", 157 | " 1.41472555 1.48664927 2.19750146 2.5207204 3.23681206 0.32439317\n", 158 | " -0.22921786 0.08719395 -0.11524194 -0.06595022 -0.03978101 -0.06151816\n", 159 | " -0.09394236 -0.14485093 -0.28258668 -0.45013464 -0.60762152 -0.70866125\n", 160 | " -0.80845132 -0.97106764 -1.06309306 -1.04395211 -1.11950469 -0.35989804\n", 161 | " 1.56262616 1.30932327 1.41614857 1.49002634 1.44030778 1.4974615\n", 162 | " 2.02811047 2.22341936 2.1189369 0.28273308 0.22687411 -0.22359138\n", 163 | " -0.07278968 -0.09631577 -0.05785819 -0.08665899 -0.12303533 -0.19276323\n", 164 | " -0.34094366 -0.53007774 -0.6636926 -0.76166986 -0.85810993 -1.01973474\n", 165 | " -1.10359032 -1.13389127 -1.13797187 0.19728184 1.30491585 1.12589712\n", 166 | " 1.56101992 1.5471799 1.35519155 1.61848413 1.8686844 1.86320923\n", 167 | " 0.84284685 1.09578392 0.74105846 -0.28563328 -0.1131897 -0.11759717\n", 168 | " -0.07138681 -0.10484842 -0.15218768 -0.23983624 -0.39446008 -0.58540856\n", 169 | " -0.70817066 -0.80613957 -0.8912735 -1.04743568 -1.11648233 -1.16203361\n", 170 | " -1.16480491 0.86892733 1.27412159 0.8998086 0.74428789 1.13274167\n", 171 | " 1.14002008 1.64475384 1.22579108 1.87626568 0.72713619 -0.21425058\n", 172 | " -0.44976207 -0.3588039 -0.26052139 -0.14642704 -0.09057754 -0.12852483\n", 173 | " -0.17658578 -0.27962415 -0.43604854 -0.62328729 -0.74417079 -0.83698675\n", 174 | " -0.91538507 -1.05836072 -1.09984451 -1.18744141 -1.19142578 1.24141786\n", 175 | " 1.39079751 1.49192297 1.27955426 1.30948745 1.17061076 0.86607308\n", 176 | " 1.27421913 0.79750725 -0.86719519 -0.69061632 -0.50423389 -0.42229875\n", 177 | " -0.30440602 -0.16353165 -0.09817535 -0.14372941 -0.20517067 -0.30866173\n", 178 | " -0.4655249 -0.65221334 -0.76683863 -0.85659993 -0.93256978 -1.06226401\n", 179 | " -1.15171237 -1.21294298 -0.55403601 1.46120819 0.97836915 1.05122066\n", 180 | " 1.2521523 1.05790293 1.35951983 0.90500191 1.55701257 0.82622186\n", 181 | " -0.93881345 -0.7662494 -0.57465574 -0.48552019 -0.34738009 -0.18855983\n", 182 | " -0.10483514 -0.16127624 -0.22554475 -0.32839989 -0.48754623 -0.66943952\n", 183 | " -0.77552861 -0.86498292 -0.94273549 -1.06015652 -1.18041842 -1.23791689\n", 184 | " 0.42552833 1.46179792 0.99490898 0.75506225 0.87837333 0.82699162\n", 185 | " 1.09938829 0.76830616 1.48553714 -0.13338616 0.50592885 -0.83182562\n", 186 | " -0.65812 -0.54406795 -0.39662058 -0.21430757 -0.11419072 -0.17789518\n", 187 | " -0.23568605 -0.33542269 -0.5026126 -0.67620553 -0.77596799 -0.86788207\n", 188 | " -0.94980187 -1.03197874 -1.22037631 -1.30832137 1.13203817 1.20044543\n", 189 | " 1.26727922 1.22318096 1.33469514 1.2591838 1.27789102 0.95415321\n", 190 | " 1.45083593 -1.14975179 -0.0817779 1.07590662 -0.71352465 -0.61851141\n", 191 | " -0.45102226 -0.23988228 -0.1324622 -0.1914184 -0.23850724 -0.33502594\n", 192 | " -0.50210849 -0.67112987 -0.76673944 -0.8616405 -0.96676107 -1.0848351\n", 193 | " -1.3330483 -0.93497502 1.45610367 1.06754889 1.26636853 1.12103986\n", 194 | " 0.83294083 1.32533583 0.96137914 0.8823002 1.43281281 1.19611371\n", 195 | " -0.78940528 1.86544193 -0.74636813 -0.65262812 -0.50618527 -0.26376513\n", 196 | " -0.14691646 -0.20208667 -0.24647794 -0.34047837 -0.50463299 -0.66562681\n", 197 | " -0.76193944 -0.87453007 -1.02396861 -1.2315534 -1.51364781 -0.22477969\n", 198 | " 1.36864633 0.97874683 1.13715509 1.05688341 0.99487436 1.40832046\n", 199 | " 0.59156431 0.94867054 1.34348434 1.46512153 0.55580094 1.79155088\n", 200 | " 1.05012863 -0.67067287 -0.54930031 -0.2968015 -0.15491047 -0.21450816\n", 201 | " -0.261535 -0.36080841 -0.53730463 -0.70325988 -0.81421065 -0.94111069\n", 202 | " -1.08418556 -1.34365865 -1.53886075 1.09326051 0.72413821 1.27757173\n", 203 | " 1.36520155 1.17770547 1.0023395 1.39555822 0.29493432 1.10901936\n", 204 | " 1.36430898 1.27440447 1.52040376 1.40357315 1.72718391 0.1853037\n", 205 | " -0.57266526 -0.33349732 -0.18106813 -0.27035229 -0.32539614 -0.42952929\n", 206 | " -0.61751986 -0.7906786 -0.89035399 -0.99618473 -1.1655271 -1.43209714\n", 207 | " -0.09950582 1.43909587 0.80004613 0.88559108 1.40804576 1.33663711\n", 208 | " 1.00766279 1.4018325 0.27208395 1.09470572 1.42729615 1.26618628\n", 209 | " 1.41174747 1.45821099 1.71015214 1.01925997 0.4601322 -0.36757044\n", 210 | " -0.24958781 -0.3531048 -0.40241884 -0.49907564 -0.69135965 -0.85359971\n", 211 | " -0.9331706 -1.0059672 -1.2177602 -1.54149264 1.06742005 1.19680318\n", 212 | " 1.16583857 1.04905231 0.80970041 1.20411735 1.24623527 0.93697892\n", 213 | " 0.42037146 1.01432568 1.45360261 1.25038614 1.51241082 1.47613898\n", 214 | " 0.92463771 -0.70060342 -0.62144365 -0.39567218 -0.31147884 -0.40192164\n", 215 | " -0.45021433 -0.54773943 -0.75003079 -0.889456 -0.98063839 -1.07747814\n", 216 | " -1.29340698 -0.73928768 1.42310729 1.18867558 1.29652988 1.37945647\n", 217 | " 1.18486113 0.53438163 0.56912652 1.05669556 0.45154219 0.81022867\n", 218 | " 1.44123053 1.22117476 1.51323768 1.10025946 -0.84443622 -0.71082151\n", 219 | " -0.62981211 -0.41576178 -0.33145798 -0.4375847 -0.49080625 -0.59254976\n", 220 | " -0.79668158 -0.93801891 -1.02130727 -1.11492415 -1.35022588 0.83375288\n", 221 | " 0.9741596 0.4062541 0.82345526 0.99971607 1.41325802 1.38631373\n", 222 | " 0.82115561 1.03621816 1.37633608 1.41019057 1.43307373 1.33830106\n", 223 | " 1.56303358 1.2326212 -0.83324214 -0.68996128 -0.60036851 -0.41411856\n", 224 | " -0.30332172 -0.43661943 -0.50963747 -0.61804526 -0.82143658 -0.95207361\n", 225 | " -1.007129 -1.12351256 -0.74667893 1.42122933 1.13385827 1.18497379\n", 226 | " 0.92903272 0.59292314 0.58084998 0.65192725 1.31203334 1.15530336\n", 227 | " 0.60156289 1.43433833 1.57231525 1.361918 1.57407123 1.10104004\n", 228 | " -0.82047003 -0.6717897 -0.59381484 -0.40266963 -0.27443878 -0.40163268\n", 229 | " -0.47645656 -0.57112574 -0.75359002 -0.90482991 -1.00654795 -1.10010001\n", 230 | " 0.84646653 1.33590939 1.12318718 1.05983988 1.30375784 1.41841835\n", 231 | " 1.3363515 0.78329442 0.72603604 1.06772811 1.03728983 0.94268209\n", 232 | " 1.58352665 1.40736874 1.56396874 0.96402622 -0.79100683 -0.64317699\n", 233 | " -0.55055123 -0.35674061 -0.26298786 -0.36483148 -0.35501478 -0.56550535\n", 234 | " -0.76427867 -0.88093481 -0.95714593 0.26300404 1.49151056 0.60123139\n", 235 | " 1.23314614 1.143365 1.10292773 1.21793326 1.30989735 1.11852481\n", 236 | " 1.34363077 1.37704795 -0.41238875 0.42876074 1.77110004 1.48771853\n", 237 | " 1.67709496 0.81572133 -0.7339355 -0.57912664 -0.47893486 -0.30785098\n", 238 | " -0.2529033 -0.35287467 -0.42241314 -0.53742101 -0.69523159 -0.48322565\n", 239 | " 0.57649233 1.85134507 0.9703557 0.90721107 0.53503501 1.08207286\n", 240 | " 1.22790733 1.24437467 1.30849615 1.11971627 1.34908479 -0.64304466\n", 241 | " -1.38817988 0.69940517 1.86107934 1.56810302 1.7514223 0.72922458\n", 242 | " -0.67125106 -0.50747585 -0.42746762 -0.27689345 -0.21764707 -0.31533525\n", 243 | " 1.09716701 3.09682197 2.34175977 2.00796236 1.85994557 1.78597139\n", 244 | " 1.49141381 0.76297629 1.11039359 0.69358239 1.21783558 1.32207011\n", 245 | " 1.30769119 1.4354789 -0.5426532 -1.36111624 -1.24797109 0.81824301\n", 246 | " 1.96644103 1.71151651 1.86841471 0.54069192 -0.61478549 -0.41894205\n", 247 | " -0.37391927 -0.23491109 -0.18236822 0.34035482 4.02444776 3.30920932\n", 248 | " 2.29452031 1.8472915 1.73635327 1.85955328 1.58154728 1.45891677\n", 249 | " 0.75783736 1.06110739 1.11682494 1.46006007 1.55251473 0.62714951\n", 250 | " -1.26069746 -1.21787971 -1.12506426 0.83640561 2.11376884 1.84866534\n", 251 | " 1.99153545 0.45817771 -0.55353411 -0.33494561 -0.31442902 -0.19052615\n", 252 | " -0.14160236 2.93079659 5.14991601 3.31015404 2.4402553 1.95391685\n", 253 | " 1.96093639 2.10885636 1.66470037 1.5670484 1.42605195 1.03439231\n", 254 | " 0.57767735 1.22668387 1.64488703 -1.0901502 -1.14072666 -1.04099027\n", 255 | " -1.03382637 0.81150532 2.25649299 2.09431908 2.11219737 0.25860424\n", 256 | " -0.50542985 -0.27819146 -0.26277875 -0.15540351 -0.09737914 0.22730653\n", 257 | " 4.98953189 4.07372805 2.88331858 2.24493644 2.21334692 2.30127177\n", 258 | " 1.80874389 1.60351937 1.52082639 1.52471192 1.38291296 1.67601794\n", 259 | " -0.24487056 -0.97710244 -1.02967184 -0.98082293 -0.93945674 0.89027942\n", 260 | " 2.46430504 2.25517974 2.33765721 0.20729654 -0.45056135 -0.14513081\n", 261 | " -0.21182513 -0.11366213 -0.05702124 -0.09821816 -0.1785151 0.31968873\n", 262 | " 1.37577775 1.90665939 2.4520196 2.67288921 2.2232822 1.87944656\n", 263 | " 1.67634924 1.53152839 1.4299862 -0.162791 -0.81210479 -0.85896501\n", 264 | " -0.91661542 -0.87628179 -0.83240929 0.60715159 2.67395709 2.65972227\n", 265 | " 2.0834714 -0.26792583 -0.40009454 -0.14170013 -0.15920537 -0.08310377\n", 266 | " -0.02780774 -0.0459571 -0.09752313 -0.20921424 -0.33708195 -0.41731463\n", 267 | " -0.42712608 0.50525833 1.05313252 1.08014246 0.48423045 -0.21840563\n", 268 | " -0.76160286 -0.69278859 -0.64574229 -0.68429498 -0.73804133 -0.66329112\n", 269 | " -0.60337338 -0.47578426 1.14396189 0.57528488 0.0308716 -0.39704551\n", 270 | " -0.28848398 -0.1579693 -0.0929556 -0.03456268]\n", 271 | "Associated target 9\n" 272 | ] 273 | } 274 | ], 275 | "source": [ 276 | "#print(\"First line of one image\", images[11][0])\n", 277 | "print(\"First line of one image\", images[11])\n", 278 | "print(\"Associated target\", targets[11])" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "# Create the model\n", 286 | "![](images/simple_nn.png)" 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "# Add the layers" 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": 10, 299 | "metadata": {}, 300 | "outputs": [ 301 | { 302 | "name": "stdout", 303 | "output_type": "stream", 304 | "text": [ 305 | "[[0.05521132 0.49481636 0.03139508 0.05542628 0.0551687 0.08608311\n", 306 | " 0.01741511 0.1200914 0.07588126 0.00851135]] [9]\n" 307 | ] 308 | } 309 | ], 310 | "source": [ 311 | "# Flatten\n", 312 | "model = tf.keras.models.Sequential()\n", 313 | "#model.add(tf.keras.layers.Flatten(input_shape=[28, 28]))\n", 314 | "\n", 315 | "# Add the layers\n", 316 | "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n", 317 | "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n", 318 | "model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n", 319 | "\n", 320 | "model_output = model.predict(images[0:1])\n", 321 | "print(model_output, targets[0:1])" 322 | ] 323 | }, 324 | { 325 | "cell_type": "markdown", 326 | "metadata": {}, 327 | "source": [ 328 | "## Model Summary" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 11, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "name": "stdout", 338 | "output_type": "stream", 339 | "text": [ 340 | "Model: \"sequential\"\n", 341 | "_________________________________________________________________\n", 342 | "Layer (type) Output Shape Param # \n", 343 | "=================================================================\n", 344 | "dense (Dense) multiple 200960 \n", 345 | "_________________________________________________________________\n", 346 | "dense_1 (Dense) multiple 32896 \n", 347 | "_________________________________________________________________\n", 348 | "dense_2 (Dense) multiple 1290 \n", 349 | "=================================================================\n", 350 | "Total params: 235,146\n", 351 | "Trainable params: 235,146\n", 352 | "Non-trainable params: 0\n", 353 | "_________________________________________________________________\n" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "model.summary()" 359 | ] 360 | }, 361 | { 362 | "cell_type": "markdown", 363 | "metadata": {}, 364 | "source": [ 365 | "## Compile the model" 366 | ] 367 | }, 368 | { 369 | "cell_type": "code", 370 | "execution_count": 12, 371 | "metadata": {}, 372 | "outputs": [], 373 | "source": [ 374 | "# Compile the model\n", 375 | "model.compile(\n", 376 | " loss=\"sparse_categorical_crossentropy\",\n", 377 | " optimizer=\"sgd\",\n", 378 | " metrics=[\"accuracy\"]\n", 379 | ")" 380 | ] 381 | }, 382 | { 383 | "cell_type": "markdown", 384 | "metadata": {}, 385 | "source": [ 386 | "## Train the model" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": 13, 392 | "metadata": {}, 393 | "outputs": [ 394 | { 395 | "name": "stdout", 396 | "output_type": "stream", 397 | "text": [ 398 | "Epoch 1/10\n", 399 | "10000/10000 [==============================] - 1s 58us/sample - loss: 1.6210 - accuracy: 0.4803\n", 400 | "Epoch 2/10\n", 401 | "10000/10000 [==============================] - 1s 58us/sample - loss: 1.0098 - accuracy: 0.6912\n", 402 | "Epoch 3/10\n", 403 | "10000/10000 [==============================] - 1s 54us/sample - loss: 0.8317 - accuracy: 0.7369\n", 404 | "Epoch 4/10\n", 405 | "10000/10000 [==============================] - 1s 53us/sample - loss: 0.7409 - accuracy: 0.7574\n", 406 | "Epoch 5/10\n", 407 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.6832 - accuracy: 0.7711\n", 408 | "Epoch 6/10\n", 409 | "10000/10000 [==============================] - 1s 54us/sample - loss: 0.6415 - accuracy: 0.7820\n", 410 | "Epoch 7/10\n", 411 | "10000/10000 [==============================] - 1s 53us/sample - loss: 0.6088 - accuracy: 0.7924\n", 412 | "Epoch 8/10\n", 413 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.5828 - accuracy: 0.7994\n", 414 | "Epoch 9/10\n", 415 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.5606 - accuracy: 0.8053\n", 416 | "Epoch 10/10\n", 417 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.5412 - accuracy: 0.8101\n" 418 | ] 419 | } 420 | ], 421 | "source": [ 422 | "history = model.fit(images, targets, epochs=10)" 423 | ] 424 | }, 425 | { 426 | "cell_type": "code", 427 | "execution_count": 14, 428 | "metadata": {}, 429 | "outputs": [ 430 | { 431 | "data": { 432 | "image/png": "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\n", 433 | "text/plain": [ 434 | "
" 435 | ] 436 | }, 437 | "metadata": { 438 | "needs_background": "light" 439 | }, 440 | "output_type": "display_data" 441 | }, 442 | { 443 | "data": { 444 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEICAYAAACzliQjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xt0VOd57/HvIwlJSEJCQlwlgQTINuAbtgy+QJMcxwltT3xp2gT7OLHTxG7PiXM/zbK7cpIup2ed9OJcTuuTljquE9cudV0nJa1b4qzErYUvIDC+IIw1gA0SN42uCKH7c/6YDR4UsAYzYs/l91lrlma/+90zjybmpzfv3vNuc3dERCQ75IRdgIiInD8KfRGRLKLQFxHJIgp9EZEsotAXEckiCn0RkSyi0BcRySIKfckYZvasmXWZWUHYtYikKoW+ZAQzqwVWAw7ceB7fN+98vZdIMij0JVN8EngReAS440SjmU01swfM7G0z6zGzRjObGuxbZWbPm1m3me03szuD9mfN7DNxr3GnmTXGbbuZfdbMWoCWoO17wWv0mtlWM1sd1z/XzP7QzHab2dFgf42ZPWhmD8T/Ema2wcy+NBkfkAgo9CVzfBJ4LHh82MxmB+1/DlwJXAtUAF8FxsxsAfBvwF8AM4HLge1n8X43AyuBpcH2luA1KoDHgX80s8Jg35eBW4HfAEqB3wX6gR8Ct5pZDoCZVQIfDI4XmRQKfUl7ZrYKWAA84e5bgd3AbUGY/i7wBXdvc/dRd3/e3QeB24Cfu/vfu/uwu3e4+9mE/v9x9053Pw7g7n8XvMaIuz8AFAAXBn0/A3zN3Xd5zCtB381AD3B90G8t8Ky7Hz7Hj0TkjBT6kgnuAH7m7tFg+/GgrRIoJPZHYLyaM7Qnan/8hpn9TzPbGUwhdQNlwftP9F4/BG4Pnt8OPHoONYlMSCehJK0F8/MfA3LN7FDQXABMB+YCA8Ai4JVxh+4HVpzhZY8BRXHbc07T5+TytMH8/VeJjdh3uPuYmXUBFvdei4DXT/M6fwe8bmaXAUuAn5yhJpGk0Ehf0t3NwCixufXLg8cS4Dli8/wPA982s3nBCdVrgks6HwM+aGYfM7M8M5thZpcHr7kd+C0zKzKzxcCnJ6hhGjACtAN5ZvZ1YnP3JzwEfNPM6i3mUjObAeDurcTOBzwK/NOJ6SKRyaLQl3R3B/C37r7P3Q+deAB/Cfw34F7gNWLB2gn8CZDj7vuInVj9StC+HbgseM3vAEPAYWLTL49NUMNG4N+BN4G3if2/i/jpn28DTwA/A3qBHwBT4/b/ELgETe3IeWC6iYpIuMzs14hN8yxw/YOUSaaRvkiIzGwK8AXgIQW+nA8KfZGQmNkSoJvYCefvhlyOZAlN74iIZBGN9EVEskjKXadfWVnptbW1YZchIpJWtm7dGnX3mRP1S7nQr62tpampKewyRETSipm9nUg/Te+IiGQRhb6ISBZR6IuIZBGFvohIFlHoi4hkEYW+iEgWUeiLiGSRlLtOX0Qk0x0fGiXaN0jHsSE6Tv4comzqFG5bOX9S31uhLyJyjoZGxug8NkTHsUE6+t75Ge0bovPE8xMB3zfE8eHR077OFfOnK/RFRM630TGnu3+IjmNDsRF531As1PsGTwnvzmB/78DIaV9nSq4xo7iAGSX5zCgpYFFlMRXFseczSvKpLMlnRnFB0JZPUf7kR7JCX0SyxvGhUQ71DnA4eBzqGeBQ7wDtR08doXf1DzF2mgWIc4xYQAdBvXReKZUlBcwozqciCPDKkndCfVpBHmb2qy8UooRC38zWAN8Dcond7OFb4/bPJ3bLt+lBn3vd/elg333E7jE6Cnze3Tcmr3wRkdjIvKNvkENBkB8+OsjhINDjA/50I/Li/FxmlRZSWZLPwsoSGmrzqYwbjZ8cqRfnM70on9yc1ArxszVh6JtZLvAgcAPQCmwxsw3u3hzX7WvAE+7+fTNbCjwN1AbP1wLLgHnAz83sAnc//YSWiMg4RweGOdw7eMrI/Ehv7Oeh3li4t/cNMjpuaJ6bY8wsKWB2WSF1lcVcs3AGs0oLmVNayJyyQmaXFjK7tIBphVNC+s3CkchIfwUQcfc9AGa2HrgJiA99B0qD52XAgeD5TcB6dx8E9ppZJHi9F5JQu4iksdExjwX5iRDvCUL8xMi8d4DDPQMcG/rVMWJpYR6zg/Cun1XJnCDAT7TNKS1kRklB2o/KJ0MioV8F7I/bbgVWjuvzR8DPzOxzQDHwwbhjXxx3bNX4NzCzu4G7AebPn9wz1yJyfoyMjnGwZ4C27uO0dh2ntauf1q7jtHUdp7W7n4PdA4yMG51PyTVmTYsF+EVzpvG+C2YGgV54MtBnlxaclxOemSpZn9ytwCPu/oCZXQM8amYXJ3qwu68D1gE0NDTo/o0iaWB4dIyD3QO0dvcHoR4L9rbg+aHegV+ZcpldWkB1eRFXzC+n6tKpVJVPPRnqc8oKqSjKJ0ej80mVSOi3ATVx29VBW7xPA2sA3P0FMysEKhM8VkRS0NDIGAd7TjNKD7YP9Q6ccoWLGcwpLaS6fCor6iqomj6V6vKpVJcXUV0+lbnTCynIyw3vFxIgsdDfAtSbWR2xwF4L3Dauzz7geuARM1sCFALtwAbgcTP7NrETufXA5iTVLiLnYHBklAPdAycDPX6U3tp1nMNHB/C4UM8xmFsWG51fvXDGKYFeXV7EnLJC8vO0skuqmzD03X3EzO4BNhK7HPNhd99hZvcDTe6+AfgK8Ddm9iViJ3XvdHcHdpjZE8RO+o4An9WVOyLn18joGHujx2g+2MvOg0fZebCXXYeOcqh34JR+uTnG3LLYSP26xZVBmL8T7HPKCpmSq1BPd+aeWlPoDQ0Nrnvkirw3PceHeeNgLztPBPyhWMAPjowBsROli2dNY8mcaSyYUXwy2E/Mrecp1NOWmW1194aJ+ukUuEgaGhtz9nf1s/NgL83B6L35QC9t3cdP9qkozmfJ3Gl84uoFLJlbytJ5pSyaWaIpmCyn0BdJcceHRnnj0DtTMzsP9vLGoaP0Dca+XZpjUFdZzPJgsa6lQcDPmlaQcksASPgU+iIpwt051Dtwcmqm+WAvOw/0srfj2MkTqiUFeSyZO43fuqKKJXNLWTK3lAtnT2Nqvq6KkcQo9EVCMDQyRsuRo6eM3psP9tLdP3yyT03FVJbMKeUjl82LTc/MLaW6fKquY5dzotAXmWS9A8M0H+hlx4FedrT10Hywl8iRvpPfRi3Iy+GiOdNYs2zOydH7RXOnUZpla8LI+aHQF0miaN8gr7f1xAL+QOzn2x39J/fPnFbAsnmlfOCiWcHofRq1M4p11YycNwp9kffA3WnrPn5y9L7jQC+vH+jhcO/gyT41FVO5eF4Zv3NlNcuqylg2r5RZ0wpDrFpEoS8yobExZ2/HMV5v66E5CPcdB96Zf88xWDSzhGsXVbJsXinL5pWxdF4pZVM1PSOpR6EvEufECdYdbe9MzzQf7KU/WN43PzeHC4P59xOj9yVzSnX1jKQNhb5krf6hkdilkQd6eL2tlx0He3jzUB9Do7Fvrxbn57J0Xikfa6g5OYKvn12ipQgkrSn0JSv0DgzHTrAGI/jXD/Syp73v5CqR5UVTuLiqjE+tquXiebERfO2MYl0eKRlHoS8ZqaNvkC1vdfLS3k427+2k+WDvyS84zS0rZNm8Un7zkrksm1fKxVVlzC0r1LdXJSso9CUjHOoZ4KW9HWwOQr7lSB8AhVNyuGJ+OV+4vp7l88u5eF4pM0oKQq5WJDwKfUk77s7+zuO8GBfy+zpj18KXFOTRUFvOLVdUsbJuBpdUlWmBMZE4Cn1Jee5O5EjfyamazXs7T64FX140hRV1FdxxbS0r6ypYMrdUN8MWeRcKfUk5o2POzoO9bN7byUt7O9jyVhedx4YAmDWtgJULZ7CiroKVdRUsnlmik60iZ0GhL6EbGhnjtbaeYBTfQdNbXRwNlg2uqZjKBy6cxcq6ClYurGB+RZFOuIqcA4W+nHcDw6O8vK87FvJvdbDt7W6OD8e+/LRoZjEfuXweK+squKq2gnnTp4ZcrUhmUejLpOsbHGHr211s3tvBS3s6eaW1m+FRxwyWzCnl41fVxEK+roJKXVkjMqkU+jIpjg4M82+vHeLHL7fx0t4Oxjx24+1Lqsr43evqWFFXQUNthdanETnPFPqSNMOjYzzX0s5T29p4pvkwgyNj1M4o4r+/fxHXLKxk+fzpFBfoPzmRMCX0L9DM1gDfA3KBh9z9W+P2fwf4QLBZBMxy9+nBvlHgtWDfPne/MRmFS2pwd15r6+GpbW389JUDdBwbYnrRFD7WUMMtV1SxvGa6TryKpJAJQ9/McoEHgRuAVmCLmW1w9+YTfdz9S3H9Pwcsj3uJ4+5+efJKllTQ2tXPP28/wFPbWtndfoz83ByuXzKLW5ZX8f4LZ+kLUSIpKpGR/gog4u57AMxsPXAT0HyG/rcC30hOeZJKegeG+bfXDvLUtjZe2tsJwFW15Xx61UJ+85K5lBVpfl4k1SUS+lXA/rjtVmDl6Tqa2QKgDvhFXHOhmTUBI8C33P0npznubuBugPnz5ydWuZwXw6Nj/Oeb7Tz1chs/D+bp6yqL+fINF3DL8ipqKorCLlFEzkKyz6qtBZ5099G4tgXu3mZmC4FfmNlr7r47/iB3XwesA2hoaPAk1yRnyd15tbWHH7/8zjx9edEUPn5VDbcsr+JyzdOLpK1EQr8NqInbrg7aTmct8Nn4BndvC37uMbNnic337/7VQyVsrV39/OTlNn78ctvJefoPLp3FLcured8FMzVPL5IBEgn9LUC9mdURC/u1wG3jO5nZRUA58EJcWznQ7+6DZlYJXAf8aTIKl+Q4MU//T9va2BzM06+oreAzqxfyG5fM1XX0IhlmwtB39xEzuwfYSOySzYfdfYeZ3Q80ufuGoOtaYL27x0/PLAH+2szGgBxic/pnOgEs58nw6Bj/saudH29/Z55+YWUxX7nhAm7WPL1IRrNTMzp8DQ0N3tTUFHYZGed08/QVxfl85NK53HJFNZdVl2meXiSNmdlWd2+YqJ++Hpnh9nf288/b23jq5Tb2tB8jPy+HG5bM5pblVbzvwpm6ybdIllHoZ6itb3fxJ//+xjvz9HUV3L16Ib+ueXqRrKbQz0DrN+/jf/3z68wsKdA8vYicQqGfQYZHx7j/p808+uLbrK6v5C9uXc70ovywyxKRFKLQzxDRvkH+x2Pb2Ly3k7t/bSFf/fCF5Gm+XkTGUehngNfbevi9R7cS7Rvkux+/nJuXV4VdkoikKIV+mtvwygG++uQrlBfl8+TvX8sl1WVhlyQiKUyhn6ZGx5w/27iLv/qP3TQsKOf7t1/JzGm61aCIvDuFfhrqOT7MF9a/zLO72rlt5Xz+6CPLtC6OiCREoZ9mIkeOctePtrK/s58/vvlibr96QdgliUgaUeinkZ83H+aL/7CdgrwcHr/ralbUVYRdkoikGYV+GnB3HvxlhAeeeZNl80pZ94kG5k2fGnZZIpKGFPop7tjgCH/w5Cs8/dohbr58Ht/66KUUTskNuywRSVMK/RS2v7Ofu37UxJuHj/KHv3ERd61eqJUwReScKPRT1PORKJ99fBujY87ffmoF77tgZtgliUgGUOinGHfnkeff4o//dScLK4v5m082UFtZHHZZIpIhFPopZGB4lK/95HWe3NrKDUtn852PX05Jgf4nEpHkUaKkiMO9A/zeo1vZvr+bz19fzxevrycnR/P3IpJcCv0UsG1fF7//6Fb6Bkf4q9uvYM3Fc8MuSUQylEI/ZE807edrP36dOWWF/OjTK7hoTmnYJYlIBlPoh2R4dIz//a87eeT5t1i1uJK/vE03PBGRyZfQKl1mtsbMdplZxMzuPc3+75jZ9uDxppl1x+27w8xagscdySw+XXUeG+ITP3iJR55/i0+vquORT12lwBeR82LCkb6Z5QIPAjcArcAWM9vg7s0n+rj7l+L6fw5YHjyvAL4BNAAObA2O7Urqb5FGdhzo4e4fbaW9b5AHfucyPnplddgliUgWSWSkvwKIuPsedx8C1gM3vUv/W4G/D55/GHjG3TuDoH8GWHMuBaezf3n1AL/9/RcYHXP+8feuUeCLyHmXyJx+FbA/brsVWHm6jma2AKgDfvEux/7KvfzM7G7gboD58+cnUFJ6GR1zHvjZLv7fs7u5ckE537/9CmZNKwy7LBHJQsk+kbsWeNLdR8/mIHdfB6wDaGho8CTXFKregWG+uH47v3jjCLeuqOGPblxGQZ4WTBORcCQS+m1ATdx2ddB2OmuBz4479v3jjn028fLS2+72Pu76URP7Ovr55s0Xc/vK+VowTURClcic/hag3szqzCyfWLBvGN/JzC4CyoEX4po3Ah8ys3IzKwc+FLRlvF++cYSb/3ITPf3DPPaZlXzi6gUKfBEJ3YQjfXcfMbN7iIV1LvCwu+8ws/uBJnc/8QdgLbDe3T3u2E4z+yaxPxwA97t7Z3J/hdTi7nz/P3bzZxt3sXRuKes+2UCVbngiIinC4jI6JTQ0NHhTU1PYZbxnz7W084kfbOYjl83jTz96KVPzNX8vIpPPzLa6e8NE/fSN3CT75RvtFOTl8Ge/rTtciUjqSegbuZK4TZEoV9VWKPBFJCUp9JPoSO8Auw4fZVV9ZdiliIiclkI/iTbtjgKwarFCX0RSk0I/iZ5riVJeNIWlc7U8soikJoV+krg7myJRrl1cqTteiUjKUugnSeRIH4d7B1mtqR0RSWEK/SRpjMTm869T6ItIClPoJ0ljS5TaGUXUVBSFXYqIyBkp9JNgeHSMF/d0aJQvIilPoZ8E2/d3c2xolNW6Pl9EUpxCPwkaW6LkGFyzUKEvIqlNoZ8EjZEol1RPp6xoStiliIi8K4X+OTo6MMz2/d2sWjwj7FJERCak0D9HL+7pZHTMWbV4ZtiliIhMSKF/jjZFokydkssVC6aHXYqIyIQU+ufouZZ2VtRV6GbnIpIWFPrn4GDPcXa3H9OqmiKSNhT656CxJVhKWdfni0iaUOifg02RKJUl+Vw4e1rYpYiIJESh/x65O42R2NILWkpZRNJFQqFvZmvMbJeZRczs3jP0+ZiZNZvZDjN7PK591My2B48NySo8bLsOHyXaN6j1dkQkreRN1MHMcoEHgRuAVmCLmW1w9+a4PvXAfcB17t5lZrPiXuK4u1+e5LpDd3I+X6EvImkkkZH+CiDi7nvcfQhYD9w0rs9dwIPu3gXg7keSW2bqaYxEWTizmHnTp4ZdiohIwhIJ/Spgf9x2a9AW7wLgAjPbZGYvmtmauH2FZtYUtN98ujcws7uDPk3t7e1n9QuEYXBklJf2dGqULyJpZ8LpnbN4nXrg/UA18J9mdom7dwML3L3NzBYCvzCz19x9d/zB7r4OWAfQ0NDgSapp0ry8r5vjw6MKfRFJO4mM9NuAmrjt6qAtXiuwwd2H3X0v8CaxPwK4e1vwcw/wLLD8HGsOXWNLlNwc4+pFWmRNRNJLIqG/Bag3szozywfWAuOvwvkJsVE+ZlZJbLpnj5mVm1lBXPt1QDNprjES5bLqMkoLtZSyiKSXCUPf3UeAe4CNwE7gCXffYWb3m9mNQbeNQIeZNQO/BP7A3TuAJUCTmb0StH8r/qqfdNTTP8yrrd2a2hGRtJTQnL67Pw08Pa7t63HPHfhy8Ijv8zxwybmXmTpe2NPBmMOqei2lLCLpR9/IPUubIlGK8nO5vEZLKYtI+lHon6XGSJSrF84gP08fnYikHyXXWWjt6mdv9JiWXhCRtKXQPwubIrGlF1ZrKWURSVMK/bPQGOlg1rQC6meVhF2KiMh7otBP0NiYsykSZdXiSsy0lLKIpCeFfoJ2Huql89iQ5vNFJK0p9BOkWyOKSCZQ6CeoMRKlflYJs0sLwy5FROQ9U+gnYGB4lM17OzXKF5G0p9BPwLa3uxgcGdN6OyKS9hT6CXguEiUvx1i5UEspi0h6U+gnYFMkyvL50ykpSNY9Z0REwqHQn0DXsSFea+th1WKtqiki6U+hP4EX9nTgDqvqNbUjIulPoT+B51qilBTkcVm1llIWkfSn0J/ApmAp5bxcfVQikv6UZO9iX0c/+zr7taqmiGQMhf67aAyWUtZ6OyKSKRT676Ix0s7cskIWzSwOuxQRkaRQ6J/B6Jjz/O4OrtNSyiKSQRIKfTNbY2a7zCxiZveeoc/HzKzZzHaY2eNx7XeYWUvwuCNZhU+2HQd66O4f1ny+iGSUCb9iama5wIPADUArsMXMNrh7c1yfeuA+4Dp37zKzWUF7BfANoAFwYGtwbFfyf5XkOjGff+0ihb6IZI5ERvorgIi773H3IWA9cNO4PncBD54Ic3c/ErR/GHjG3TuDfc8Aa5JT+uRqbIly0ZxpzJxWEHYpIiJJk0joVwH747Zbg7Z4FwAXmNkmM3vRzNacxbGY2d1m1mRmTe3t7YlXP0mOD43S9FaXVtUUkYyTrBO5eUA98H7gVuBvzCzhr7C6+zp3b3D3hpkzw1/jZstbnQyNjmn9fBHJOImEfhtQE7ddHbTFawU2uPuwu+8F3iT2RyCRY1POpkiU/NwcVtRVhF2KiEhSJRL6W4B6M6szs3xgLbBhXJ+fEBvlY2aVxKZ79gAbgQ+ZWbmZlQMfCtpS2nMtUa5YMJ2ifC2lLCKZZcLQd/cR4B5iYb0TeMLdd5jZ/WZ2Y9BtI9BhZs3AL4E/cPcOd+8EvknsD8cW4P6gLWV19A3SfLBX8/kikpESGsq6+9PA0+Pavh733IEvB4/xxz4MPHxuZZ4/m3Z3ALCqPvxzCyIiyaZv5I6zqSVKaWEel1SVhV2KiEjSKfTjuDuNkSjXLqokN0dLL4hI5lHox3mro5+27uNcp0s1RSRDKfTjNLbEvhi2WidxRSRDKfTjNEaiVE2fyoIZRWGXIiIyKRT6gZHRMZ7f3cEqLaUsIhlMoR94ra2HowMjWnpBRDKaQj/Q2HJiKeUZIVciIjJ5FPqBxkiUZfNKmVGipZRFJHMp9IFjgyNs26ellEUk8yn0gc1vdTI86prPF5GMp9AnNp+fn5fDVbVaSllEMptCn9j6+VfVllM4JTfsUkREJlXWh/6RowO8cego12k+X0SyQNaH/vOR2FLKqxdrKWURyXxZH/rPtUSZXjSFpfNKwy5FRGTSZXXouzubIlGu01LKIpIlsjr0d7f3cah3QPP5IpI1sjr0Tyy9sFrX54tIlsju0I90ML+iiJoKLaUsItkha0N/eHSMF/d06Fu4IpJVEgp9M1tjZrvMLGJm955m/51m1m5m24PHZ+L2jca1b0hm8efi1dZu+gZHtN6OiGSVvIk6mFku8CBwA9AKbDGzDe7ePK7rP7j7Pad5iePufvm5l5pcz7VEMdNSyiKSXRIZ6a8AIu6+x92HgPXATZNb1uTbFIlySVUZ04vywy5FROS8SST0q4D9cdutQdt4HzWzV83sSTOriWsvNLMmM3vRzG4+3RuY2d1Bn6b29vbEq3+P+gZHeHlft6Z2RCTrJOtE7k+BWne/FHgG+GHcvgXu3gDcBnzXzBaNP9jd17l7g7s3zJw5+cshvLSng5ExV+iLSNZJJPTbgPiRe3XQdpK7d7j7YLD5EHBl3L624Oce4Flg+TnUmxTPtUQpnJLDFQvKwy5FROS8SiT0twD1ZlZnZvnAWuCUq3DMbG7c5o3AzqC93MwKgueVwHXA+BPA511sKeUKLaUsIllnwqt33H3EzO4BNgK5wMPuvsPM7gea3H0D8HkzuxEYATqBO4PDlwB/bWZjxP7AfOs0V/2cV4d6Bmg50sfvNFSHWYaISCgmDH0Ad38aeHpc29fjnt8H3Hea454HLjnHGpNqUyS29ILW2xGRbJR138htjESZUZzPkjlaSllEsk9Whb670xiJcu3iSnK0lLKIZKGsCv03D/fRfnSQ1ZraEZEslVWh33hiPl+LrIlIlsqu0G9pZ2FlMVXTp4ZdiohIKLIm9IdGxnhpb6eu2hGRrJY1of/yvi76h0a1fr6IZLWsCf1NkSg5Blcv1FLKIpK9sib0n4tEuaxmOmVTp4RdiohIaLIi9HsHhnllv5ZSFhHJitB/YXcHY45CX0SyXlaE/qZIlKL8XJbP11LKIpLdsiL0G1uirKyrID8vK35dEZEzyvgUbOs+zp7oMV2fLyJCFoT+ppbY0gur6yf/NowiIqku40O/MRKlsqSAC2aXhF2KiEjoMjr0x8acTZEoqxbPwExLKYuIZHTov3HoKB3HhlilqR0RESDDQ78x0g7o+nwRkRMyPPQ7WDyrhDllhWGXIiKSEjI29AeGR9m8t0OjfBGROAmFvpmtMbNdZhYxs3tPs/9OM2s3s+3B4zNx++4ws5bgcUcyi3832/Z1MTA8ptAXEYmTN1EHM8sFHgRuAFqBLWa2wd2bx3X9B3e/Z9yxFcA3gAbAga3BsV1Jqf5dNLZEyc0xVi6smOy3EhFJG4mM9FcAEXff4+5DwHrgpgRf/8PAM+7eGQT9M8Ca91bq2dkUibK8ZjrTCrWUsojICYmEfhWwP267NWgb76Nm9qqZPWlmNWdzrJndbWZNZtbU3t6eYOln1t0/xKttPVp6QURknGSdyP0pUOvulxIbzf/wbA5293Xu3uDuDTNnnvs19S/s7sAdVuvWiCIip0gk9NuAmrjt6qDtJHfvcPfBYPMh4MpEj50Mz0WilBTkcVnN9Ml+KxGRtJJI6G8B6s2szszygbXAhvgOZjY3bvNGYGfwfCPwITMrN7Ny4ENB26TaFIly9cIKpuRm7BWpIiLvyYRX77j7iJndQyysc4GH3X2Hmd0PNLn7BuDzZnYjMAJ0AncGx3aa2TeJ/eEAuN/dOyfh9zhpf2c/b3f0c+e1tZP5NiIiaWnC0Adw96eBp8e1fT3u+X3AfWc49mHg4XOo8aw0Rk4spaz5fBGR8TJu/qOxJcrs0gIWzdRSyiIi42VU6I+NOZt2R1m1eKaWUhYROY2MCv0dB3rp7h9mVf2MsEsREUlJGRX6J+bz9aUsEZHTy7DQb+fC2dOYNU1LKYuInE7GhP7A8Chb3upila7aERE5o4wJ/d6BYdYsm8P1F80KuxQRkZSV0HXeI62QAAADLklEQVT66WDWtEL+763Lwy5DRCSlZcxIX0REJqbQFxHJIgp9EZEsotAXEckiCn0RkSyi0BcRySIKfRGRLKLQFxHJIubuYddwCjNrB94+h5eoBKJJKifd6bM4lT6PU+nzeEcmfBYL3H3mRJ1SLvTPlZk1uXtD2HWkAn0Wp9LncSp9Hu/Ips9C0zsiIllEoS8ikkUyMfTXhV1ACtFncSp9HqfS5/GOrPksMm5OX0REziwTR/oiInIGCn0RkSySMaFvZmvMbJeZRczs3rDrCZOZ1ZjZL82s2cx2mNkXwq4pbGaWa2Yvm9m/hF1L2Mxsupk9aWZvmNlOM7sm7JrCZGZfCv6dvG5mf29mGX2T7YwIfTPLBR4Efh1YCtxqZkvDrSpUI8BX3H0pcDXw2Sz/PAC+AOwMu4gU8T3g3939IuAysvhzMbMq4PNAg7tfDOQCa8OtanJlROgDK4CIu+9x9yFgPXBTyDWFxt0Puvu24PlRYv+oq8KtKjxmVg38JvBQ2LWEzczKgF8DfgDg7kPu3h1uVaHLA6aaWR5QBBwIuZ5JlSmhXwXsj9tuJYtDLp6Z1QLLgZfCrSRU3wW+CoyFXUgKqAPagb8NprseMrPisIsKi7u3AX8O7AMOAj3u/rNwq5pcmRL6chpmVgL8E/BFd+8Nu54wmNl/BY64+9awa0kRecAVwPfdfTlwDMjac2BmVk5sVqAOmAcUm9nt4VY1uTIl9NuAmrjt6qAta5nZFGKB/5i7PxV2PSG6DrjRzN4iNu33X8zs78ItKVStQKu7n/h/fk8S+yOQrT4I7HX3dncfBp4Crg25pkmVKaG/Bag3szozyyd2ImZDyDWFxsyM2JztTnf/dtj1hMnd73P3anevJfbfxS/cPaNHcu/G3Q8B+83swqDpeqA5xJLCtg+42syKgn8315PhJ7bzwi4gGdx9xMzuATYSO/v+sLvvCLmsMF0HfAJ4zcy2B21/6O5Ph1iTpI7PAY8FA6Q9wKdCric07v6SmT0JbCN21dvLZPiSDFqGQUQki2TK9I6IiCRAoS8ikkUU+iIiWUShLyKSRRT6IiJZRKEvIpJFFPoiIlnk/wMmvUZoKkpmTAAAAABJRU5ErkJggg==\n", 445 | "text/plain": [ 446 | "
" 447 | ] 448 | }, 449 | "metadata": { 450 | "needs_background": "light" 451 | }, 452 | "output_type": "display_data" 453 | } 454 | ], 455 | "source": [ 456 | "loss_curve = history.history[\"loss\"]\n", 457 | "acc_curve = history.history[\"accuracy\"]\n", 458 | "\n", 459 | "plt.plot(loss_curve)\n", 460 | "plt.title(\"Loss\")\n", 461 | "plt.show()\n", 462 | "\n", 463 | "plt.plot(acc_curve)\n", 464 | "plt.title(\"Accuracy\")\n", 465 | "plt.show()" 466 | ] 467 | } 468 | ], 469 | "metadata": { 470 | "kernelspec": { 471 | "display_name": "Python 3", 472 | "language": "python", 473 | "name": "python3" 474 | }, 475 | "language_info": { 476 | "codemirror_mode": { 477 | "name": "ipython", 478 | "version": 3 479 | }, 480 | "file_extension": ".py", 481 | "mimetype": "text/x-python", 482 | "name": "python", 483 | "nbconvert_exporter": "python", 484 | "pygments_lexer": "ipython3", 485 | "version": "3.6.7" 486 | } 487 | }, 488 | "nbformat": 4, 489 | "nbformat_minor": 2 490 | } 491 | -------------------------------------------------------------------------------- /others/Simple neural network.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Import" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "Limited tf.compat.v2.summary API due to missing TensorBoard installation\n", 20 | "Limited tf.summary API due to missing TensorBoard installation\n" 21 | ] 22 | } 23 | ], 24 | "source": [ 25 | "# Matplotlib\n", 26 | "import matplotlib.pyplot as plt\n", 27 | "# Tensorflow\n", 28 | "import tensorflow as tf\n", 29 | "# Numpy and Pandas\n", 30 | "import numpy as np\n", 31 | "import pandas as pd\n", 32 | "# Ohter import\n", 33 | "import sys" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "## Be sure to used Tensorflow 2.0" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 2, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "## Load the dataset: Fashion MNIST" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "![](https://storage.googleapis.com/kaggle-datasets-images/2243/3791/9384af51de8baa77f6320901f53bd26b/dataset-cover.png)" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 3, 69 | "metadata": { 70 | "scrolled": true 71 | }, 72 | "outputs": [ 73 | { 74 | "name": "stdout", 75 | "output_type": "stream", 76 | "text": [ 77 | "(10000, 28, 28)\n", 78 | "(10000,)\n" 79 | ] 80 | } 81 | ], 82 | "source": [ 83 | "# Fashio MNIST\n", 84 | "fashion_mnist = tf.keras.datasets.fashion_mnist\n", 85 | "(images, targets), (_, _) = fashion_mnist.load_data()\n", 86 | "\n", 87 | "# Get only a subpart of the dataset\n", 88 | "# Get only a subpart\n", 89 | "images = images[:10000]\n", 90 | "targets = targets [:10000]\n", 91 | "\n", 92 | "print(images.shape)\n", 93 | "print(targets.shape)" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "## Plot one of the data" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": 4, 106 | "metadata": {}, 107 | "outputs": [ 108 | { 109 | "data": { 110 | "image/png": "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\n", 111 | "text/plain": [ 112 | "
" 113 | ] 114 | }, 115 | "metadata": { 116 | "needs_background": "light" 117 | }, 118 | "output_type": "display_data" 119 | } 120 | ], 121 | "source": [ 122 | "targets_names = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\", \"Sandal\", \n", 123 | " \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"\n", 124 | "]\n", 125 | "# Plot one image\n", 126 | "plt.imshow(images[11], cmap=\"binary\")\n", 127 | "plt.title(targets_names[targets[11]])\n", 128 | "plt.show()" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 5, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "First line of one image [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 39 111 93 85\n", 141 | " 27 0 0 0 0 0 1 0 0 0]\n", 142 | "Associated target 9\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "print(\"First line of one image\", images[11][0])\n", 148 | "print(\"Associated target\", targets[11])" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "# Create the model\n", 156 | "![](images/simple_nn.png)" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "## Flatten the image" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 6, 169 | "metadata": {}, 170 | "outputs": [ 171 | { 172 | "name": "stdout", 173 | "output_type": "stream", 174 | "text": [ 175 | "Shape of the image (1, 28, 28)\n", 176 | "Shape of the image after the Flatten (1, 784)\n" 177 | ] 178 | } 179 | ], 180 | "source": [ 181 | "# Create the model\n", 182 | "model = tf.keras.models.Sequential()\n", 183 | "model.add(tf.keras.layers.Flatten(input_shape=[28, 28]))\n", 184 | "\n", 185 | "print(\"Shape of the image\", images[0:1].shape)\n", 186 | "model_output = model.predict(images[0:1])\n", 187 | "print(\"Shape of the image after the Flatten\", model_output.shape)" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "# Add the layers" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": 7, 200 | "metadata": {}, 201 | "outputs": [ 202 | { 203 | "name": "stdout", 204 | "output_type": "stream", 205 | "text": [ 206 | "[[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]] [9]\n" 207 | ] 208 | } 209 | ], 210 | "source": [ 211 | "# Flatten\n", 212 | "model = tf.keras.models.Sequential()\n", 213 | "model.add(tf.keras.layers.Flatten(input_shape=[28, 28]))\n", 214 | "\n", 215 | "# Add the layers\n", 216 | "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n", 217 | "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n", 218 | "model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n", 219 | "\n", 220 | "model_output = model.predict(images[0:1])\n", 221 | "print(model_output, targets[0:1])" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "## Model Summary" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 8, 234 | "metadata": {}, 235 | "outputs": [ 236 | { 237 | "name": "stdout", 238 | "output_type": "stream", 239 | "text": [ 240 | "Model: \"sequential_1\"\n", 241 | "_________________________________________________________________\n", 242 | "Layer (type) Output Shape Param # \n", 243 | "=================================================================\n", 244 | "flatten_1 (Flatten) (None, 784) 0 \n", 245 | "_________________________________________________________________\n", 246 | "dense (Dense) (None, 256) 200960 \n", 247 | "_________________________________________________________________\n", 248 | "dense_1 (Dense) (None, 128) 32896 \n", 249 | "_________________________________________________________________\n", 250 | "dense_2 (Dense) (None, 10) 1290 \n", 251 | "=================================================================\n", 252 | "Total params: 235,146\n", 253 | "Trainable params: 235,146\n", 254 | "Non-trainable params: 0\n", 255 | "_________________________________________________________________\n" 256 | ] 257 | } 258 | ], 259 | "source": [ 260 | "model.summary()" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": {}, 266 | "source": [ 267 | "## Compile the model" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 9, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [ 276 | "# Compile the model\n", 277 | "model.compile(\n", 278 | " loss=\"sparse_categorical_crossentropy\",\n", 279 | " optimizer=\"sgd\",\n", 280 | " metrics=[\"accuracy\"]\n", 281 | ")" 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "## Train the model" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": 10, 294 | "metadata": {}, 295 | "outputs": [ 296 | { 297 | "name": "stdout", 298 | "output_type": "stream", 299 | "text": [ 300 | "Epoch 1/10\n", 301 | "10000/10000 [==============================] - 1s 58us/sample - loss: 10.8593 - accuracy: 0.6027\n", 302 | "Epoch 2/10\n", 303 | "10000/10000 [==============================] - 1s 52us/sample - loss: 0.9779 - accuracy: 0.6885\n", 304 | "Epoch 3/10\n", 305 | "10000/10000 [==============================] - 1s 55us/sample - loss: 0.8373 - accuracy: 0.7047\n", 306 | "Epoch 4/10\n", 307 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.7515 - accuracy: 0.7247\n", 308 | "Epoch 5/10\n", 309 | "10000/10000 [==============================] - 1s 52us/sample - loss: 0.6660 - accuracy: 0.7518\n", 310 | "Epoch 6/10\n", 311 | "10000/10000 [==============================] - 1s 50us/sample - loss: 0.6186 - accuracy: 0.7641\n", 312 | "Epoch 7/10\n", 313 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.5768 - accuracy: 0.7753\n", 314 | "Epoch 8/10\n", 315 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.5507 - accuracy: 0.7813\n", 316 | "Epoch 9/10\n", 317 | "10000/10000 [==============================] - 1s 50us/sample - loss: 0.5309 - accuracy: 0.7942\n", 318 | "Epoch 10/10\n", 319 | "10000/10000 [==============================] - 1s 51us/sample - loss: 0.5167 - accuracy: 0.7971\n" 320 | ] 321 | } 322 | ], 323 | "source": [ 324 | "history = model.fit(images, targets, epochs=10)" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": 11, 330 | "metadata": {}, 331 | "outputs": [ 332 | { 333 | "data": { 334 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAF5JJREFUeJzt3X2MHHd9x/HPd3b39p52Hds5exc75AKJvRch8VC3PEmoIrSigEglqioIEEJV00otT6JFUKniP1q1iEJVhOQmUCRQUBWighClIB6KkNoUJ9BCcnYenRDHD2f7nHuy9253v/1jZu/2znfx+XbvZmfm/ZJOtzM7O/v12v78fvubmd+YuwsAkHxB3AUAAHqDQAeAlCDQASAlCHQASAkCHQBSgkAHgJQg0AEgJQh0pJKZnTSzt8RdB7CTCHQASAkCHZliZn9sZk+Y2UUz+5aZvSRab2b2D2Z2zsxmzOyXZvaK6Lm3mdmjZjZrZqfM7C/i/VMA6yPQkRlm9mZJfyPpDyVVJT0j6evR078r6U2SDknaFW1zIXruXkl/4u4lSa+Q9MMdLBvYtHzcBQA76D2SvuTuD0uSmX1S0rSZjUtaklSSVJP0P+4+2fG6JUm3m9n/uvu0pOkdrRrYJHroyJKXKOyVS5LcfU5hL/yAu/9Q0j9J+oKkc2Z21MzK0abvkvQ2Sc+Y2X+a2et3uG5gUwh0ZMnzkm5uL5jZiKS9kk5Jkrv/o7v/hqTbFQ69/GW0/mfufqekfZL+TdK/7nDdwKYQ6EizgpkNtn8k3SfpA2b2KjMrSvq0pAfd/aSZ/aaZvdbMCpLmJV2R1DKzATN7j5ntcvclSTOSWrH9iYAXQaAjzb4j6XLHz29L+mtJ35B0WtLLJd0VbVuW9M8Kx8efUTgU8/fRc++TdNLMZiT9qcKxeKDvGDe4AIB0oIcOAClBoANAShDoAJASBDoApMSOXil64403+vj4+E6+JQAk3kMPPXTe3ceutd2OBvr4+LiOHTu2k28JAIlnZs9ceyuGXAAgNQh0AEgJAh0AUoJAB4CUINABICUIdABICQIdAFIiEYH+zV+c0lf/e1OnYQJAZiUi0P/9l2f0pZ8+HXcZANDXEhHotWpJT1+Y1+XFZtylAEDfSkagV8pylx47Oxt3KQDQtxIR6BPVkiTp+JmZmCsBgP6ViEC/afewhgdymjxNDx0ANpKIQA8C06H9JZ04Q6ADwEYSEehSOOxy/MyMuKk1AKwvMYFeq5Q1vbCkc7P1uEsBgL6UoEAPD4xOnubAKACsJ0GBXpYkHWccHQDWlZhA3zVcUHXXoI7TQweAdSUm0KVw2IUeOgCsL1mBXi3ryak5LTZacZcCAH0nWYFeKWmp6Xrq/FzcpQBA37lmoJvZl8zsnJn9qmPdHjP7vpk9Hv3evb1lhiaq0YFRrhgFgKtspof+L5LeumbdJyT9wN1vk/SDaHnb3XLjiAZygSaZ0wUArnLNQHf3n0i6uGb1nZK+Ej3+iqTf73Fd6yrkAt26b5QeOgCsY6tj6Pvd/XT0+Iyk/RttaGZ3m9kxMzs2NTW1xbdbUaswpwsArKfrg6IeTq6y4QQr7n7U3Y+4+5GxsbFu3061aklnZq5oen6x630BQJpsNdDPmllVkqLf53pX0ovjilEAWN9WA/1bkt4fPX6/pG/2ppxrq3GzCwBY12ZOW7xP0n9JOmxmz5nZH0n6W0m/Y2aPS3pLtLwjxkaL2jsywIFRAFgjf60N3P3dGzx1R49r2RQzUy2aGx0AsCJRV4q2Hd5f1mNn59RscbMLAGhLZKDXqiVdXmrq2YsLcZcCAH0jkYE+0T7Thal0AWBZIgP9tv2jCkya5NRFAFiWyEAfLOR0y40j9NABoEMiA10K50bn4iIAWJHcQN9f0rMXFzRXb8RdCgD0heQGejQ3+mNn6aUDgJTkQK9EUwBwxSgASEpwoB/cPaTRYp4rRgEgkthANzPVKiV66AAQSWygS+EVo5NnZhROyQ4A2ZbsQK+UNXuloedfuBJ3KQAQu4QHenhg9ATj6ACQ7EA/FAX6JOPoAJDsQC8PFnRw9xBXjAKAEh7oUjiOzpwuAJCCQJ+olvTU+XldWWrGXQoAxCrxgV6rlNVsuZ44Nxd3KQAQq8QH+uHlM10YRweQbYkP9PG9wyrmA6YAAJB5iQ/0fC7Qof0lznQBkHmJD3QpvMCIc9EBZF06Ar1a1vm5uqZm63GXAgCxSUWgT3BgFADSEejtM104MAogy1IR6HtHixorFTkwCiDTUhHoUnhglB46gCxLTaBPVMt67OycGs1W3KUAQCy6CnQz+6iZPWJmvzKz+8xssFeFXa9apaTFRksnL8zHVQIAxGrLgW5mByR9SNIRd3+FpJyku3pV2PWqVcqSmBsdQHZ1O+SSlzRkZnlJw5Ke776krXn5vhHlA2McHUBmbTnQ3f2UpM9IelbSaUkvuPv31m5nZneb2TEzOzY1NbX1Sq+hmM/pZWMjnIsOILO6GXLZLelOSbdIeomkETN779rt3P2oux9x9yNjY2Nbr3QTapUyQy4AMqubIZe3SHra3afcfUnSA5Le0JuytqZWLenUpcuaubIUZxkAEItuAv1ZSa8zs2EzM0l3SJrsTVlbMxEdGGXYBUAWdTOG/qCk+yU9LOmX0b6O9qiuLalVoykAuMcogAzKd/Nid/+UpE/1qJauVcqD2jVU0CQ9dAAZlJorRSXJzFSrlBhyAZBJqQp0ScuB3mp53KUAwI5KX6BXy5qrN3Tq0uW4SwGAHZW+QI/mRp/kwCiAjEldoB/aX5KZmBsdQOakLtBHinndvGeYOV0AZE7qAl0KpwCghw4ga1IZ6IcrJZ08P6/Li824SwGAHZPKQJ+oltRy6fFz9NIBZEcqA719s4vjzLwIIENSGegv3TOsoUJOkxwYBZAhqQz0IDAdrpTooQPIlFQGuhSOox8/MyN3pgAAkA2pDfTD+0uaXljS1Gw97lIAYEekNtBr1fDAKFPpAsiK9AZ6hZtdAMiW1Ab6DcMDqu4a5IpRAJmR2kCXwl46sy4CyIp0B3q1rCen5rTUbMVdCgBsu3QHeqWkpabrqan5uEsBgG2X8kCPpgDgilEAGZDqQH/Z2IgKOdMkV4wCyIBUB3ohF+jWfSV66AAyIdWBLkkTzOkCICNSH+i1aklnZq7o0sJi3KUAwLZKf6AvHxillw4g3TIQ6EwBACAbUh/oY6Wi9owM0EMHkHqpD3QzC6cAINABpFxXgW5mN5jZ/WZ23Mwmzez1vSqsl2qVsh47M6tmi5tdAEivbnvon5f0XXevSXqlpMnuS+q9WrWky0tNPXtxIe5SAGDbbDnQzWyXpDdJuleS3H3R3S/1qrBemmif6cKBUQAp1k0P/RZJU5K+bGY/N7N7zGxk7UZmdreZHTOzY1NTU1283dbdtn9UgXHqIoB06ybQ85JeI+mL7v5qSfOSPrF2I3c/6u5H3P3I2NhYF2+3dYOFnMZvHGEKAACp1k2gPyfpOXd/MFq+X2HA96WJSpkeOoBU23Kgu/sZSb82s8PRqjskPdqTqrZBrVLSMxcWNF9vxF0KAGyLbs9y+aCkr5nZ/0l6laRPd1/S9qhVwwOjJ87SSweQTvluXuzuv5B0pEe1bKuVKQBm9ZqX7o65GgDovdRfKdp2cPeQRot5neDAKICUykygm5kOMwUAgBTLTKBL4bDL8dMzcmcKAADpk61Ar5Y1c6Wh0y9cibsUAOi5TAX6RPvAKOPoAFIoU4F+KAr0Se4xCiCFMhXo5cGCDu4e0gkOjAJIoUwFuhTOjc6QC4A0ymCgl/Tk1LzqjWbcpQBAT2Uv0KslNVuuJ87NxV0KAPRU9gJ9+WYXjKMDSJfMBfr43mEV8wHj6ABSJ3OBns8FOrS/xNzoAFInc4EuRVMAEOgAUiaTgX64UtLUbF3n5+pxlwIAPZPJQJ9o3+yCXjqAFMlkoNeWpwDgwCiA9MhkoO8dLWqsVGQcHUCqZDLQpfaBUXroANIjs4E+US3r8bNzajRbcZcCAD2R2UA/vL+keqOlkxcW4i4FAHois4Feq3KzCwDpktlAv3XfqHKBMacLgNTIbKAX8zm9fGyEHjqA1MhsoEvhzIvcjg5AWmQ70Kslnbp0WTNXluIuBQC6lulAn4jmRn+MC4wApECmA/1wewoAAh1ACmQ60Ku7BlUezOs4c7oASIGuA93Mcmb2czP7di8K2klmplq1zJwuAFKhFz30D0ua7MF+YjFRKenEmVm5e9ylAEBXugp0Mzso6e2S7ulNOTuvVi1rrt7Qc9OX4y4FALrSbQ/9c5I+LmnDGa7M7G4zO2Zmx6amprp8u95rz43OsAuApNtyoJvZOySdc/eHXmw7dz/q7kfc/cjY2NhW327bHNofBToHRgEkXDc99DdKeqeZnZT0dUlvNrOv9qSqHTRSzOvmvcP00AEk3pYD3d0/6e4H3X1c0l2Sfuju7+1ZZTuoVilpkjldACRcps9Db6tVyjp5fl6XF5txlwIAW9aTQHf3H7v7O3qxrzhMVEtqufT4OYZdACQXPXSFPXSJM10AJBuBLumle4Y1VMhxswsAiUagSwoC06FKiZtdAEg0Aj0yUSlp8vQMUwAASCwCPVKrlDS9sKSp2XrcpQDAlhDokVo1PDDK3OgAkopAj7TndDnBODqAhCLQIzcMD6i6a5AzXQAkFoHe4XClxJALgMQi0DvUKmU9cW5WS80NZwMGgL5FoHeYqJa01HQ9NTUfdykAcN0I9A4rUwBwYBRA8hDoHV42NqJCzpjTBUAiEegdCrlAt+4rcfciAIlEoK8xUSnRQweQSAT6GocrJZ1+4YouLSzGXQoAXBcCfY32FAD00gEkDYG+xkQ0BQDj6ACShkBfY6xU1J6RAZ04Sw8dQLIQ6GuYmWqVkiaZ0wVAwhDo66hVyjpxZlatFje7AJAcBPo6apWSLi819ezFhbhLAYBNI9DXUatGB0aZAgBAghDo67htX0mBiXF0AIlCoK9jaCCn8RtH6KEDSBQCfQMT0YFRAEgKAn0DtUpJz1xc0Hy9EXcpALApBPoGDldKcpce4wIjAAlBoG9ggjldACTMlgPdzG4ysx+Z2aNm9oiZfbiXhcXtwA1DGi3mmdMFQGLku3htQ9LH3P1hMytJesjMvu/uj/aotlgFgelwpaRJeugAEmLLPXR3P+3uD0ePZyVNSjrQq8L6Qa1S0okzs3JnCgAA/a8nY+hmNi7p1ZIe7MX++kWtWtYLl5d0ZuZK3KUAwDV1HehmNirpG5I+4u5XDTib2d1mdszMjk1NTXX7djtqZW50hl0A9L+uAt3MCgrD/Gvu/sB627j7UXc/4u5HxsbGunm7HXcoCvRJrhgFkADdnOViku6VNOnun+1dSf2jPFjQgRuG6KEDSIRueuhvlPQ+SW82s19EP2/rUV19Y6JaYk4XAImw5dMW3f2nkqyHtfSlWqWsH5+YUr3RVDGfi7scANgQV4peQ61aUqPlevLcfNylAMCLItCvoVZpTwHAsAuA/kagX8P43mEN5APmdAHQ9wj0a8jnAh3aP6pJ5nQB0OcI9E2oVcr00AH0PQJ9E2qVkqZm67owV4+7FADYEIG+Ce250bklHYB+RqBvQm15CgACHUD/ItA3Ye9oUWOlIje7ANDXCPRNqlVKHBgF0NcI9E2qVUp67OysGs1W3KUAwLoI9E2qVcqqN1o6eWEh7lIAYF0E+ibVquGBUc50AdCvurlJdKbcum9UucB0z0+f0iPPv6A9IwPaPTygPaMD2jM8oD0j4c/wQE7hVPEAsLMI9E0q5nN612sO6EcnpnT0J0+p0Vr/xtED+UB722E/svLTGf67RwraO1LU7pGCdg8PqJDjixKA7hHo1+Hv/uCVkiR318yVhqbnF3VxYVEX58Lf0/OLuhj9TC8s6sL8op6bXtDF+UXNXGlsuN/yYD4M/ZGBqxqD3SPRN4DlxmBA5cE83wIAXIVA3wIz066hgnYNFTSukU29ZqnZ0vTCoqbnl3Rhvq7p+aXlxmB6YaUheP7SFT3y/IwuzC9qsbH+GTX5wDQ6mNfIQF4jxZyGB/IaLeY1PJDTSDFcFz4Xrhst5jVczGuk/Xz0unDbvIYLOQUBDQSQdAT6DinkAu0rDWpfaVBS6Zrbu7sWFpvLQb/2G8BcvaH5elMLiw3N1RtaWGzq/Fxd84vh+vl6Q/UNGoT1DBXWNgYbNBRRg9DZUIxG23Y2FMV8wLcIYIcR6H3KzJZ70DftGd7SPpaaLS0shqE/X18J+vnF9u+V9WHDsHrb6YVwyGi+3lzedoNDB1fJBRY2BB0hv9wIDKw0HKu+OVzjmwXHGoAXR6CnWCEXaNdQoF1DhZ7sz91Vb7SWAz/8ZhA2EAv1lW8KaxuKdoOwUG/q+UtXVjUeC4vNTb//QC7QcHF1IzEykNfQQE4D+UDFXKCBfPhTaD+OfhfzK8uFju3Wvm75tbmO10Svy9OgoM8R6Ng0M9NgIafBQk57R3uzz1bLtbAUNgjL3xyihmG5wVjnm8VCx7eG83N1LTZbWmxEPx2PNzobaSsC03JjUOxoLNY2BO3HhZwtryvkAhXya5ajdauWc9bx+mg5F6iQX7OcW/2e7X3nA2OoK8MIdMQqCEyjxXCsfju0Wh4GfGfgd4b+Ztav93iD1y01w28wS03XUvS+S82WlhprlpuuZg8bm075wJQLbOV3LlBgncumnIWPl5eDQDmT8kHQsW5lu85tckHYcORy4T6X951rv0cQvS78+23vIzBTYOFwXHv9queD6Pl11uei1wbByr5yy/tQx/7XX2+mlefNZIGW61n7fGBKbKNIoCPVgsA0GITfKvpNs+VRuLdWGoDG6uX68nIret5XLzddS43O58NvJc3op9Hxu7W8vHqb1du11Gy56o3mqvVrt2uu2VdrzXulQdAR8iuBv9IArDQW1rFt2BgEwdWvvff9R3Tz3s2dFbdVBDoQk7CH3J+NTTfcXS0PG6yWRw2Ah6F/1fqOxy3XButdzVb4XCvaV+f6ZsvlfvX69rYe7bfVUUNr1fr28srjlrf/HGu2b3Vu46u3bb34a4v57f97JtAB9JSZRUMzyRy2SDIO2wNAShDoAJASBDoApASBDgApQaADQEp0Fehm9lYzO2FmT5jZJ3pVFADg+m050M0sJ+kLkn5P0u2S3m1mt/eqMADA9emmh/5bkp5w96fcfVHS1yXd2ZuyAADXq5sLiw5I+nXH8nOSXrt2IzO7W9Ld0eKcmZ3Y4vvdKOn8Fl+bRnweK/gsVuPzWC0Nn8fNm9lo268Udfejko52ux8zO+buR3pQUirweazgs1iNz2O1LH0e3Qy5nJJ0U8fywWgdACAG3QT6zyTdZma3mNmApLskfas3ZQEArteWh1zcvWFmfy7pPyTlJH3J3R/pWWVX63rYJmX4PFbwWazG57FaZj4Pc0/H3MUAkHVcKQoAKUGgA0BKJCLQmWIgZGY3mdmPzOxRM3vEzD4cd039wMxyZvZzM/t23LXEzcxuMLP7zey4mU2a2evjrikuZvbR6P/Jr8zsPjMbjLum7db3gc4UA6s0JH3M3W+X9DpJf5bhz6LThyVNxl1En/i8pO+6e03SK5XRz8XMDkj6kKQj7v4KhSdu3BVvVduv7wNdTDGwzN1Pu/vD0eNZhf9ZD8RbVbzM7KCkt0u6J+5a4mZmuyS9SdK9kuTui+5+Kd6qYpWXNGRmeUnDkp6PuZ5tl4RAX2+KgUyHmCSZ2bikV0t6MN5KYvc5SR+X1Iq7kD5wi6QpSV+OhqDuMbPtvc18n3L3U5I+I+lZSaclveDu34u3qu2XhEDHGmY2Kukbkj7i7jNx1xMXM3uHpHPu/lDctfSJvKTXSPqiu79a0rykTB5zMrPdCr/J3yLpJZJGzOy98Va1/ZIQ6Ewx0MHMCgrD/Gvu/kDc9cTsjZLeaWYnFQ7FvdnMvhpvSbF6TtJz7t7+1na/woDPordIetrdp9x9SdIDkt4Qc03bLgmBzhQDETMzheOjk+7+2bjriZu7f9LdD7r7uMJ/Fz9099T3wjbi7mck/drMDker7pD0aIwlxelZSa8zs+Ho/80dysAB4m2fbbFbMUwx0M/eKOl9kn5pZr+I1v2Vu38nxprQXz4o6WtR5+cpSR+IuZ5YuPuDZna/pIcVnh32c2VgCgAu/QeAlEjCkAsAYBMIdABICQIdAFKCQAeAlCDQASAlCHQASAkCHQBS4v8BX/i/0Gz+SkQAAAAASUVORK5CYII=\n", 335 | "text/plain": [ 336 | "
" 337 | ] 338 | }, 339 | "metadata": { 340 | "needs_background": "light" 341 | }, 342 | "output_type": "display_data" 343 | }, 344 | { 345 | "data": { 346 | "image/png": "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\n", 347 | "text/plain": [ 348 | "
" 349 | ] 350 | }, 351 | "metadata": { 352 | "needs_background": "light" 353 | }, 354 | "output_type": "display_data" 355 | } 356 | ], 357 | "source": [ 358 | "loss_curve = history.history[\"loss\"]\n", 359 | "acc_curve = history.history[\"accuracy\"]\n", 360 | "\n", 361 | "plt.plot(loss_curve)\n", 362 | "plt.title(\"Loss\")\n", 363 | "plt.show()\n", 364 | "\n", 365 | "plt.plot(acc_curve)\n", 366 | "plt.title(\"Accuracy\")\n", 367 | "plt.show()" 368 | ] 369 | } 370 | ], 371 | "metadata": { 372 | "kernelspec": { 373 | "display_name": "Python 3", 374 | "language": "python", 375 | "name": "python3" 376 | }, 377 | "language_info": { 378 | "codemirror_mode": { 379 | "name": "ipython", 380 | "version": 3 381 | }, 382 | "file_extension": ".py", 383 | "mimetype": "text/x-python", 384 | "name": "python", 385 | "nbconvert_exporter": "python", 386 | "pygments_lexer": "ipython3", 387 | "version": "3.6.7" 388 | } 389 | }, 390 | "nbformat": 4, 391 | "nbformat_minor": 2 392 | } 393 | --------------------------------------------------------------------------------