lab-guided-cnn-mnist.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"_K94I7aFLQ9S"},"source":["# Guided lab : Image Classification using CNN\n","\n","At the end of this tutorial, you would get familiarized with\n","\n","*   Creating deep networks using Keras\n","*   Steps necessary in training a neural network\n","*   Prediction and performance analysis using neural networks\n","\n","---"]},{"cell_type":"markdown","metadata":{"id":"KdglSzOi4Cp-"},"source":["# **Colaboratory environment**\n","By default, Colab notebooks run on CPU.\n","You can switch your notebook to run with GPU.\n","\n","In order to obtain access to the GPU, you need to choose the tab Runtime and then select “Change runtime type” as shown in the following figure:\n","\n","![Changing runtime](https://miro.medium.com/max/747/1*euE7nGZ0uJQcgvkpgvkoQg.png)\n","\n","When a pop-up window appears select GPU. \n","\n","**Ensure “Hardware accelerator” is set to GPU.**"]},{"cell_type":"markdown","metadata":{"id":"Zli14lxJ48BK"},"source":["# **Environment set up**\n","**Keras** is a Python library that provides, in a simple way, the creation of a wide range of Deep Learning models using as backend other libraries such as TensorFlow, Theano or CNTK **(We would use Tensorflow backend)**. \n","\n","Keras is used since its learning curve is very smooth compared to others, and at the moment it is one of the popular middleware to implement neural networks.\n","\n","The developer guides for Keras can be found at: https://keras.io/guides/"]},{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3686,"status":"ok","timestamp":1667911202240,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"P3BPaal61sjX","outputId":"ea5139e2-1936-42f6-86f5-a6591e73ddda"},"outputs":[{"name":"stderr","output_type":"stream","text":["2024-08-14 17:55:36.362457: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n","To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"]},{"name":"stdout","output_type":"stream","text":["3.3.3\n"]}],"source":["from tensorflow import keras\n","\n","print(keras.__version__)"]},{"cell_type":"markdown","metadata":{"id":"I5slKBah5sLk"},"source":["# **Understanding Data: MNIST Dataset**\n","The MNIST dataset is an acronym that stands for the Modified National Institute of Standards and Technology dataset. \n","\n","It is a dataset of 60,000 small square 28×28 pixel grayscale images of handwritten single digits between 0 and 9.\n","\n","In Keras, the MNIST dataset is preloaded in the form of four Numpy arrays. x_train and y_train contain the training set, while x_test and y_test contain the test data. The images are encoded as Numpy arrays and their corresponding labels ranging from 0 to 9."]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2262,"status":"ok","timestamp":1667911204495,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"KWxUKDUf0N70","outputId":"3d3eb986-2ef3-4208-d96e-871b975d4c95"},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 28, 28)\n","3\n","uint8\n","(10000, 28, 28)\n"]}],"source":["from tensorflow.keras.datasets import mnist\n","(x_train, y_train), (x_test, y_test) = mnist.load_data()\n","\n","print(x_train.shape)\n","print(x_train.ndim)\n","print(x_train.dtype)\n","\n","print(x_test.shape)"]},{"cell_type":"markdown","metadata":{"id":"ibzTShLR-ZYv"},"source":["## Visualizing the Data\n","\n","A plot of the first nine images in the dataset is created showing the natural handwritten nature of the images to be classified.\n","\n","**Let us create a 3*3 subplot to visualize the first 9 images of the dataset.** "]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":268},"executionInfo":{"elapsed":2351,"status":"ok","timestamp":1667911206843,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"o8VOg4ix0Yry","outputId":"29949993-a0c4-4d2b-ffcb-64e7e32147bb"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 9 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import matplotlib.pyplot as plt\n","\n","for i in range(9):\n","\tplt.subplot(330 + 1 + i)\n","\tplt.imshow(x_train[i], cmap=plt.get_cmap('gray'))\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"uGZkLxinEN6L"},"source":["## Data normalization\n","\n","The pixel values for each image in the dataset are unsigned integers in the range between black and white, or 0 and 255.\n","\n","**Let us normalize the pixel values of grayscale images, e.g. rescale them to the range [0,1].**\n","\n","*Hint: 'astype' is a numpy function that could be used to cast the numpy array to a specified type*"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":27,"status":"ok","timestamp":1667911206844,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"iODdnwlH0xyw","outputId":"efa69997-f582-42b4-acb7-485eebd2c334"},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 28, 28)\n","(10000, 28, 28)\n"]}],"source":["x_train = x_train.astype(\"float32\") / 255\n","x_test = x_test.astype(\"float32\") / 255\n","\n","print(x_train.shape)\n","print(x_test.shape)"]},{"cell_type":"markdown","metadata":{"id":"-AK7-4arKNF9"},"source":["## Preparing data\n","The images are all pre-aligned (e.g. each image only contains a hand-drawn digit) and they have the same square size of 28×28 pixels. Also, the images are grayscale. Therefore, we can load the images and reshape the data arrays to have a 1D vector data.\n","\n","*Note that this data preparation is not applicable for all networks*\n","\n","**Let us reshape the images as a 1D vector.**"]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":17,"status":"ok","timestamp":1667911206844,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"mQWNj20I0_-w","outputId":"33462816-0307-4d36-8f47-3b682f514bd9"},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 784)\n","(10000, 784)\n"]}],"source":["x_train = x_train.reshape(60000, 784)\n","x_test = x_test.reshape(10000, 784)\n","\n","print(x_train.shape)\n","print(x_test.shape)"]},{"cell_type":"markdown","metadata":{"id":"3yNN4gs-LOmS"},"source":["## Preparing labels\n","\n","The labels for each input data (remember that in our case they are numbers between 0 and 9) indicate which digit represents the image, that is, to which class it is associated. \n","\n","In this case, we will represent this label with a vector of 10 positions, where the position corresponding to the digit that represents the image contains a 1 and the remaining positions of the vector contain the value 0. This is known as **one-hot encoding.**\n","\n","**Let us convert the labels into the equivalent one-hot encoded form.**\n","\n","*Hint: keras.utils.to_categorical could be used to convert an integer vector to a binary class matrix.*"]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":13,"status":"ok","timestamp":1667911206845,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"hRBa1_PA1KBX","outputId":"4cdebfba-91f1-4384-80b8-c1d9afdc1cce"},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 10)\n","(10000, 10)\n"]}],"source":["from tensorflow.keras.utils import to_categorical\n","\n","y_train = to_categorical(y_train, num_classes=10)\n","y_test = to_categorical(y_test, num_classes=10)\n","\n","print(y_train.shape)\n","print(y_test.shape)"]},{"cell_type":"markdown","metadata":{"id":"dfEBWzOpOmP7"},"source":["# **Defining Model**\n","\n","The Sequential class of the Keras library is a wrapper for the sequential neural network model. In this case, the model in Keras is considered as a sequence of layers and each of them gradually “distills” the input data to obtain the desired output. \n","\n","In Keras we can find all the required types of layers that can be easily added to the model through the add() method. \n","\n","Below snippet shows a simple network with a single dense layer. \n","\n","*Note that the input information has to be defined in the first layer of the model.* "]},{"cell_type":"code","execution_count":7,"metadata":{"executionInfo":{"elapsed":2911,"status":"ok","timestamp":1667911209748,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"KjW4xAFaP1KG"},"outputs":[{"name":"stderr","output_type":"stream","text":["/Users/joaorochaemelo/code/IH/venv_ironhack/lib/python3.11/site-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n","  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"]}],"source":["from tensorflow.keras.models import Sequential\n","from tensorflow.keras.layers import Dense, Activation\n","\n","model = Sequential()\n","model.add(Dense(10, input_dim=784))\n","model.add(Activation('relu'))"]},{"cell_type":"markdown","metadata":{"id":"wqxvLQf6QSv1"},"source":["The architecture of the model can be checked using the function **summary()** available in the model class. Note that the summary returns the layer information along with the output shape for each layer and the number of parameters that needs to be trained.\n","\n","In this simple example, it indicates that 7,850 parameters are required (column Param #). In the first layer, for each neuron i (between 0 and 9) we require 784 parameters for the weights wij and therefore 10×784 parameters to store the weights of the 10 neurons. In addition to that 10 additional parameters for the 10 bj biases corresponding to each one of them.\n","\n","The non-trainable parameters of a model are those that will not be updating and optimized during training, and that have to be defined a priori, or passed as inputs. "]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":14,"status":"ok","timestamp":1667911209748,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"8mktMmmURAfb","outputId":"5c0083b1-9029-4993-bb01-e596ea4243db"},"outputs":[{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n","</pre>\n"],"text/plain":["\u001b[1mModel: \"sequential\"\u001b[0m\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n","┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n","┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n","│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">7,850</span> │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ activation (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>)         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n","└─────────────────────────────────┴────────────────────────┴───────────────┘\n","</pre>\n"],"text/plain":["┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n","┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n","┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n","│ dense (\u001b[38;5;33mDense\u001b[0m)                   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)             │         \u001b[38;5;34m7,850\u001b[0m │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ activation (\u001b[38;5;33mActivation\u001b[0m)         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)             │             \u001b[38;5;34m0\u001b[0m │\n","└─────────────────────────────────┴────────────────────────┴───────────────┘\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">7,850</span> (30.66 KB)\n","</pre>\n"],"text/plain":["\u001b[1m Total params: \u001b[0m\u001b[38;5;34m7,850\u001b[0m (30.66 KB)\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">7,850</span> (30.66 KB)\n","</pre>\n"],"text/plain":["\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m7,850\u001b[0m (30.66 KB)\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n","</pre>\n"],"text/plain":["\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"]},"metadata":{},"output_type":"display_data"}],"source":["model.summary()"]},{"cell_type":"markdown","metadata":{"id":"sqHk3fztYFjs"},"source":["# Compiling models\n","\n","Before training a model, we need to configure the learning process, which is done via the compile method. It receives three arguments:\n","\n","*   Loss function\n","*   Optimizer\n","*   Metrics\n","\n","**Hint: Learn the commonly used loss functions and optimizers available in Keras documentation.**"]},{"cell_type":"code","execution_count":9,"metadata":{"executionInfo":{"elapsed":3,"status":"ok","timestamp":1667911209748,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"aVdNIBmv102V"},"outputs":[],"source":["model.compile(loss='categorical_crossentropy',\n","              optimizer='sgd',\n","              metrics = ['accuracy'])"]},{"cell_type":"markdown","metadata":{"id":"ktS7_-13ZSfp"},"source":["## Training models\n","\n","Keras models are trained on Numpy arrays of input data and labels. For training a model, we will typically use the fit function."]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4522,"status":"ok","timestamp":1667911571874,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"gCpox6Oa19c9","outputId":"7a4b0450-d509-4055-fbde-5f1c7efed2f4"},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 1/5\n","\u001b[1m59/59\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - accuracy: 0.2467 - loss: 2.7808\n","Epoch 2/5\n","\u001b[1m59/59\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - accuracy: 0.6458 - loss: 1.3922\n","Epoch 3/5\n","\u001b[1m59/59\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - accuracy: 0.2544 - loss: nan  \n","Epoch 4/5\n","\u001b[1m59/59\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - accuracy: 0.1003 - loss: nan\n","Epoch 5/5\n","\u001b[1m59/59\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - accuracy: 0.0991 - loss: nan\n"]}],"source":["history = model.fit(x_train, y_train, batch_size=1024, epochs=5)"]},{"cell_type":"markdown","metadata":{"id":"ViagI49FvTmo"},"source":["## History Callback\n","\n","A callback is a set of functions to be applied at given stages of the training procedure. It can be used to get a view on internal states and statistics of the model during training. There are several callbacks are available in Keras and they are passed as a list of callbacks to the .fit() method.\n","\n","The History object gets returned by the fit method of models and is automatically applied to every Keras model."]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4,"status":"ok","timestamp":1667911577443,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"bPsnRowdMT1P","outputId":"625c243e-348f-45f1-9d56-3a5f77afe431"},"outputs":[{"name":"stdout","output_type":"stream","text":["dict_keys(['accuracy', 'loss'])\n"]}],"source":["print(history.history.keys())"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3,"status":"ok","timestamp":1667911579844,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"sJFu3XH8nV6G","outputId":"03358a6d-0354-4c32-935b-03b73c295c35"},"outputs":[{"name":"stdout","output_type":"stream","text":["[2.0577547550201416, 1.327634334564209, nan, nan, nan]\n","[0.3860333263874054, 0.6674500107765198, 0.1434333324432373, 0.09871666878461838, 0.09871666878461838]\n"]}],"source":["print(history.history['loss']) # returns the loss value at the end of each epoch\n","print(history.history['accuracy']) # returns the accuracy at the end of each epoch"]},{"cell_type":"markdown","metadata":{"id":"leHvxD0twlKs"},"source":["**Let us plot the loss values and the accuracy values as a 2 x 1 plot.**\n","\n","Note that the loss term decreases and the accuracy increases with respect to the epochs."]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":281},"executionInfo":{"elapsed":671,"status":"ok","timestamp":1667911582483,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"lX6vd-n7wjmd","outputId":"9d150af3-f6a1-42a7-92e5-894854dfe3dd"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["plt.subplot(211)\n","plt.title('Cross Entropy Loss')\n","plt.plot(history.history['loss'], color='blue', label='train')\n","\n","plt.subplot(212)\n","plt.title('Classification Accuracy')\n","plt.plot(history.history['accuracy'], color='green', label='train')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"Pk0HXuQxaNvS"},"source":["# **Model evaluation**\n","\n","## Accuracy\n","\n","After training the model, the network has to be evaluated with new test data. This can be achieved by using the evaluate() method.\n","\n","**Let us print the test accuracy of the network.**"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1747,"status":"ok","timestamp":1667911595319,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"1Xmdv_Ql3UbR","outputId":"10f4ab3e-162a-4ed6-b6dd-3e363e952915"},"outputs":[{"name":"stdout","output_type":"stream","text":["\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 940us/step - accuracy: 0.0924 - loss: nan\n","Test loss: nan\n","Test accuracy: 0.09799999743700027\n"]}],"source":["test_loss, test_acc = model.evaluate(x_test, y_test)\n","print('Test loss:', test_loss)\n","print('Test accuracy:', test_acc)"]},{"cell_type":"markdown","metadata":{"id":"7FWrHB8S5-Pb"},"source":["## Confusion matrix\n","\n","Note that accuracy is the ratio between the correct predictions that the model has made over the total predictions regardless of what category it is. However, it is necessary to delve a little more and take into account the types of correct and incorrect predictions made by the model in each of its categories.\n","\n","For this purpose, a confusion matrix is used. It is a table with rows and columns that count the predictions in comparison with the real values. This is used to better understand how well the model behaves and it is very useful to show explicitly when one class is confused with another.\n","\n","**Hint:**\n","1.   predict() is used to predict the output for the input samples.\n","2.   confusion_matrix is available in sklearn.metrics"]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1125,"status":"ok","timestamp":1667911601209,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"RXwGXfi6i2qm","outputId":"a8127473-f3f4-45ed-b1c4-8aec5b37e71b"},"outputs":[{"name":"stdout","output_type":"stream","text":["\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 937us/step\n"]}],"source":["predictions = model.predict(x_test)"]},{"cell_type":"markdown","metadata":{"id":"FKjrVaeeDyEL"},"source":["It has to be noted that the predictions is the probability of the input belonging to any one of the class."]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":414,"status":"ok","timestamp":1667911605201,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"p7fyPS7LD058","outputId":"c29b39ff-4db3-42cc-85ba-e755d67c1d1d"},"outputs":[{"name":"stdout","output_type":"stream","text":["[nan nan nan nan nan nan nan nan nan nan]\n"]}],"source":["print(predictions[0])"]},{"cell_type":"markdown","metadata":{"id":"CIvCcFe0EKFE"},"source":["**Now, let us convert the probability distribution to get single output for each input. For this, we would take the maximum probability score.**"]},{"cell_type":"code","execution_count":17,"metadata":{"executionInfo":{"elapsed":2,"status":"ok","timestamp":1667911605201,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"wFAtFDzOlFXn"},"outputs":[],"source":["import numpy as np\n","predictions = np.argmax(predictions, axis=1)"]},{"cell_type":"code","execution_count":18,"metadata":{"executionInfo":{"elapsed":4,"status":"ok","timestamp":1667911606342,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"EApByl7wlk5a"},"outputs":[],"source":["from sklearn.metrics import confusion_matrix\n","gt = np.argmax(y_test, axis=1)"]},{"cell_type":"markdown","metadata":{"id":"uZR9oEl-E4yD"},"source":["**Now, we will use the confusion matrix function to get the table for all the 10 classes.**"]},{"cell_type":"code","execution_count":19,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3,"status":"ok","timestamp":1667911609436,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"SMyihJtbmVQO","outputId":"771446e0-e0e6-4952-8a45-3155597f914d"},"outputs":[{"data":{"text/plain":["array([[ 980,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [1135,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [1032,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [1010,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [ 982,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [ 892,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [ 958,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [1028,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [ 974,    0,    0,    0,    0,    0,    0,    0,    0,    0],\n","       [1009,    0,    0,    0,    0,    0,    0,    0,    0,    0]])"]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["confusion_matrix(gt, predictions)"]},{"cell_type":"markdown","metadata":{"id":"UPmsnSf7oJEO"},"source":["# **Defining different models**\n","\n","In the previous example, we designed a neural network with just dense layers. But in practice, the deep networks are more wider and deeper.\n","\n","When we define a model, the shallow layers learn the low level features such as edges and as the networks go deeper, the network learns the high level features. \n","The model, in general, has two main aspects: the feature extraction front end comprised of convolutional and pooling layers, and the classifier backend that will make a prediction.\n","\n","**Define the following model:** \n","\n","**For the convolutional front-end, start with a single convolutional layer with a small filter size (3,3) and a modest number of filters (32) followed by a max pooling layer. Use the input as (28,28,1) instead of (784,). The filter maps can then be flattened to provide features to the classifier. Use a dense layer with 100 units before the classification layer (which is also a dense layer with softmax activation).**\n","\n","*Hint: Conv2D, MaxPooling2D, Flatten, Dense and other layers can be obtained by importing keras.layer*"]},{"cell_type":"code","execution_count":20,"metadata":{"executionInfo":{"elapsed":434,"status":"ok","timestamp":1667911614333,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"1jZHNMZCn-ps"},"outputs":[{"name":"stderr","output_type":"stream","text":["/Users/joaorochaemelo/code/IH/venv_ironhack/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n","  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"]}],"source":["from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense\n","model = Sequential()\n","model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', input_shape=(28, 28, 1)))\n","model.add(MaxPooling2D((2, 2)))\n","model.add(Flatten())\n","model.add(Dense(100, activation='relu', kernel_initializer='he_uniform'))\n","model.add(Dense(10, activation='softmax'))"]},{"cell_type":"markdown","metadata":{"id":"fO3aLXZUJQe1"},"source":["**Let us check the architecture using summary().**"]},{"cell_type":"code","execution_count":21,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":13,"status":"ok","timestamp":1667911614961,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"6Y0CAn2DJWec","outputId":"f5e95059-8702-4f02-b681-2c589b262b39"},"outputs":[{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_1\"</span>\n","</pre>\n"],"text/plain":["\u001b[1mModel: \"sequential_1\"\u001b[0m\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n","┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n","┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n","│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │           <span style=\"color: #00af00; text-decoration-color: #00af00\">320</span> │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ max_pooling2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">13</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">13</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">5408</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>)            │       <span style=\"color: #00af00; text-decoration-color: #00af00\">540,900</span> │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,010</span> │\n","└─────────────────────────────────┴────────────────────────┴───────────────┘\n","</pre>\n"],"text/plain":["┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n","┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n","┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n","│ conv2d (\u001b[38;5;33mConv2D\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m26\u001b[0m, \u001b[38;5;34m26\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │           \u001b[38;5;34m320\u001b[0m │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m)    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ flatten (\u001b[38;5;33mFlatten\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5408\u001b[0m)           │             \u001b[38;5;34m0\u001b[0m │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m)            │       \u001b[38;5;34m540,900\u001b[0m │\n","├─────────────────────────────────┼────────────────────────┼───────────────┤\n","│ dense_2 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)             │         \u001b[38;5;34m1,010\u001b[0m │\n","└─────────────────────────────────┴────────────────────────┴───────────────┘\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">542,230</span> (2.07 MB)\n","</pre>\n"],"text/plain":["\u001b[1m Total params: \u001b[0m\u001b[38;5;34m542,230\u001b[0m (2.07 MB)\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">542,230</span> (2.07 MB)\n","</pre>\n"],"text/plain":["\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m542,230\u001b[0m (2.07 MB)\n"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n","</pre>\n"],"text/plain":["\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"]},"metadata":{},"output_type":"display_data"}],"source":["model.summary()"]},{"cell_type":"markdown","metadata":{"id":"SKsSmt7wJa83"},"source":["**Compile the model.**"]},{"cell_type":"code","execution_count":22,"metadata":{"executionInfo":{"elapsed":2,"status":"ok","timestamp":1667911617274,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"u3fm1gyXor98"},"outputs":[],"source":["model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])"]},{"cell_type":"markdown","metadata":{"id":"oesI8fU5KPik"},"source":["**Reshape the input of the mnist dataset to the new input dimensions (28, 28, 1).**"]},{"cell_type":"code","execution_count":23,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":421,"status":"ok","timestamp":1667911621326,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"UNECu5UvpT4f","outputId":"c4993416-c5e8-4121-c79a-b0d7817693c1"},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 28, 28)\n","3\n","uint8\n","(10000, 28, 28)\n","After reshaping:\n","(60000, 28, 28, 1)\n","4\n","float32\n","(10000, 28, 28, 1)\n","(60000, 10)\n","(10000, 10)\n"]}],"source":["from tensorflow.keras.datasets import mnist\n","from tensorflow.keras.utils import to_categorical\n","\n","(x_train, y_train), (x_test, y_test) = mnist.load_data()\n","\n","print(x_train.shape)\n","print(x_train.ndim)\n","print(x_train.dtype)\n","print(x_test.shape)\n","\n","x_train = x_train.astype(\"float32\") / 255\n","x_test = x_test.astype(\"float32\") / 255\n","\n","print('After reshaping:')\n","\n","x_train = np.expand_dims(x_train, -1)\n","x_test = np.expand_dims(x_test, -1)\n","\n","print(x_train.shape)\n","print(x_train.ndim)\n","print(x_train.dtype)\n","print(x_test.shape)\n","\n","y_train = to_categorical(y_train, num_classes=10)\n","y_test = to_categorical(y_test, num_classes=10)\n","\n","print(y_train.shape)\n","print(y_test.shape)"]},{"cell_type":"markdown","metadata":{"id":"ALGpoYHkKmda"},"source":["**Train the model for 10 epochs with a batch size of 100.**"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":22133,"status":"ok","timestamp":1667911647884,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"e_aADgN6o8da","outputId":"41341445-9886-43f2-e0ce-43ad1420ea15"},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 1/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 331ms/step - accuracy: 0.5810 - loss: 1.5300 - val_accuracy: 0.8882 - val_loss: 0.5500\n","Epoch 2/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 387ms/step - accuracy: 0.8627 - loss: 0.5763 - val_accuracy: 0.9073 - val_loss: 0.3870\n","Epoch 3/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 413ms/step - accuracy: 0.8853 - loss: 0.4377 - val_accuracy: 0.9167 - val_loss: 0.3271\n","Epoch 4/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 380ms/step - accuracy: 0.8954 - loss: 0.3893 - val_accuracy: 0.9225 - val_loss: 0.2941\n","Epoch 5/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 372ms/step - accuracy: 0.9027 - loss: 0.3528 - val_accuracy: 0.9288 - val_loss: 0.2720\n","Epoch 6/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 373ms/step - accuracy: 0.9065 - loss: 0.3308 - val_accuracy: 0.9327 - val_loss: 0.2558\n","Epoch 7/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 371ms/step - accuracy: 0.9115 - loss: 0.3145 - val_accuracy: 0.9350 - val_loss: 0.2436\n","Epoch 8/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 375ms/step - accuracy: 0.9140 - loss: 0.3043 - val_accuracy: 0.9368 - val_loss: 0.2343\n","Epoch 9/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 373ms/step - accuracy: 0.9168 - loss: 0.2905 - val_accuracy: 0.9397 - val_loss: 0.2257\n","Epoch 10/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 375ms/step - accuracy: 0.9201 - loss: 0.2837 - val_accuracy: 0.9417 - val_loss: 0.2169\n","Epoch 11/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 386ms/step - accuracy: 0.9245 - loss: 0.2662 - val_accuracy: 0.9437 - val_loss: 0.2103\n","Epoch 12/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 371ms/step - accuracy: 0.9247 - loss: 0.2643 - val_accuracy: 0.9457 - val_loss: 0.2049\n","Epoch 13/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 404ms/step - accuracy: 0.9275 - loss: 0.2536 - val_accuracy: 0.9473 - val_loss: 0.1993\n","Epoch 14/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 378ms/step - accuracy: 0.9285 - loss: 0.2532 - val_accuracy: 0.9467 - val_loss: 0.1950\n","Epoch 15/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 372ms/step - accuracy: 0.9313 - loss: 0.2440 - val_accuracy: 0.9492 - val_loss: 0.1903\n","Epoch 16/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 404ms/step - accuracy: 0.9337 - loss: 0.2328 - val_accuracy: 0.9502 - val_loss: 0.1852\n","Epoch 17/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 364ms/step - accuracy: 0.9335 - loss: 0.2340 - val_accuracy: 0.9512 - val_loss: 0.1819\n","Epoch 18/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 377ms/step - accuracy: 0.9345 - loss: 0.2308 - val_accuracy: 0.9525 - val_loss: 0.1775\n","Epoch 19/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 402ms/step - accuracy: 0.9367 - loss: 0.2238 - val_accuracy: 0.9528 - val_loss: 0.1743\n","Epoch 20/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 367ms/step - accuracy: 0.9359 - loss: 0.2212 - val_accuracy: 0.9550 - val_loss: 0.1708\n","Epoch 21/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 386ms/step - accuracy: 0.9396 - loss: 0.2094 - val_accuracy: 0.9530 - val_loss: 0.1684\n","Epoch 22/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 415ms/step - accuracy: 0.9409 - loss: 0.2091 - val_accuracy: 0.9548 - val_loss: 0.1655\n","Epoch 23/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 387ms/step - accuracy: 0.9407 - loss: 0.2077 - val_accuracy: 0.9583 - val_loss: 0.1619\n","Epoch 24/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 360ms/step - accuracy: 0.9414 - loss: 0.2053 - val_accuracy: 0.9580 - val_loss: 0.1588\n","Epoch 25/25\n","\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 381ms/step - accuracy: 0.9423 - loss: 0.2016 - val_accuracy: 0.9578 - val_loss: 0.1570\n"]}],"source":["history = model.fit(x_train, y_train, batch_size=1024, epochs=25, validation_split=0.1)"]},{"cell_type":"code","execution_count":25,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":526,"status":"ok","timestamp":1667911651261,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"7c8ezZ4OPOz3","outputId":"d0ad38d0-418e-4331-b4d9-f0169d86c295"},"outputs":[{"name":"stdout","output_type":"stream","text":["dict_keys(['accuracy', 'loss', 'val_accuracy', 'val_loss'])\n"]}],"source":["print(history.history.keys())"]},{"cell_type":"markdown","metadata":{"id":"mY4Lh9ILXj66"},"source":["**Plot the loss function and the accuracy curves as before.**"]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":281},"executionInfo":{"elapsed":5,"status":"ok","timestamp":1667911653349,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"_yHkKxn9XsTR","outputId":"27479534-eab4-4760-f399-246841b8eebc"},"outputs":[{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAjEAAAGzCAYAAADe/0a6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABuJElEQVR4nO3deVxU5eI/8M/MyAw7iOyIIJhbLhgKuaZXrmjm1bJyKUVKu+VyS8rSUtHKSPvmj1K7mtfSSsslq1uWZaR1VdTEzDRFwQVcAEEBWQdmnt8fpxkYGJaBGYbl8369nteceeacM88cp+bDc57zHJkQQoCIiIiohZFbuwFEREREDcEQQ0RERC0SQwwRERG1SAwxRERE1CIxxBAREVGLxBBDRERELRJDDBEREbVIDDFERETUIjHEEBERUYvEEENEREQtEkMMkZWkpqbin//8J4KCgmBrawtnZ2cMHjwY77zzDoqLi63dvHpZtmwZZDJZjSUjI8PkfW7btg3x8fHmb2wTCgwMxAMPPGDtZhC1eu2s3QCitmjPnj145JFHoFKpMH36dPTq1QtqtRoHDx7EggULcObMGbz//vvWbma9/fvf/4ajo2O1eldXV5P3tW3bNpw+fRrPPfdc4xtGRK0aQwxRE7t06RImT56MgIAA/PTTT/Dx8dG/NmfOHKSkpGDPnj01bq/VaqFWq2Fra9sUza2Xhx9+GO7u7k3+viUlJVAqlZDL2alM1Bbxv3yiJrZq1SoUFBRg06ZNBgFGp0uXLnj22Wf1z2UyGebOnYutW7fi7rvvhkqlwt69ewEAv/32G8aMGQNnZ2c4Ojpi5MiROHLkiMH+ysrKsHz5ctx1112wtbVFhw4dMGTIEOzbt0+/TkZGBqKjo9GxY0eoVCr4+Phg/PjxuHz5slk+84EDByCTybBjxw6sWLECHTt2hK2tLUaOHImUlBT9esOHD8eePXtw5coV/SmpwMBAg3189tlnWLx4Mfz8/GBvb4/8/HwAwM6dOxEaGgo7Ozu4u7vj8ccfx7Vr1wzaMWPGDDg6OuLixYuIjIyEg4MDfH198eqrr0IIAQAQQiAwMBDjx4+v9jlKSkrg4uKCf/7zn40+JuXl5XjttdcQHBwMlUqFwMBAvPzyyygtLTVY7/jx44iMjIS7uzvs7OzQuXNnPPHEEwbrfPbZZwgNDYWTkxOcnZ3Ru3dvvPPOO41uI1Fzx54Yoib29ddfIygoCIMGDar3Nj/99BN27NiBuXPnwt3dHYGBgThz5gyGDh0KZ2dnvPjii7CxscGGDRswfPhw/PzzzwgPDwcgjVuJi4vDzJkzERYWhvz8fBw/fhwnTpzA3//+dwDAxIkTcebMGcybNw+BgYHIysrCvn37kJaWpg8Rtbl161a1unbt2lU7nfTmm29CLpfjhRdeQF5eHlatWoXHHnsMR48eBQC88soryMvLw9WrV/H//t//A4Bqp6lee+01KJVKvPDCCygtLYVSqcTmzZsRHR2NAQMGIC4uDpmZmXjnnXdw6NAh/Pbbbwbt0Gg0GD16NO69916sWrUKe/fuRWxsLMrLy/Hqq69CJpPh8ccfx6pVq3Dr1i24ubnpt/3666+Rn5+Pxx9/vM5jUpeZM2diy5YtePjhh/H888/j6NGjiIuLw9mzZ/HFF18AALKysjBq1Ch4eHhg4cKFcHV1xeXLl7F79279fvbt24cpU6Zg5MiRWLlyJQDg7NmzOHTokEEYJmqVBBE1mby8PAFAjB8/vt7bABByuVycOXPGoH7ChAlCqVSK1NRUfd3169eFk5OTGDZsmL6ub9++YuzYsTXu//bt2wKAeOutt+r/Qf4SGxsrABgt3bp106+3f/9+AUD06NFDlJaW6uvfeecdAUD88ccf+rqxY8eKgICAau+l20dQUJAoKirS16vVauHp6Sl69eoliouL9fXffPONACCWLl2qr4uKihIAxLx58/R1Wq1WjB07ViiVSnHz5k0hhBDJyckCgPj3v/9t0IZ//OMfIjAwUGi12lqPS0BAQK3H/OTJkwKAmDlzpkH9Cy+8IACIn376SQghxBdffCEAiF9//bXGfT377LPC2dlZlJeX19omotaIp5OImpDu1IeTk5NJ2913333o2bOn/rlGo8EPP/yACRMmICgoSF/v4+ODqVOn4uDBg/r3cnV1xZkzZ3DhwgWj+7azs4NSqcSBAwdw+/ZtUz8SAODzzz/Hvn37DMqHH35Ybb3o6GgolUr986FDhwIALl68WO/3ioqKgp2dnf758ePHkZWVhdmzZxuMExo7diy6d+9udHzR3Llz9cu603VqtRo//vgjAKBr164IDw/H1q1b9evdunUL3333HR577DHIZLJ6t9eYb7/9FgAQExNjUP/8888DgL7Nuh6kb775BmVlZUb35erqisLCQoPTg0RtBUMMURNydnYGANy5c8ek7Tp37mzw/ObNmygqKkK3bt2qrdujRw9otVqkp6cDAF599VXk5uaia9eu6N27NxYsWIBTp07p11epVFi5ciW+++47eHl5YdiwYVi1apVJl0cPGzYMERERBmXgwIHV1uvUqZPB8/bt2wOASeGp6rG4cuUKABg9Ft27d9e/riOXyw2CHyCFFgAGY4CmT5+OQ4cO6bffuXMnysrKMG3atHq3tSZXrlyBXC5Hly5dDOq9vb3h6uqqf8/77rsPEydOxPLly+Hu7o7x48fjww8/NBg3M3v2bHTt2hVjxoxBx44d8cQTT+jHTBG1dgwxRE3I2dkZvr6+OH36tEnbVe55MNWwYcOQmpqKDz74AL169cJ//vMf3HPPPfjPf/6jX+e5557D+fPnERcXB1tbWyxZsgQ9evTAb7/91uD3NUahUBitF38Nqq2PxhwLU0yePBk2Njb63phPPvkE/fv3NxqWGqquHh2ZTIZdu3YhMTERc+fOxbVr1/DEE08gNDQUBQUFAABPT0+cPHkS//3vf/GPf/wD+/fvx5gxYxAVFWW2dhI1VwwxRE3sgQceQGpqKhITExu8Dw8PD9jb2yM5Obnaa+fOnYNcLoe/v7++zs3NDdHR0fj000+Rnp6OPn36YNmyZQbbBQcH4/nnn8cPP/yA06dPQ61W4+23325wGxvK1FM1AQEBAGD0WCQnJ+tf19FqtdVOX50/fx4ADAYxu7m5YezYsdi6dSuuXLmCQ4cOmaUXRtdmrVZb7RRfZmYmcnNzq7X53nvvxYoVK3D8+HFs3boVZ86cwWeffaZ/XalUYty4cXjvvff0kyh+9NFHBld+EbVGDDFETezFF1+Eg4MDZs6ciczMzGqvp6am1nl5rEKhwKhRo/DVV18ZnALJzMzEtm3bMGTIEP2pq5ycHINtHR0d0aVLF/0piaKiIpSUlBisExwcDCcnp2qX+zYFBwcH5OXl1Xv9/v37w9PTE+vXrzdo73fffYezZ89i7Nix1bZZu3atflkIgbVr18LGxgYjR440WG/atGn4888/sWDBAigUCkyePLkBn6i6+++/HwCqzUy8evVqANC3+fbt29V6qUJCQgBA/1mr/vvK5XL06dPHYB2i1oqXWBM1seDgYGzbtg2TJk1Cjx49DGbsPXz4MHbu3IkZM2bUuZ/XX38d+/btw5AhQzB79my0a9cOGzZsQGlpKVatWqVfr2fPnhg+fDhCQ0Ph5uaG48ePY9euXfrBrefPn8fIkSPx6KOPomfPnmjXrh2++OILZGZm1vtHe9euXUZn7P373/8OLy+v+h2Yv4SGhmL79u2IiYnBgAED4OjoiHHjxtW4vo2NDVauXIno6Gjcd999mDJliv4S68DAQMyfP99gfVtbW+zduxdRUVEIDw/Hd999hz179uDll1+Gh4eHwbpjx45Fhw4dsHPnTowZMwaenp71/hwpKSl4/fXXq9X369cPY8eORVRUFN5//33k5ubivvvuw7Fjx7BlyxZMmDABI0aMAABs2bIF7733Hh588EEEBwfjzp072LhxI5ydnfVBaObMmbh16xb+9re/oWPHjrhy5QrWrFmDkJAQ9OjRo97tJWqRrHx1FFGbdf78eTFr1iwRGBgolEqlcHJyEoMHDxZr1qwRJSUl+vUAiDlz5hjdx4kTJ0RkZKRwdHQU9vb2YsSIEeLw4cMG67z++usiLCxMuLq6Cjs7O9G9e3exYsUKoVarhRBCZGdnizlz5oju3bsLBwcH4eLiIsLDw8WOHTvq/Ay1XWINQOzfv18IUXF59M6dOw22v3TpkgAgPvzwQ31dQUGBmDp1qnB1dRUA9Jdb17QPne3bt4t+/foJlUol3NzcxGOPPSauXr1qsE5UVJRwcHAQqampYtSoUcLe3l54eXmJ2NhYodFojO539uzZAoDYtm1bncdDJyAgoMZj8uSTTwohhCgrKxPLly8XnTt3FjY2NsLf318sWrTI4N/+xIkTYsqUKaJTp05CpVIJT09P8cADD4jjx4/r19m1a5cYNWqU8PT0FEqlUnTq1En885//FDdu3Kh3e4laKpkQJoyoIyJqwWbMmIFdu3bpB8XWx/z587Fp0yZkZGTA3t7egq0jIlNxTAwRUQ1KSkrwySefYOLEiQwwRM0Qx8QQEVWRlZWFH3/8Ebt27UJOTg6n7ydqphhiiIiq+PPPP/HYY4/B09MT7777rv6KICJqXjgmhoiIiFokjokhIiKiFokhhoiIiFqkVjEmRqvV4vr163Bycmr03WWJiIioaQghcOfOHfj6+kIuN71fpVWEmOvXrxvcJ4aIiIhajvT0dHTs2NHk7VpFiHFycgIgHQTd/WKIiIioecvPz4e/v7/+d9xUrSLE6E4hOTs7M8QQERG1MA0dCsKBvURERNQiMcQQERFRi8QQQ0RERC0SQ0wtsrKAxx4DBg0COK8xERFR89IqBvZairMzsGMHUF4OpKcDnTpZu0VERESkw56YWtjaAr17S8vHj1u3LURERGSIIaYO/ftLjwwxREREzQtDTB10IebXX63bDiIiIjLEEFOHAQOkx+PHObiXiIioOWGIqUOvXoBKBeTmAhcvWrs1REREpMMQUwcbGyAkRFrmKSUiIqLmgyGmHji4l4iIqPlhiKkHhhgiIqLmhyGmHnSDe5OSAI3Gum0hIiIiCUNMPXTvDtjbAwUFwPnz1m4NERERAQwx9aJQAPfcIy1zcC8REVHzYPYQ88svv2DcuHHw9fWFTCbDl19+Wec2Bw4cwD333AOVSoUuXbpg8+bN5m5Wo1WeL4aIiIisz+whprCwEH379sW6devqtf6lS5cwduxYjBgxAidPnsRzzz2HmTNn4vvvvzd30xqFg3uJiIiaF7PfxXrMmDEYM2ZMvddfv349OnfujLfffhsA0KNHDxw8eBD/7//9P0RGRpq7eQ2mCzG//QaUlUnzxxAREZH1WH1MTGJiIiIiIgzqIiMjkZiYWOM2paWlyM/PNyiW1qUL4OIClJQAf/5p8bcjIiKiOlg9xGRkZMDLy8ugzsvLC/n5+SguLja6TVxcHFxcXPTF39/f4u2Uy4HQUGmZp5SIiIisz+ohpiEWLVqEvLw8fUlPT2+S9+UdrYmIiJoPs4+JMZW3tzcyMzMN6jIzM+Hs7Aw7Ozuj26hUKqhUqqZongFeoURERNR8WL0nZuDAgUhISDCo27dvHwYOHGilFtVM1xNz6hRQWmrdthAREbV1Zg8xBQUFOHnyJE6ePAlAuoT65MmTSEtLAyCdCpo+fbp+/aeffhoXL17Eiy++iHPnzuG9997Djh07MH/+fHM3rdECAoAOHaSrk06dsnZriIiI2jazh5jjx4+jX79+6NevHwAgJiYG/fr1w9KlSwEAN27c0AcaAOjcuTP27NmDffv2oW/fvnj77bfxn//8p1ldXq0jk/GUEhERUXNh9jExw4cPhxCixteNzcY7fPhw/Pbbb+ZuikX07w/s3csQQ0REZG1WHxPT0vAKJSIiouaBIcZEutNJZ84ARUXWbQsREVFbxhBjIl9fwMcH0GqBv8YuExERkRUwxDQATykRERFZH0NMA/AKJSIiIutjiGkAXU8MQwwREZH1MMQ0gC7EJCcDTXADbSIiIjKCIaYBPDyk2XuFAE6csHZriIiI2iaGmAbi4F4iIiLrYohpII6LISIisi6GmAbiFUpERETWxRDTQPfcIz1evAjk5Fi3LURERG0RQ0wDtW8PdOkiLSclWbctREREbRFDTCPwlBIREZH1MMQ0Aq9QIiIish6GmEZgTwwREZH1MMQ0Qr9+gEwGXL0KZGRYuzVERERtC0NMIzg6Aj16SMvsjSEiImpaDDGNxFNKRERE1sEQ00icuZeIiMg6GGIaqfIVSkJYty1ERERtCUNMI/XtC7RrB2RlSQN8iYiIqGlYLMSsW7cOgYGBsLW1RXh4OI4dO1br+vHx8ejWrRvs7Ozg7++P+fPno6SkxFLNMxs7O6BXL2mZp5SIiIiajkVCzPbt2xETE4PY2FicOHECffv2RWRkJLKysoyuv23bNixcuBCxsbE4e/YsNm3ahO3bt+Pll1+2RPPMjpPeERERNT2LhJjVq1dj1qxZiI6ORs+ePbF+/XrY29vjgw8+MLr+4cOHMXjwYEydOhWBgYEYNWoUpkyZUmPvTWlpKfLz8w2KNfEKJSIioqZn9hCjVquRlJSEiIiIijeRyxEREYHExESj2wwaNAhJSUn60HLx4kV8++23uP/++42uHxcXBxcXF33x9/c398cwSeUrlDi4l4iIqGmYPcRkZ2dDo9HAy8vLoN7LywsZNUxrO3XqVLz66qsYMmQIbGxsEBwcjOHDh9d4OmnRokXIy8vTl/T0dHN/DJP06gUolcDt28DFi1ZtChERUZvRLK5OOnDgAN544w289957OHHiBHbv3o09e/bgtddeM7q+SqWCs7OzQbEmpRIICZGWeUqJiIioaZg9xLi7u0OhUCAzM9OgPjMzE97e3ka3WbJkCaZNm4aZM2eid+/eePDBB/HGG28gLi4OWq3W3E20CA7uJSIialpmDzFKpRKhoaFISEjQ12m1WiQkJGDgwIFGtykqKoJcbtgUhUIBABAtZJAJZ+4lIiJqWu0ssdOYmBhERUWhf//+CAsLQ3x8PAoLCxEdHQ0AmD59Ovz8/BAXFwcAGDduHFavXo1+/fohPDwcKSkpWLJkCcaNG6cPM82d7gqlpCRAqwXkzeJEHRERUetlkRAzadIk3Lx5E0uXLkVGRgZCQkKwd+9e/WDftLQ0g56XxYsXQyaTYfHixbh27Ro8PDwwbtw4rFixwhLNs4ju3QF7e6CgAEhOrri7NREREVmGTLSU8zW1yM/Ph4uLC/Ly8qw6yHfIEODQIeCjj4Bp06zWDCIiohahsb/fPOlhRpz0joiIqOkwxJgRr1AiIiJqOgwxZqQLMb/9BpSXW7ctRERErR1DjBnddRfg7AyUlAB//mnt1hAREbVuDDFmJJcDoaHSMk8pERERWRZDjJlx0jsiIqKmwRBjZrxCiYiIqGkwxJiZrifm99+B0lLrtoWIiKg1Y4gxs8BAoEMHoKwM+OMPa7eGiIio9WKIMTOZjONiiIiImgJDjAVw0jsiIiLLY4ixAPbEEBERWR5DjAXorlA6cwYoKrJuW4iIiForhhgL8PUFvL0BjQY4edLarSEiImqdGGIsgIN7iYiILI8hxkJ0p5Q4uJeIiMgyGGIshD0xRERElsUQYyG6EJOcDOTnW7ctRERErRFDjIV4egKdOgFCACdOWLs1RERErQ9DjAXxlBIREZHlMMRYEO9oTUREZDkWCzHr1q1DYGAgbG1tER4ejmPHjtW6fm5uLubMmQMfHx+oVCp07doV3377raWa1yR4+wEiIiLLaWeJnW7fvh0xMTFYv349wsPDER8fj8jISCQnJ8PT07Pa+mq1Gn//+9/h6emJXbt2wc/PD1euXIGrq6slmtdkQkOlx4sXgVu3ADc367aHiIioNZEJIYS5dxoeHo4BAwZg7dq1AACtVgt/f3/MmzcPCxcurLb++vXr8dZbb+HcuXOwsbEx+f3y8/Ph4uKCvLw8ODs7N7r95nTXXUBKCvDDD8Df/27t1hARETUfjf39NvvpJLVajaSkJERERFS8iVyOiIgIJCYmGt3mv//9LwYOHIg5c+bAy8sLvXr1whtvvAGNRmN0/dLSUuTn5xuU5oqnlIiIiCzD7CEmOzsbGo0GXl5eBvVeXl7IyMgwus3Fixexa9cuaDQafPvtt1iyZAnefvttvP7660bXj4uLg4uLi774+/ub+2OYDa9QIiIisoxmcXWSVquFp6cn3n//fYSGhmLSpEl45ZVXsH79eqPrL1q0CHl5efqSnp7exC2uP16hREREZBlmH9jr7u4OhUKBzMxMg/rMzEx4e3sb3cbHxwc2NjZQKBT6uh49eiAjIwNqtRpKpdJgfZVKBZVKZe6mW0S/ftINIdPTgcxMoEoHFRERETWQ2XtilEolQkNDkZCQoK/TarVISEjAwIEDjW4zePBgpKSkQKvV6uvOnz8PHx+fagGmpXFyArp3l5bZG0NERGQ+FjmdFBMTg40bN2LLli04e/YsnnnmGRQWFiI6OhoAMH36dCxatEi//jPPPINbt27h2Wefxfnz57Fnzx688cYbmDNnjiWa1+R4SomIiMj8LDJPzKRJk3Dz5k0sXboUGRkZCAkJwd69e/WDfdPS0iCXV+Qnf39/fP/995g/fz769OkDPz8/PPvss3jppZcs0bwm178/8NFHvEKJiIjInCwyT0xTs+g8MeXl0mAWP78G7yIxERg0SBoPc+OGNEaGiIiorWt288S0KmlpwNChwOjRQElJg3cTEgIoFFIWunbNfM0jIiJqyxhiamNrK90z4PRpwMhMw/VlZwf06iUt85QSERGReTDE1MbTE9i8WVp+5x3g++8bvCtOekdERGReDDF1GTMGmDtXWp4xA7h5s0G70V2htH8/UMPdFIiIiMgEDDH1sWoV0LMnkJEBzJoFNGAs9IgRgFwuDfKdPLlRQ2yIiIgIDDH1Y2cHbNsGKJXAV18BGzeavIuuXYFPP5V2sWuXNFY4L88CbSUiImojGGLqq29f4I03pOX584Hz503exaOPAnv3SrP4/vwzMGwYcP26mdtJRETURjDEmGL+fGDkSKCoCJg6FVCrTd7FiBHAL78A3t7AqVPAwIHAuXMWaCsREVErxxBjCrkc2LIFcHMDkpKAZcsatJuQEGlsTNeu0lQ0Q4YAR46YtaVEREStHkOMqfz8gPffl5bffFPqVmmAwEDg4EEgLAzIyQH+9jdgzx7zNZOIiKi1Y4hpiIkTgSeekK5SevxxIDe3Qbvx8AB++km6iru4GBg/HvjwQ/M2lYiIqLViiGmod94BgoOB9HRg9uwG78bBQbrgKSpKmj/miSek8cMt/45WRERElsUQ01COjsDWrdJNkT79VFpuIBsbqQdm0SLp+SuvAPPmcVI8IiKi2jDENEZ4OBAbKy3Png1cvtzgXclkUg/Mu+9Ky+vWcVI8IiKi2jDENNaiRcDgwUB+vjQ+pry8UbubNw/47DNOikdERFQXhpjGatcO+PhjaQa7Q4ekK5YaiZPiERER1Y0hxhw6d5bO/wDS3DHHjjV6l5wUj4iIqHYMMeby+OPSIBaNBnjsMaCgoNG75KR4RERENWOIMReZDPj3vwF/fyAlBXjuObPslpPiERERGccQY06urtL4GJkM2LQJ2L3bLLvlpHhERETVMcSY2333AS+9JC3PmgVcu2aW3RqbFG/qVODwYU6MR0REbRNDjCUsXw6EhgK3bgEzZgBarVl2W3VSvE8/la7uvuce4D//kW6uTURE1FZYLMSsW7cOgYGBsLW1RXh4OI7V84qdzz77DDKZDBMmTLBU0yxPqZRm8LW3B378UbpFgZnoJsU7fhyIjgZsbYGTJ6VOHz8/YP584MIFs70dERFRs2WRELN9+3bExMQgNjYWJ06cQN++fREZGYmsrKxat7t8+TJeeOEFDB061BLNalrdugGrV0vLCxcCv/9u1t2HhgIffABcvQr83/8BQUHSfSjj46WrmSIjgf/+l7cuICKi1ksmhPlHVISHh2PAgAFYu3YtAECr1cLf3x/z5s3DwoULjW6j0WgwbNgwPPHEE/jf//6H3NxcfPnll/V6v/z8fLi4uCAvLw/Ozs7m+hiNJwQwYYKUJu6+G/j1V8DOziJvpdUC338vTVfz7bcV42Q6dQKefhqYOVMaIExERNRcNPb32+w9MWq1GklJSYiIiKh4E7kcERERSExMrHG7V199FZ6ennjyySfrfI/S0lLk5+cblGZJJpMGq3h7A2fOVAz4tQC5XLp66ZtvgNRU4MUXgQ4dpPllXn4Z6NgRmDZNmneGA4GJiKg1MHuIyc7OhkajgZeXl0G9l5cXMjIyjG5z8OBBbNq0CRs3bqzXe8TFxcHFxUVf/P39G91ui/HwqLgees0a4OuvLf6WnTsDK1dKp5o2b5bmmFGrgU8+AQYNkk5FbdrEgcBERNSyWf3qpDt37mDatGnYuHEj3N3d67XNokWLkJeXpy/p6ekWbmUjjR4N/Otf0vI//iHdHKkJ7iFgaytdkn30qHQma8YMQKUCfvtNOr3k5wfExHAgMBERtUxmHxOjVqthb2+PXbt2GVxhFBUVhdzcXHz11VcG6588eRL9+vWDQqHQ12n/uiRZLpcjOTkZwcHBtb5nsx0TU1lJCfDPf0qT4Qkhnf+ZNg1YulQaldtEcnKkAcH//jdw6VJFfdeu0mzAI0YAw4cDnp5N1iQiImqjmt2YGKVSidDQUCQkJOjrtFotEhISMHDgwGrrd+/eHX/88QdOnjypL//4xz8wYsQInDx5snmfKjKFrS2wZYt0ldKECdJI3C1bpKuYnnnGbJPi1aVDB2DBAunOCHv2APffL+Wp8+eB9euBSZMALy+gd2+p8+jLL4Hbt5ukaURERCaxyNVJ27dvR1RUFDZs2ICwsDDEx8djx44dOHfuHLy8vDB9+nT4+fkhLi7O6PYzZsxoHVcn1ebXX4HFi4EffpCe29oCs2dLl2M38WVEubnSHbP375dub3DqlOHrMhnQr5/US/O3vwFDhwJOTk3aRCIiaoUa+/vdzgJtwqRJk3Dz5k0sXboUGRkZCAkJwd69e/WDfdPS0iCXW304jnUNGCBdE/3LL8Arr0h3eVy9GtiwQbp55AsvSPdiagKurtJQnX/8Q3qenQ0cOFARas6dA06ckMrbbwMKhdR8XagZNEia14+IiKgpWaQnpqm1yJ6YyoSQemReeQVISpLqXF2lIPPss4Cjo1Wbd+OGFGh0JTXV8HWlErj3XinUDBsG9O0rnbYiIiKqTWN/vxlimhMhpEEoS5ZI88oA0qmlRYukcTO2tlZtnk5aWkUvzU8/SZdyV+XnB/TpIwUa3WPXrkA7i/T9ERFRS8QQg1YUYnQ0GmD7diA2VhqBC0ipYMkS6YZJSqV121eJEFLPjC7UHDsGXLxofF2VCujZsyLY6MJNPa+sJyKiVoYhBq0wxOiUlUlXML36KqCbC6dzZ2DZMuCxx6TBKc1Qfj5w+rR0IdapUxWloMD4+j4+hr02ffoA3btLd+0mIqLWiyEGrTjE6JSWAu+/D6xYAWRmSnU9egBPPCHda6BnT+kSomZMqwUuX5bCjC7c/P579fE1OjY20umnLl2Au+6SHnWlY8dmm9+IiMgEDDFoAyFGp7AQWLtWuqdA5clbOnWSwsyYMcDIkVYfCGyKggLjvTa13Q5LqQSCgw2DjS7s+Ptz3A0RUUvBEIM2FGJ08vKk00zffitdC11aWvGajY00kYsu1LSAXpqqhJB6bc6fl4YEXbggPaakSONtyspq3tbGRjrjVjnYdOkCBAZKAcfBoak+BRER1YUhBm0wxFRWVCQFmW+/Bb77rvqo2k6dpHs33X+/NKlLC5+lTqORhgdVDja6kppqmOeMad9eOiT+/hWPlZf9/DgWh4ioqTDEoI2HmMqEkH7dv/tOKq2wl6Y2Wq10uXfVcHPhgnRZeG2nqHRkMmmgsbGAo3v08JBu1UBERI3DEAOGmBrpeml0oabqKFpdL83o0dIUvH5+rSrUVJWXJ/XipKdLocbYslpd937atZPuL+XjA/j6So+6Uvm5pyfH5xAR1YYhBgwx9Va5l2b//urnXtzdpZskVS533dVmuh20WuDmTcNgUzXs3LghdXjVh1wuBZmaQo4u6Hh4SGN1WnF+JCIyiiEGDDENUrmX5sAB4OxZacBJVQ4O0gQulYPN3XdLM9e1QWVlQFaWFGauX5cedaXy88xM44ezJnZ2Upjx8KgINrU98l5VRNQaMMSAIcYsioula51/+62inDol1VfVrp00nqZysAkJAXjs9TQaqVfHWMDRPc/IkAJRSYnp+7e3Nww2Hh7S/arc3AwfKy/b27O3h4iaF4YYMMRYTHm5dJ1z5WDz22+Gc9RUFhwsTbdbdXY6P782c0rKVEJI0//cvCkFmvo81nUFVk1UKuPhpmr40ZX27aXC8ENElsIQA4aYJiWENDikarAxdhdIHZUKCAqqPjtdly7S4GKOfq03IYA7d6QwUznY3LwJ3LoF5ORUPFZerm1unboolVKYqRxs6rPcvn2bPetIRPXEEAOGmGYhO1sKM3/+KV0Fpbu++dIlqUenJu3aSTPRVQ03wcFSfTO5c3dLJoQ0M3JtIafy8q1bUmfb7du1/9PVh50d4OoKuLgYPta3jgOeiVo3hhgwxDRr5eVSz03lGelMmZ2uQwfpdFTl0rGj4XM3N/7SWYAu/Ny+bRhsdMu11eXl1f8qrtooFBWBxtlZWnZ2rnm5pteb0Y3fiagShhgwxLRYWi1w7ZrxgJOSIg0WqQ9b2+pBp2rg8fLiuY0mpNFIQSYvD8jNlYpuub51plzdVRdb24pg4+QkLTs51V2MradSMTMTmQtDDBhiWiUhpD/pr12TytWrFcuVS3Z2/ffp6FhxKY+7e8Vy1ee6ZWdn/lpZiRDSLACVg01+fsVj1eWaXqtvDjZFu3bVg42jo1R0y6bUOThw3Du1XQwxYIhp00pKpOuVjQUcXfC5fr1hI1ttbIyHG90lPcaKkxODTzNSXi4NhK4abu7cMSzG6qq+VlRkuXY6OEihRvdYddnU1xwcpPFIDEfU3DHEgCGG6iCE9Oulu4zn5k2pB6e25Yb+CW9jU3G9srt77YFHt0779rxCqwXQaKQxQpXDTUFBRV3lx/rWabWWbbO9vVR0wcbBoWHPK+9Ht2xnJ41ZImoMhhgwxJAFFBfXHHR0l/NULQ2ZtU6nfXvDYGPsseoyR6u2aEJIXxldKCoslIKN7rE+yzXVNRWVqnq4qSn0NKTY2Ulfc3Zutl7NNsSsW7cOb731FjIyMtC3b1+sWbMGYWFhRtfduHEjPvroI5w+fRoAEBoaijfeeKPG9atiiKFmoaioerDJzq459OTkSAM+GsrJqSLUuLlVjFyteqlOTY+cxa5V0mqlDF5YKH0lCwsNi7G62uqLi6XXdK8bm8TbkuRy4+HGzs5wubZS3/Xs7Ngp2tQa+/ttkX+u7du3IyYmBuvXr0d4eDji4+MRGRmJ5ORkeHp6Vlv/wIEDmDJlCgYNGgRbW1usXLkSo0aNwpkzZ+Dn52eJJhKZn+7/sP7+9d+mvNxwshZd6Kn6WHn51i3pl0r3J/ylSw1rr+765aoBp/IIVFOKnR1DUTMgl1ecCrIErVbqQdIFG124qfzcWH3VQGSs6F4vLKy4Ok2rrehtagrt2klXsxkLOPWp1y3b2tZv2c5O6tHiqbmGsUhPTHh4OAYMGIC1a9cCALRaLfz9/TFv3jwsXLiwzu01Gg3at2+PtWvXYvr06XWuz54YalO0WqkHp2qwqTxytfKjsUt7LDEYQyarPeTUdplOTcu2tgxGbVRZWc3BqLjYeNEFobpK1fUaeisPc7KxMQw5tRWVyrTXdc8r11ets9Zpu2bXE6NWq5GUlIRFixbp6+RyOSIiIpCYmFivfRQVFaGsrAxubm5GXy8tLUVppW9dfn5+4xpN1JLI5RU3OLrrLtO3192wyVjAycur+LO3PkU3EEO3X13vkLkoFBXBRndOoPJjfeuqvlZ5BKu9Pc8hNEM2NhVnRy1Nq5WCjLHAU1JS//qSkor6+ixXnhG7rEwq1vw5qxpsqj7a2wPff2+99hlj9v9ys7OzodFo4OXlZVDv5eWFc+fO1WsfL730Enx9fREREWH09bi4OCxfvrzRbSVqkyr3mJjjdK1uEEbVgKMbrdqQS3d01zNXnjXPkpTK6sGmPo/GSuXrnHXr8lrnZk0urzgd1JTKyyvCU+WQo+sd0gWeyqWm+tqKbpuqj2q1YXtKS2vvlWrq41Mfze7PjzfffBOfffYZDhw4ANsa7puzaNEixMTE6J/n5+fD35RxCERkPpUHYVT546XBNBopyFQONpXPAxh7NKVOd15CdzZdrZZKTXdobyw7u+rhpmrg0Q2O0BXdn8D1fV65zt6el/W0AO3aScVS45fqotVKX/uaQk7VR0tPCdAQZg8x7u7uUCgUyMzMNKjPzMyEt7d3rdv+3//9H9588038+OOP6NOnT43rqVQqqDiFPFHrpVBUTIdrKUJI/3eufGlOfR4rL+tOqVUuurqiooqQpDvfcPOm5T5PVcYu66l6uq0+1zhXDUp1FQanFkMurxgj0xSn7SzB7CFGqVQiNDQUCQkJmDBhAgBpYG9CQgLmzp1b43arVq3CihUr8P3336N///7mbhYRkSGZrOL/4B06mH//QlScZqsp6FR+rvuTt/Kfvw15rgtOTX1Zj46NTc0Bp74jUOtaR6WS3kepNHysqY6n81oti5xOiomJQVRUFPr374+wsDDEx8ejsLAQ0dHRAIDp06fDz88PcXFxAICVK1di6dKl2LZtGwIDA5GRkQEAcHR0hKOjoyWaSERkWTJZRY9GUxFCGh1a0ym0hpTKYclYqXpLD90I1aYOT7VRKIwHHKXSsKhUNT+v7TXd8/pcWlS5cEB5o1nkCE6aNAk3b97E0qVLkZGRgZCQEOzdu1c/2DctLQ3ySsn43//+N9RqNR5++GGD/cTGxmLZsmWWaCIRUesjk1X8qDbV+YHKAyt0j8ZK1VGpVUeo1vd5cbH0PmVlFY+Vl6uOVgWkMVYaTeNm1bYEhaLuHiddQKpcjNXVtq5u8I2xYmNT++uVi1ze7E4X8rYDRETUegghBZaaAo6xR10A05XKz+v7WuWwVlsxFrJaCqXS7JPqNLt5YoiIiKxGJqvoOWiOdJPS1Oe66Mqltl6u2l5Xq6VQV15e/1L1FKFOM5xWuJn+KxMREbVC1pqUxlTGgo/uXhDNCEMMERERGVIopNLMpzPhdWdERETUIjHEEBERUYvEEENEREQtEkMMERERtUitYmCvbqqbfGvew5yIiIhMovvdbuiUda0ixNy5cwcAeCdrIiKiFujOnTtwacAs061ixl6tVovr16/DyckJMjNPiZyfnw9/f3+kp6dzNuAmxONuHTzu1sHjbh087tZR+bg7OTnhzp078PX1NbgdUX21ip4YuVyOjh07WvQ9nJ2d+SW3Ah536+Bxtw4ed+vgcbcO3XFvSA+MDgf2EhERUYvEEENEREQtEkNMHVQqFWJjY6Fq5lMvtzY87tbB424dPO7WweNuHeY87q1iYC8RERG1PeyJISIiohaJIYaIiIhaJIYYIiIiapEYYoiIiKhFYoipw7p16xAYGAhbW1uEh4fj2LFj1m5Sq7Zs2TLIZDKD0r17d2s3q9X55ZdfMG7cOPj6+kImk+HLL780eF0IgaVLl8LHxwd2dnaIiIjAhQsXrNPYVqSu4z5jxoxq3//Ro0dbp7GtRFxcHAYMGAAnJyd4enpiwoQJSE5ONlinpKQEc+bMQYcOHeDo6IiJEyciMzPTSi1uHepz3IcPH17t+/7000+b9D4MMbXYvn07YmJiEBsbixMnTqBv376IjIxEVlaWtZvWqt199924ceOGvhw8eNDaTWqwwMBAzJgxw2rvP2PGDAQGBhrUFRQUYMWKFdi/fz9u3LgBAMjKyoJMJsPmzZsBAKtWrcK7776L9evX4+jRo3BwcEBkZCRKSkrM3sbhw4dj+PDhZt9vc1RYWIi+ffti3bp1Na4zevRog+//p59+2oQtbH1+/vlnzJkzB0eOHMG+fftQVlaGUaNGobCwUL/O/Pnz8fXXX2Pnzp34+eefcf36dTz00ENWbHXLV5/jDgCzZs0y+L6vWrXKtDcSVKOwsDAxZ84c/XONRiN8fX1FXFycFVvVusXGxoq+fftauxl1SklJEU899ZTo3LmzUKlUwsnJSQwaNEjEx8eLoqIi/XoBAQEiKirKau2MiooSAQEBBnWLFi0SCoVCLFu2THz88ccCgNiwYYMAID788EOh1WqFt7e3eOutt/Tb5ObmCpVKJT799NMGtePMmTMiNjZWXLp0qdpr9913n7jvvvsatF9z2bNnjwAgfHx8hEajaZL3BCC++OILg7qoqCgxfvz4Jnn/tiorK0sAED///LMQQvpu29jYiJ07d+rXOXv2rAAgEhMTrdXMVqfqcRdC+m//2WefbdR+2RNTA7VajaSkJEREROjr5HI5IiIikJiYaMWWtX4XLlyAr68vgoKC8NhjjyEtLc3aTTKwZ88e9O7dGzt27MC4ceOwZs0axMXFoVOnTliwYAGeffZZazdRb+PGjdW6cH/66Sfce++9iI2NxeOPPw4A8PDwQHFxMaZNm4ZLly4hIyPD4Lvv4uKC8PDwBn/3//zzTyxfvhyXL1+u9toPP/yAH374oUH7NZetW7ciMDAQN27cwE8//WTVthw4cACenp7o1q0bnnnmGeTk5Fi1Pa1NXl4eAMDNzQ0AkJSUhLKyMoPve/fu3dGpUyf+v96Mqh53na1bt8Ld3R29evXCokWLUFRUZNJ+W8UNIC0hOzsbGo0GXl5eBvVeXl44d+6clVrV+oWHh2Pz5s3o1q0bbty4geXLl2Po0KE4ffo0nJycrN08XLp0CZMnT0ZAQAB++ukn+Pj46F+bM2cOUlJSsGfPHiu20JCNjU21uqysLPTs2dOgTiaTwdbWFgCQkZEBAEa/+7rXzEmpVJp9n6YoLCzEV199hbi4OHz44YfYunWrwQ9aUxo9ejQeeughdO7cGampqXj55ZcxZswYJCYmQqFQoLCwEA4ODlZpW2ug1Wrx3HPPYfDgwejVqxcA6fuuVCrh6upqsK6lvu9tkbHjDgBTp05FQEAAfH19cerUKbz00ktITk7G7t2767/zRvYQtVrXrl0TAMThw4cN6hcsWCDCwsKs1Kq25/bt28LZ2Vn85z//sXZThBBCPP300wKAOHToUL3Wr3o6KScnRzz//POiV69ewsHBQTg5OYnRo0eLkydPVtv23XffFT179hR2dnbC1dVVhIaGiq1bt+pfz8/PF88++6wICAgQSqVSeHh4iIiICJGUlKRfp/LppP379wsARkvl00mHDh0SAMT169fF2bNnxSOPPCLc3d2FXC4XTk5O4uWXX9bv//Lly+KZZ54RXbt2Fba2tsLNzU08/PDDBqeNPvzwQ6PvuX//fiGE8dNJmZmZ4oknnhCenp5CpVKJPn36iM2bNxusc+nSJQFAvPXWW2LDhg0iKChIKJVK0b9/f3Hs2LF6/fsIIcTHH38s5HK5uHHjhli5cqVwdnYWxcXF1dYrLi4WsbGx4q677hIqlUp4e3uLBx98UKSkpOjX0Wg0Ij4+XvTq1UuoVCrh7u4uIiMjxa+//mrQZt0xqXw6CYCIjY3VP4+NjdUfqxEjRghXV1cREhIihBDi999/F1FRUfrTmV5eXiI6OlpkZ2dXa/fVq1fFE088IXx8fIRSqRSBgYHi6aefFqWlpSI1NVUAEKtXr662ne57sG3btnofy+bu6aefFgEBASI9PV1ft3XrVqFUKqutO2DAAPHiiy82ZfNaLWPH3ZiEhAQBwOC/qbqwJ6YG7u7uUCgU1UaoZ2Zmwtvb20qtantcXV3RtWtXpKSkWLspAICvv/4aQUFBGDRoUIO2v3jxIr788ks88sgj6Ny5MzIzM7Fhwwbcd999+PPPP+Hr6wtAOg30r3/9Cw8//DCeffZZlJSU4NSpUzh69CimTp0KAHj66aexa9cuzJ07Fz179kROTg4OHjyIs2fP4p577qn23j169MDHH3+M+fPno2PHjnj++ecBANOmTTNYT/f9/t///odZs2bBxsYGTz31FHbt2gVnZ2d8/fXXWLFiBQDg119/xeHDhzF58mR07NgRly9fxr///W8MHz4cf/75J+zt7TFs2DD861//wrvvvouXX34ZPXr00LfHmOLiYgwfPhwpKSmYO3cuOnfujJ07d2LGjBnIzc2tdrpu27ZtuHPnDv75z39CJpNh1apVeOihh3Dx4kWjPVFVbd26FSNGjIC3tzcmT56MhQsX4uuvv8YjjzyiX0ej0eCBBx5AQkICJk+ejGeffRZ37tzBvn37cPr0aQQHBwMAnnzySWzevBljxozBzJkzUV5ejv/97384cuQI+vfvX2dbjFEoFLh16xbeeOMNiL/uErNv3z5cvHgR0dHR8Pb2xpkzZ/D+++/jzJkzOHLkCGQyGQDg+vXrCAsLQ25uLp566il0794d165dw65du1BUVISgoCAMHjwYW7duxfz586sdFycnJ4wfP75B7W5u5s6di2+++Qa//PILOnbsqK/39vaGWq1Gbm6uQW8M/19vHjUdd2PCw8MBACkpKfr/purUyIDVqoWFhYm5c+fqn2s0GuHn58eBvU3ozp07on379uKdd96xdlNEXl6eAGDSwMuqPTElJSXVBo5eunRJqFQq8eqrr+rrxo8fL+6+++5a9+3i4mIw8NwYYwN7AwICxNixY/XPUcPA3qCgIOHk5CSuXLki8vLy9AN7tVqtftvKg5h1EhMTBQDx0Ucf6et27txp0PtSWdWemPj4eAFAfPLJJ/o6tVotBg4cKBwdHUV+fr4QoqJXo0OHDuLWrVv6db/66isBQHz99de1HhshpB6fdu3aiY0bN+rrBg0aVO3f+IMPPqixx0J3PH766ScBQPzrX/+qcZ2G9sR89dVXBvszdtw//fRTAUD88ssv+rrp06cLuVyu7wky1ibdv/3Zs2f1r6nVauHu7m7VQenmotVqxZw5c4Svr684f/58tdd1A3t37dqlrzt37hwH9jZSXcfdmIMHDwoA4vfff6/3+3Bgby1iYmKwceNGbNmyBWfPnsUzzzyDwsJCREdHW7tprdYLL7yAn3/+GZcvX8bhw4fx4IMPQqFQYMqUKdZuGvLz8wGgUWNzVCoV5HLpPzuNRoOcnBw4OjqiW7duOHHihH49V1dXXL16Fb/++muN+3J1dcXRo0dx/fp1k9tRXl6OkydP4uTJkwCA9PR0AEBOTg5kMhlmzpyJixcvYvjw4cjLy8P06dPh6+uLCRMm6P/KBwA7Ozv9cllZGXJyctClSxe4uroafB5TfPvtt/D29jb4N7exscG//vUvFBQU4OeffzZYf9KkSWjfvr3++dChQwFIvV51+eyzzyCXyzFx4kR93ZQpU/Ddd9/h9u3b+rrPP/8c7u7umDdvXrV96I7H559/DplMhtjY2BrX0V1eqhusfunSJZw8eVL//IcffsCRI0dw+fJlffs7duyIyMhIg/1VPu4lJSXIzs7GvffeCwD6467VavHll19i3LhxRnuBdG169NFHYWtri61bt+pf+/7775Gdna0f+N2SzZkzB5988gm2bdsGJycnZGRkICMjA8XFxQCkQetPPvkkYmJisH//fiQlJSE6OhoDBw7UH1MyXV3HPTU1Fa+99hqSkpJw+fJl/Pe//8X06dMxbNgw9OnTp/5v1NCU1VasWbNGdOrUSSiVShEWFiaOHDli7Sa1apMmTdKfu/fz8xOTJk0y6fyoJZmjJ0aj0YjVq1eLLl26CIVCYTBGZMSIEfr1/vzzT+Hn5ycAiC5duojZs2eLgwcPGux7+/btwtbWVsjlcjFgwAARGxsrUlNTDdapqSfm3nvvNTpOZfDgwUKIit4UJycnoVKpxMiRI0VycnK1z1dUVCSWLFkiOnbsKGQymcG+oqOj9euZ0hPTrVs3MXTo0GrrnTx5UgAQa9euFUJU9Gq8+eab1dYFIJYtW1atvqoBAwaIIUOGiAsXLuiL7q/BDRs26Nfr3r27/tjUZPTo0cLPz6/WdXS9JVVLVFSUACCCgoKEh4eHsLGxES4uLgKAwRgnnZycHPGvf/1LeHp6VtvX8uXLhRBCZGRkCADilVdeqfM4PPLIIyIoKEj/fPLkycLPz6/JLje3JGPHG3/1hukUFxeL2bNni/bt2wt7e3vx4IMPihs3bliv0a1AXcc9LS1NDBs2TLi5uQmVSiW6dOkiFixYIPLy8kx6H46JqcPcuXMxd+5cazejzfjss8+s3YQaOTs7w9fXF6dPn27wPt544w0sWbIETzzxBF577TW4ublBLpfjueeeg1ar1a/Xo0cPJCcn45tvvsHevXvx+eef47333sPSpUuxfPlyANJf0EOHDsUXX3yBH374AW+99RZWrlyJ3bt3Y8yYMbW2o0OHDvrxFQBw+fJldO7cGTNnzgRQ8Vf66tWr9XXGzJs3Dx9++CGee+45DBw4EC4uLpDJZJg8ebLB57EkhUJhtL7y5zPmwoUL+p6uu+66q9rrW7duxVNPPdX4BlYycOBAAMCHH35oMAmiRqPBli1bMG3aNCxbtgyANHv18uXL0alTp2r7efTRR3H48GEsWLAAISEhcHR0hFarxejRoxt03KdPn46dO3fi8OHD6N27N/773/9i9uzZ+l7Dlqyu7wEA2NraYt26dbVOQkimqeu4+/v7V+tVbQiGGCITPPDAA3j//feRmJio/0Eyxa5duzBixAhs2rTJoD43Nxfu7u4GdQ4ODpg0aRImTZoEtVqNhx56CCtWrMCiRYv0l0P7+Phg9uzZmD17NrKysnDPPfdgxYoVdYaYugQFBQFAnYFt165diIqKwttvv62vKykpQW5ursF6lU9B1SUgIACnTp2CVqs1+BHVTW0QEBBQ733VZuvWrbCxscHHH39cLQgdPHgQ7777LtLS0tCpUycEBwfj6NGjKCsrq3GwcHBwML7//nvcunWr2lwYOrrTXlWPz5UrV+rd7tu3byMhIQHLly/H0qVL9fVVbwvh4eEBZ2fneoXu0aNHw8PDA1u3bkV4eDiKioqqDfgmao5afswmakIvvvgiHBwcMHPmTKP3VklNTcU777xT4/YKhaLaXyg7d+7EtWvXDOqqTnCmVCrRs2dPCCFQVlYGjUajnzxKx9PTE76+vigtLTX1Y1Xj4eGBYcOG4YMPPqg22WDl9hv7PGvWrIFGozGo081tUvXH25j7778fGRkZ2L59u76uvLwca9asgaOjI+677z5TP45RW7duxdChQzFp0iQ8/PDDBmXBggUAoJ/yf+LEicjOzsbatWur7Uf3+SdOnAghhL6nzNg6zs7OcHd3xy+//GLw+nvvvVfvdusCV9XjHh8fb/BcLpdjwoQJ+Prrr3H8+PEa2wQA7dq1w5QpU7Bjxw5s3rwZvXv3Nm1cApGVsCeGyATBwcHYtm0bJk2ahB49emD69Ono1asX1Go1Dh8+rL8UuCYPPPAAXn31VURHR2PQoEH4448/sHXrVn3Ph86oUaPg7e2NwYMHw8vLC2fPnsXatWsxduxYODk5ITc3Fx07dsTDDz+Mvn37wtHRET/++CN+/fVXg16Rxnj33XcxZMgQ3HPPPXjqqafQuXNnXL58GXv27NEPCH7ggQfw8ccfw8XFBT179kRiYiJ+/PFHdOjQwWBfISEhUCgUWLlyJfLy8qBSqfC3v/0Nnp6e1d73qaeewoYNGzBjxgwkJSUhMDAQu3btwqFDhxAfH2+WSQ+PHj2qv4TbGD8/P9xzzz3YunUrXnrpJUyfPh0fffQRYmJicOzYMQwdOhSFhYX48ccfMXv2bIwfPx4jRozAtGnT8O677+LChQv6Uzv/+9//MGLECP17zZw5E2+++SZmzpyJ/v3745dffsH58+fr3XZnZ2cMGzYMq1atQllZGfz8/PDDDz/g0qVL1dZ944038MMPP+C+++7DU089hR49euDGjRvYuXMnDh48aHBJ8fTp0/Huu+9i//79WLlypWkHlMhazDOEh6htOX/+vJg1a5YIDAwUSqVSODk5icGDB4s1a9aIkpIS/XrGLrF+/vnnhY+Pj7CzsxODBw8WiYmJ1Qa3btiwQQwbNkx06NBBqFQqERwcbDDorbS0VCxYsED07dtXODk5CQcHB9G3b1/x3nvvGbSzPpdYC2F46W9lp0+fFg8++KBwdXUVtra2olu3bmLJkiX612/fvi2io6OFu7u7cHR0FJGRkeLcuXNG7xm1ceNGERQUpB/QXNdkd7r9KpVK0bt372ptqzzZXVWocrlyVfPmzRMAqg2ErmzZsmUGl3sWFRWJV155RXTu3FnY2NgIb29v8fDDDxvso7y8XLz11luie/fu+gkIx4wZYzA4t6ioSDz55JPCxcVFODk5iUcffVR/Xxljl1jfvHmzWtuuXr2q/3dxcXERjzzyiLh+/brRz33lyhUxffp04eHhIVQqlQgKChJz5swRpaWl1fZ79913C7lcLq5evVrjcSFqTmRC1GPUExERtXr9+vWDm5sbEhISrN0UonrhmBgiIsLx48dx8uRJTJ8+3dpNIao39sQQEbVhp0+fRlJSEt5++21kZ2fj4sWL+qvfiJo79sQQEbVhu3btQnR0NMrKyvDpp58ywFCLwp4YIiIiapHYE0NEREQtUquYJ0ar1eL69etwcnIyaWZQIiIish4hBO7cuQNfX98G3eaiVYSY69evw9/f39rNICIiogZIT09Hx44dTd6uVYQY3Qye6enpcHZ2tnJriIiIqD7y8/Ph7+/f4Jm4W0WI0Z1CcnZ2ZoghIiJqYRo6FIQDe4mIiKhFYoghIiKiFokhhoiIiFqkVjEmhoiIqFUoLgYyMwG5HFAo6i5yOdCGpxZhiCEiImoqxcXAlSvA5cvGS2am6fusK+jIZBVhpyGPumWVCjh0yJxHo9EYYoiIiMyluBhIS6seTi5dqn9IUamkR41GKnXdHUi3nqU1w/tqMcQQEZF1aTTA7dtATg6QnV17ycmRftQ7dADc3KRS17KLi9SbYAohgDt3gNxcqW2Vi7G6nBwpvGRk1L1vR0egc2cgMNB4ad/e8BSRENIxKi+vCCymFCGkotWa/lh5uRmetmpQiFm3bh3eeustZGRkoG/fvlizZg3CwsKMrltWVoa4uDhs2bIF165dQ7du3bBy5UqMHj1av86yZcuwfPlyg+26deuGc+fONaR5RETUEGVlQEGB9ONdUAAUFVX/4WzoD2lxcc0h5datunsbqkpJqf+6crkUDKqGm/btAbXaeDjJzW1474apIaUuMhnQrp1UyIDJR2T79u2IiYnB+vXrER4ejvj4eERGRiI5ORmenp7V1l+8eDE++eQTbNy4Ed27d8f333+PBx98EIcPH0a/fv30691999348ccfKxrGfywiourKyqRAoCtFRYbPi4ulAKIrukBS0/PKdWq1dT+biwvg7l5ROnQwfK6rk8mk4JOTIz3WtlxYKPUi5ORIxVRKpRQ62rcHXF0rlisXV1cpFPn7SyHFza1Z9lq0RjIhTIu/4eHhGDBgANauXQtAuvmiv78/5s2bh4ULF1Zb39fXF6+88grmzJmjr5s4cSLs7OzwySefAJB6Yr788kucPHmyQR8iPz8fLi4uyMvL44y9RNS0ysvrDhWNqav6WlOMfVCppN4Ee3vpr/+6Bo7WZx2VqnogqRxMOnQAbGzM/1lKSqSelZqCjkplPJTolu3sGEgsqLG/3yZ1d6jVaiQlJWHRokX6OrlcjoiICCQmJhrdprS0FLZVBgPZ2dnh4MGDBnUXLlyAr68vbG1tMXDgQMTFxaFTp0417rO0tFT/PD8/35SPQURUs9JSICtLGoCpe6yp5OZKIcZa7OyMFycnKYToiinPHRyk3ofWwtYW8PGRCrU6JoWY7OxsaDQaeHl5GdR7eXnVOH4lMjISq1evxrBhwxAcHIyEhATs3r0bmkp/TYSHh2Pz5s3o1q0bbty4geXLl2Po0KE4ffq00ZtCxcXFVRtDQ0QtSHk5kJcnhYC8vOrLVZ8XFEh/7SuV1YtKZby+ptc1mtrDSW5uwz+Xra0UIuztjYeLmupreq229W1t2UNAbZ7FB5688847mDVrFrp37w6ZTIbg4GBER0fjgw8+0K8zZswY/XKfPn0QHh6OgIAA7NixA08++WS1fS5atAgxMTH657q7YBJREyotrbgqw9hYhFu3pEBgLKgUFVm58XWwsQE8PQEvL6lUXq5c2revCBoMFURNzqQQ4+7uDoVCgcwq17lnZmbC29vb6DYeHh748ssvUVJSgpycHPj6+mLhwoUICgqq8X1cXV3RtWtXpNQw+lylUkGlu46eiBpHra57cKSx5cLCxr+3g4M0mFNXXF2NP3d0lHpQ1Or6ldLSml8Dag4llcMJAwkRAECj1aC4vBgl5SVwt3e3dnMMmBRilEolQkNDkZCQgAkTJgCQBvYmJCRg7ty5tW5ra2sLPz8/lJWV4fPPP8ejjz5a47oFBQVITU3FtGnTTGkeUdumu1S0ptBRUygpKGj4e9Z06aqutG9fc0hxdrbMQE6iNkAIgXJtuT5c6EpxWcXz4vJiFJcVo6isCIVlhSgqK5KW1YXV6/5a1r1Wua6kvAQA4Kh0xJ1Fd6z8yQ2ZfDopJiYGUVFR6N+/P8LCwhAfH4/CwkJER0cDAKZPnw4/Pz/ExcUBAI4ePYpr164hJCQE165dw7Jly6DVavHiiy/q9/nCCy9g3LhxCAgIwPXr1xEbGwuFQoEpU6aY6WMStSBlZbWHkZqCyZ1G/M9FJqsII7ogUp/JxBoyiRhRC1auLUdeSR7ySvMMHu+o70CtUaNcW44yTZn0qC0zeF5nXaXXdCGkpnBSUl4CrdA26WcvLiuGEAKyZtRLaXKImTRpEm7evImlS5ciIyMDISEh2Lt3r36wb1paGuSV/qdWUlKCxYsX4+LFi3B0dMT999+Pjz/+GK6urvp1rl69iilTpiAnJwceHh4YMmQIjhw5Ag8Pj8Z/QiJr02qlCb2uXzcsGRnGA0pjrraTyaTejroCSNU6hhFqJTRaDdQaNcq0ZVBr1LWW0vJSFKgLqgWSvFLD5fzSfP1yUVnzHM+lUqhgZ2MH23a2+mLXTnruoHSAvY09HGwMH+1t7Ku9VludbTvbZhVggAbME9MccZ4YsgohpB6TquGkarlxo2GX4dZ0mqbqKZvKwcTFRZqTg6iZE0KgqKzIeIAoyUNuSW6NoaKorKjGYNJUvRP2NvZwUbnAxdYFLioXOKmcoFKoYKOwQTt5O9jIpcfKy7rXjNUZrK+w0QcQ23a2NYYT3WtKhRJyWcv8I6RJ54kharU0moopx6veF6Xy81u3pFCiCyiV5iuqlUwmDSb19a0o3t4Vk3xVDSSurgwj1GxotBoUlhWiUF3YsMeyQqnHo1I4yS/NR7nW8nPstJO3g1KhNFps5DZwVDrqg0jlUKJ7dFY5G62zUXA8V3PAEEOti0YjBY2bN6WSlSU93rpV843bcnMbdwqnQwfDcGKseHlxECs1Ka3QolBdiPzS/PoVdfW6O6V3UKAuQKmmnmG9AeQyudHwoHt0tXWtVm9vYw+VQlVjONGHFIVNi+2hoPphiKHmTautCCW6QFJ5uWpdTo60TUM5Ohq/P0rlOh8fw96UZnh7emr+hBAoLi/WnyIpVBeiuLxYf2VI1aK7yqSorAhF5TXU/1XuqO/gTukdCJh3tIAMMjgoHeBg41DzYw2vOSodjYYUR6VjsxtnQS0HQwxZl0YDXL0KpKZKJSWlYvn6dSmUNOReMe3bS6dvPDykorvct7Zw4urK3hKql8q9HFUHftY2QLTqY1OcTlHIFHCxlU6BVC1OSiej9ZVfrxxE7NrZMXBQs8IQQ5ZXUgJculQRTiqHlcuX63fn3PbtKwJJ5XCiW65c5+7OMELVqDVq/ZgMXU9FgbpAv2zssabXC9WFZuvlkEEGZ5UzHJWO+itBqhY7GzvYt6uhvmpdOzuDINIcryghMheGGDIPIYDz54Hff68eVK5dk16viY0N0Lkz0KULEBxcUfz9pXDCUEKQQkhuSa7JJa9UCi6WuDRW18tR40DQWsZ66HpHHJWOHLdB1EAMMdQwRUXAr78Chw9XlFu3al7fyUkKJlWDSnAw0LEjr8RpY7RCi9vFt3Gz6Cayi7Jxs/AmbhbdxM3Cv54X3TR4LbsoG8XlxWZ5b0elI5yUTnBSORl/rOE1Y9vx9AqRdTHEUP2kpxsGlpMnq899YmsLhIQAd91VPay4u/NeNK1YmaasInxUCiT6IFLleU5RDjSiAWOdAH0vhqutq2FRuVavq1R0PR/t5PzfHlFrwf+aqbqyMimkVA4tV69WX8/PDxg8GBg0SCp9+wJKZZM3l8yvtLzUIHhkFWZVCyeVl3NLchv0Pi4qF3g4eMDD3gPu9u7wsPeAh0P1ZXd7d7jZucFJ6QSFnL12RCRhiCFpSvwjR4BDh6TA8uuvQHGVrnuFQupl0QWWwYOlMSvUrAkhcEd9BzlFOcgpzqn2eKv4VrX67KJs3FGbfh8muUyODnYd9KFE/2gkmHjYe6CDfQcoFQy9RNRwDDFtTVER8NtvwLFjUlg5dkwafFtV+/YVgWXQIGDAAMDBoenbS9VohRaZBZlIy0tDen460vLSkFGQURFEqoSUhl7G207eziB4eDp4GoSSqo/tbduzl4SImhRDTGtWVgacOVMRVn79FTh92vi8Kz16GIaWrl15Q0ArEEIgrzQP6XnpBiFF/5iXjqv5V1GmLTNpv7btbNHBrgM62HcwfPxr2c3OTb+sCy6utq4ctEpEzRpDTGshhHRJc+XAcuKENEdLVd7eQFiYVAYMAPr3lyaDI4srKivC1fyruJp/Fel56UZDSn1O5chlcvg6+aKTSyf4O/vD18nXeEj569HOxq4JPh0RUdNiiGmpMjKAo0crQsvx49J9gKpydpaCyoABFaHFz49XCllAgbpAH1AqB5Wrdyqe3yqu5TL0SjrYdYC/i78+pBg8ukihhVfZEFFbx/8LtiRXrgA7dwI7dkjhpSqVCujXzzCw3HUXTwuZQXFZMa7kXUFaXlqNAaW+V+g42DjA38UfHZ07opNzp2phpaNzRzgoOf6IiKguDDHN3ZUrwK5dUnA5dqyiXiYD7r67IqyEhQG9evES5wbKLcnFldwruJJ3peLxr+XLuZdxs+hmvfbjrHJGR+eOUnHqqA8ruuLv7A9nlTPHmhARmQFDTHOUllYRXI4eraiXyYD77gMeeQR46CFpbAvVSQiBzMLMGkPKlbwryC/Nr3M/jkpHBLgEwN/FH/7OhuFEV5xVzk3wiYiICGCIaT50wWXnTmnOFh2ZDBg2DHj0UQaXWhSXFeNS7iVcvH0RqbdScfH2RVzMvSg93r6IknIjA5yrcLd3R4BLAAJcA6THysuuAWhv2549KEREzQhDjDWlp1cEl8TEinqZDBg6tCK4+PhYr43NhK43RRdKUm+l6kNK6q1U3Ci4Uev2Msjg5+xXY0jp5NKJ41CIiFoYhpimdvVqxakiY8HlkUeAiRPbbHDJL83HH5l/4FTmKZzPOW/Qm1LXXYidVc4Ibh+MoPZB+kdd8Xfx5+ywREStDENMUzl9Gpg3DzhwoKJOJgOGDKnocfH1tVrzmppGq0HKrRScyjwllSzp8XLu5Rq3kcvk8Hf2NxpSgt2CebqHiKiNYYixNI0GWL0aWLwYUKul4DJ4sBRcJk5sE8ElpyinIqz8FVjOZJ1BcXmx0fU7OndEH68+6OHewyCsBLgGsDeFiIj0GhRi1q1bh7feegsZGRno27cv1qxZg7CwMKPrlpWVIS4uDlu2bMG1a9fQrVs3rFy5EqNHj27wPluMixeBqCjg4EHp+dixwHvvAZ06WbddFlKuLce57HOGgSXzFK7duWZ0fbt2dujt1Rt9PPugj5dUenv1hpsdZw8mIqK6mRxitm/fjpiYGKxfvx7h4eGIj49HZGQkkpOT4enpWW39xYsX45NPPsHGjRvRvXt3fP/993jwwQdx+PBh9OvXr0H7bPaEADZuBGJigMJCwNERiI8HnniiVc2Um1+ajyNXj+Bg2kEcSj+Eo1ePorCs0Oi6nV07o693X4PAEtQ+iDcMJCKiBpMJIYQpG4SHh2PAgAFYu3YtAECr1cLf3x/z5s3DwoULq63v6+uLV155BXPmzNHXTZw4EXZ2dvjkk08atM+q8vPz4eLigry8PDg7W3mejhs3gCefBL77Tno+bBiweTPQubNVm2UO6Xnp+sByKP0QTmWeglZoDdZxUjrpQ4qu9PLsxflTiIiomsb+fpvUE6NWq5GUlIRFixbp6+RyOSIiIpBY+UqbSkpLS2Fra2tQZ2dnh4N/nWJp6D5LS0v1z/Pz656orEns2AE88wxw65Z0C4A33gCee65FTvuv0WpwOuu0PrQcTDuI9Pz0aut1du2MwZ0GY4j/EAzuNBg9PXpCLmt5n5eIiFoek0JMdnY2NBoNvLy8DOq9vLxw7tw5o9tERkZi9erVGDZsGIKDg5GQkIDdu3dDo9E0eJ9xcXFYvny5KU23rFu3gDlzgM8+k57fcw/w0UfSbQFaiEJ1IY5eO4pDaYdwMP0gjlw9Um0WW4VMgRDvEAzpNASD/QdjcKfB8HVq/QOTiYioebL41UnvvPMOZs2ahe7du0MmkyE4OBjR0dH44IMPGrzPRYsWISYmRv88Pz8f/v7+5miu6fbulca63LgBKBTAK69IVyLZ2FinPfUkhMDprNPY9ecufJvyLX678Rs0QmOwjpPSCQP9B0qBxX8wwjuGw1HpaKUWExERGTIpxLi7u0OhUCAzM9OgPjMzE941TIfv4eGBL7/8EiUlJcjJyYGvry8WLlyIoKCgBu9TpVJBpVKZ0nTzKygAXngB2LBBet6tm9T70oyvqBJC4GTGSez6cxd2nd2F8znnDV7v6NwRQzoN0Z8a6u3ZmwNviYio2TIpxCiVSoSGhiIhIQETJkwAIA3CTUhIwNy5c2vd1tbWFn5+figrK8Pnn3+ORx99tNH7tJpDh4Dp06VLqAHg2Wel8S/29tZtlxFCCBy/flwfXC7evqh/TaVQIbJLJB7q/hBGdB6BTi6t89JvIiJqnUw+nRQTE4OoqCj0798fYWFhiI+PR2FhIaKjowEA06dPh5+fH+Li4gAAR48exbVr1xASEoJr165h2bJl0Gq1ePHFF+u9z2ajtBRYuhR46y3pMmp/f+nKo7/9zdotM6AVWhy7dgw7z+zE52c/x5W8K/rXbNvZ4v677sfDPR7G2K5jedUQERG1WCaHmEmTJuHmzZtYunQpMjIyEBISgr179+oH5qalpUFe6WqckpISLF68GBcvXoSjoyPuv/9+fPzxx3B1da33PpuFkyel3pc//pCeR0UB77wDuLhYtVk6WqHF4fTD2PXnLnx+9nNczb+qf83exh4PdH0AD/d4GGPuGsNxLURE1CqYPE9Mc2TReWLKy6Wel9hYoKwM8PAA3n8f+OvUlzVptBr8L+1/2PXnLuw+u9vgTs5OSieM6zYOD/d4GJFdImFv0/xOdRERUdvWpPPEtDlXrgBTplTcbXr8eCnAWHkW4Su5V/DmwTex+9xuZBVm6etdVC4Y3308Hu7xMP4e/HfYtrOtZS9EREQtG0NMbeztgdRUwNkZePdd6XSSFW8bUKYpQ/yReCz7eRmKyooAAG52bpjQbQIe7vkwRgaN5A0SiYiozWCIqY2HB7Brl3TDxoAAqzYlMT0R//zmn/gjSxqTMyxgGF4Z+gpGBI6AjaJ5z0lDRERkCQwxdRk61Kpvf7v4Nhb+uBDvn3gfANDBrgP+b9T/IapvFGSt6GaSREREpmKIaaaEENj2xzbE/BCjH/cSHRKNVX9fBXd7dyu3joiIyPoYYpqh8znnMXvPbCRcSgAA9HDvgfUPrMewgGFWbhkREVHzwRDTjJSWl+LNg28i7mAcSjWlsG1niyXDluCFQS9wwC4REVEVDDHNxE+XfsIze57R388oMjgS6+5fh2C3YCu3jIiIqHliiLGyrMIsPP/D8/jk1CcAAG9Hb8RHxuPRux/lwF0iIqJaMMRYiVZosenEJrz040u4XXIbMsgwe8BsrPjbCrjYNo9bGRARETVnDDFWcDrrNJ7+5mkcSj8EAAjxDsGGBzYgzC/Myi0jIiJqORhimlChuhCv/vwqVh9ZjXJtORxsHPD6317H3LC5aCfnPwUREZEp+MvZRPJL8xG2MQzJOckAgAe7P4h3Rr8Dfxd/K7eMiIioZWKIaSJ7U/YiOScZHvYe2PSPTRjXbZy1m0RERNSiya3dgLYi6XoSAGBij4kMMERERGbAENNEkm5IISbUN9TKLSEiImodGGKagBCiIsT4MMQQERGZA0NME7h4+yJyS3KhUqhwt+fd1m4OERFRq8AQ0wSOXz8OAOjj1Yf3QCIiIjIThpgmoDuV1N+3v5VbQkRE1HowxDQBXU8Mx8MQERGZD0OMhQkhcOLGCQDsiSEiIjInhhgLS72dirzSPKgUKvT06Gnt5hAREbUaDQox69atQ2BgIGxtbREeHo5jx47Vun58fDy6desGOzs7+Pv7Y/78+SgpKdG/vmzZMshkMoPSvXv3hjSt2dGdSgrxDoGNwsbKrSEiImo9TL7twPbt2xETE4P169cjPDwc8fHxiIyMRHJyMjw9Pautv23bNixcuBAffPABBg0ahPPnz2PGjBmQyWRYvXq1fr27774bP/74Y0XD2rWOOyLoZurleBgiIiLzMrknZvXq1Zg1axaio6PRs2dPrF+/Hvb29vjggw+Mrn/48GEMHjwYU6dORWBgIEaNGoUpU6ZU671p164dvL299cXd3b1hn6iZOX7jr0G9nKmXiIjIrEwKMWq1GklJSYiIiKjYgVyOiIgIJCYmGt1m0KBBSEpK0oeWixcv4ttvv8X9999vsN6FCxfg6+uLoKAgPPbYY0hLS6uxHaWlpcjPzzcozZFWaDmol4iIyEJMOmeTnZ0NjUYDLy8vg3ovLy+cO3fO6DZTp05FdnY2hgwZAiEEysvL8fTTT+Pll1/WrxMeHo7NmzejW7duuHHjBpYvX46hQ4fi9OnTcHJyqrbPuLg4LF++3JSmW0XKrRTkl+bDtp0tB/USERGZmcWvTjpw4ADeeOMNvPfeezhx4gR2796NPXv24LXXXtOvM2bMGDzyyCPo06cPIiMj8e233yI3Nxc7duwwus9FixYhLy9PX9LT0y39MRpENx4mxDsE7eStY4wPERFRc2HSL6u7uzsUCgUyMzMN6jMzM+Ht7W10myVLlmDatGmYOXMmAKB3794oLCzEU089hVdeeQVyefUc5erqiq5duyIlJcXoPlUqFVQqlSlNtwre9JGIiMhyTOqJUSqVCA0NRUJCgr5Oq9UiISEBAwcONLpNUVFRtaCiUCgASBPBGVNQUIDU1FT4+PiY0rxmR3d5NcfDEBERmZ/J5zhiYmIQFRWF/v37IywsDPHx8SgsLER0dDQAYPr06fDz80NcXBwAYNy4cVi9ejX69euH8PBwpKSkYMmSJRg3bpw+zLzwwgsYN24cAgICcP36dcTGxkKhUGDKlClm/KhNq/KgXvbEEBERmZ/JIWbSpEm4efMmli5dioyMDISEhGDv3r36wb5paWkGPS+LFy+GTCbD4sWLce3aNXh4eGDcuHFYsWKFfp2rV69iypQpyMnJgYeHB4YMGYIjR47Aw8PDDB/ROi7kXMAd9R3YtbNDD48e1m4OERFRqyMTNZ3TaUHy8/Ph4uKCvLw8ODs7W7s5AIBtf2zDY7sfw8COA3H4ycPWbg4REVGz09jfb947yUJ452oiIiLLYoixEN2VSRzUS0REZBkMMRZgMKiXtxsgIiKyCIYYCzifcx4F6gLY29iju3vruBs3ERFRc8MQYwGcqZeIiMjyGGIsQD/JnQ/HwxAREVkKQ4wF6G83wPEwREREFsMQY2YarYYz9RIRETUBhhgzO59zHoVlhRzUS0REZGEMMWamO5XUz7sfFHKFlVtDRETUejHEmBnvXE1ERNQ0GGLMTD+ol+NhiIiILIohxowqD+plTwwREZFlMcSYUXJOMorKiuBg44CuHbpauzlEREStGkOMGenGw/Tz4aBeIiIiS2OIMSPd7QY4Uy8REZHlMcSYEWfqJSIiajoMMWai0WrwW8ZvADiol4iIqCkwxJjJuexzKCorgqPSkYN6iYiImgBDjJnoBvXe43MP5DIeViIiIkvjr62ZcJI7IiKipsUQYya83QAREVHTYogxg3JtOU5mnATAnhgiIqKm0qAQs27dOgQGBsLW1hbh4eE4duxYrevHx8ejW7dusLOzg7+/P+bPn4+SkpJG7bM5OZd9DsXlxXBSOuGuDndZuzlERERtgskhZvv27YiJiUFsbCxOnDiBvn37IjIyEllZWUbX37ZtGxYuXIjY2FicPXsWmzZtwvbt2/Hyyy83eJ/NDQf1EhERNT2Tf3FXr16NWbNmITo6Gj179sT69ethb2+PDz74wOj6hw8fxuDBgzF16lQEBgZi1KhRmDJlikFPi6n7LC0tRX5+vkGxJt1MvTyVRERE1HRMCjFqtRpJSUmIiIio2IFcjoiICCQmJhrdZtCgQUhKStKHlosXL+Lbb7/F/fff3+B9xsXFwcXFRV/8/f1N+Rhmd/wGB/USERE1NZNCTHZ2NjQaDby8vAzqvby8kJGRYXSbqVOn4tVXX8WQIUNgY2OD4OBgDB8+XH86qSH7XLRoEfLy8vQlPT3dlI9hVgaDenm7ASIioiZj8QEcBw4cwBtvvIH33nsPJ06cwO7du7Fnzx689tprDd6nSqWCs7OzQbGWP2/+iZLyEjirnNHFrYvV2kFERNTWtDNlZXd3dygUCmRmZhrUZ2Zmwtvb2+g2S5YswbRp0zBz5kwAQO/evVFYWIinnnoKr7zySoP22ZzoxsNwUC8REVHTMulXV6lUIjQ0FAkJCfo6rVaLhIQEDBw40Og2RUVFkMsN30ahUAAAhBAN2mdzwpl6iYiIrMOknhgAiImJQVRUFPr374+wsDDEx8ejsLAQ0dHRAIDp06fDz88PcXFxAIBx48Zh9erV6NevH8LDw5GSkoIlS5Zg3Lhx+jBT1z6bM87US0REZB0mh5hJkybh5s2bWLp0KTIyMhASEoK9e/fqB+ampaUZ9LwsXrwYMpkMixcvxrVr1+Dh4YFx48ZhxYoV9d5nc1WmKcPvmb8DYE8MERFRU5MJIYS1G9FY+fn5cHFxQV5eXpMO8v0943eEbAiBi8oFt166xTExREREJmjs7zd/dRtBNx6Gg3qJiIiaHn95G4HjYYiIiKyHIaYReGUSERGR9TDENFCZpgy/Z0iDetkTQ0RE1PQYYhrozM0zKNWUwtXWFUHtg6zdHCIiojaHIaaBKs/UK5PJrNwaIiKitochpoH0g3p9eCqJiIjIGhhiGkg/qJd3riYiIrIKhpgGUGvU+pl6OaiXiIjIOhhiGuBM1hmoNWq0t22Pzq6drd0cIiKiNokhpgF042FCfUM5qJeIiMhKGGIagJPcERERWR9DTAPoQgzHwxAREVkPQ4yJ1Bo1TmWeAsCeGCIiImtiiDHR6azT+kG9ga6B1m4OERFRm8UQY6LKd67moF4iIiLrYYgxke52AzyVREREZF0MMSY6fqOiJ4aIiIishyHGBKXlpfgj8w8AvN0AERGRtTHEmOB01mmUacvQwa4DAlwCrN0cIiKiNo0hxgScqZeIiKj5YIgxAWfqJSIiaj4aFGLWrVuHwMBA2NraIjw8HMeOHatx3eHDh0Mmk1UrY8eO1a8zY8aMaq+PHj26IU2zqMqXVxMREZF1tTN1g+3btyMmJgbr169HeHg44uPjERkZieTkZHh6elZbf/fu3VCr1frnOTk56Nu3Lx555BGD9UaPHo0PP/xQ/1ylUpnaNIsqKS/B6azTANgTQ0RE1ByY3BOzevVqzJo1C9HR0ejZsyfWr18Pe3t7fPDBB0bXd3Nzg7e3t77s27cP9vb21UKMSqUyWK99+/YN+0QW8kfmHyjTlsHd3h2dXDpZuzlERERtnkkhRq1WIykpCRERERU7kMsRERGBxMTEeu1j06ZNmDx5MhwcHAzqDxw4AE9PT3Tr1g3PPPMMcnJyatxHaWkp8vPzDYqlVR4Pw0G9RERE1mdSiMnOzoZGo4GXl5dBvZeXFzIyMurc/tixYzh9+jRmzpxpUD969Gh89NFHSEhIwMqVK/Hzzz9jzJgx0Gg0RvcTFxcHFxcXffH39zflYzSIbqZejochIiJqHkweE9MYmzZtQu/evREWFmZQP3nyZP1y79690adPHwQHB+PAgQMYOXJktf0sWrQIMTEx+uf5+fkWDzK6mXo5HoaIiKh5MKknxt3dHQqFApmZmQb1mZmZ8Pb2rnXbwsJCfPbZZ3jyySfrfJ+goCC4u7sjJSXF6OsqlQrOzs4GxZIqD+plTwwREVHzYFKIUSqVCA0NRUJCgr5Oq9UiISEBAwcOrHXbnTt3orS0FI8//nid73P16lXk5OTAx8fHlOZZzKnMUyjXlsPD3gMdnTtauzlERESEBlydFBMTg40bN2LLli04e/YsnnnmGRQWFiI6OhoAMH36dCxatKjadps2bcKECRPQoUMHg/qCggIsWLAAR44cweXLl5GQkIDx48ejS5cuiIyMbODHMi/9nas5Uy8REVGzYfKYmEmTJuHmzZtYunQpMjIyEBISgr179+oH+6alpUEuN8xGycnJOHjwIH744Ydq+1MoFDh16hS2bNmC3Nxc+Pr6YtSoUXjttdeazVwx+knufHgqiYiIqLmQCSGEtRvRWPn5+XBxcUFeXp5FxseErA/B75m/44tJX2BC9wlm3z8REVFb1Njfb947qQ7FZcU4c/MMAA7qJSIiak4YYuqgG9Tr6eAJPyc/azeHiIiI/sIQUwfdTL39fftzUC8REVEzwhBTB92gXk5yR0RE1LwwxNSh8j2TiIiIqPlgiKlFcVkxzmRxUC8REVFz1KT3TmppCtQFeLLfk7iUewm+Tr7Wbg4RERFVwhBTCw8HD2wYt8HazSAiIiIjeDqJiIiIWiSGGCIiImqRGGKIiIioRWKIISIiohapVQzs1d3DMj8/38otISIiovrS/W439F7UrSLE3LlzBwDg7+9v5ZYQERGRqe7cuQMXFxeTt5OJhsafZkSr1eL69etwcnIy+/2N8vPz4e/vj/T09AbdJpwahsfdOnjcrYPH3Tp43K2j8nF3cnLCnTt34OvrC7nc9BEuraInRi6Xo2PHjhZ9D2dnZ37JrYDH3Tp43K2Dx906eNytQ3fcG9IDo8OBvURERNQiMcQQERFRi8QQUweVSoXY2FioVCprN6VN4XG3Dh536+Bxtw4ed+sw53FvFQN7iYiIqO1hTwwRERG1SAwxRERE1CIxxBAREVGLxBBDRERELRJDDBEREbVIDDF1WLduHQIDA2Fra4vw8HAcO3bM2k1q1ZYtWwaZTGZQunfvbu1mtTq//PILxo0bB19fX8hkMnz55ZcGrwshsHTpUvj4+MDOzg4RERG4cOGCdRrbitR13GfMmFHt+z969GjrNLaViIuLw4ABA+Dk5ARPT09MmDABycnJBuuUlJRgzpw56NChAxwdHTFx4kRkZmZaqcWtQ32O+/Dhw6t9359++mmT3ochphbbt29HTEwMYmNjceLECfTt2xeRkZHIysqydtNatbvvvhs3btzQl4MHD1q7Sa1OYWEh+vbti3Xr1hl9fdWqVXj33Xexfv16HD16FA4ODoiMjERJSUkTt7R1qeu4A8Do0aMNvv+ffvppE7aw9fn5558xZ84cHDlyBPv27UNZWRlGjRqFwsJC/Trz58/H119/jZ07d+Lnn3/G9evX8dBDD1mx1S1ffY47AMyaNcvg+75q1SrT3khQjcLCwsScOXP0zzUajfD19RVxcXFWbFXrFhsbK/r27WvtZrQpAMQXX3yhf67VaoW3t7d466239HW5ublCpVKJTz/91AotbJ2qHnchhIiKihLjx4+3SnvaiqysLAFA/Pzzz0II6bttY2Mjdu7cqV/n7NmzAoBITEy0VjNbnarHXQgh7rvvPvHss882ar/siamBWq1GUlISIiIi9HVyuRwRERFITEy0YstavwsXLsDX1xdBQUF47LHHkJaWZu0mtSmXLl1CRkaGwXffxcUF4eHh/O43gQMHDsDT0xPdunXDM888g5ycHGs3qVXJy8sDALi5uQEAkpKSUFZWZvB97969Ozp16sTvuxlVPe46W7duhbu7O3r16oVFixahqKjIpP22irtYW0J2djY0Gg28vLwM6r28vHDu3Dkrtar1Cw8Px+bNm9GtWzfcuHEDy5cvx9ChQ3H69Gk4OTlZu3ltQkZGBgAY/e7rXiPLGD16NB566CF07twZqampePnllzFmzBgkJiZCoVBYu3ktnlarxXPPPYfBgwejV69eAKTvu1KphKurq8G6/L6bj7HjDgBTp05FQEAAfH19cerUKbz00ktITk7G7t27671vhhhqVsaMGaNf7tOnD8LDwxEQEIAdO3bgySeftGLLiCxv8uTJ+uXevXujT58+CA4OxoEDBzBy5Egrtqx1mDNnDk6fPs1xdk2spuP+1FNP6Zd79+4NHx8fjBw5EqmpqQgODq7Xvnk6qQbu7u5QKBTVRqhnZmbC29vbSq1qe1xdXdG1a1ekpKRYuylthu77ze++9QUFBcHd3Z3ffzOYO3cuvvnmG+zfvx8dO3bU13t7e0OtViM3N9dgfX7fzaOm425MeHg4AJj0fWeIqYFSqURoaCgSEhL0dVqtFgkJCRg4cKAVW9a2FBQUIDU1FT4+PtZuSpvRuXNneHt7G3z38/PzcfToUX73m9jVq1eRk5PD738jCCEwd+5cfPHFF/jpp5/QuXNng9dDQ0NhY2Nj8H1PTk5GWloav++NUNdxN+bkyZMAYNL3naeTahETE4OoqCj0798fYWFhiI+PR2FhIaKjo63dtFbrhRdewLhx4xAQEIDr168jNjYWCoUCU6ZMsXbTWpWCggKDv3YuXbqEkydPws3NDZ06dcJzzz2H119/HXfddRc6d+6MJUuWwNfXFxMmTLBeo1uB2o67m5sbli9fjokTJ8Lb2xupqal48cUX0aVLF0RGRlqx1S3bnDlzsG3bNnz11VdwcnLSj3NxcXGBnZ0dXFxc8OSTTyImJgZubm5wdnbGvHnzMHDgQNx7771Wbn3LVddxT01NxbZt23D//fejQ4cOOHXqFObPn49hw4ahT58+9X+jRl3b1AasWbNGdOrUSSiVShEWFiaOHDli7Sa1apMmTRI+Pj5CqVQKPz8/MWnSJJGSkmLtZrU6+/fvFwCqlaioKCGEdJn1kiVLhJeXl1CpVGLkyJEiOTnZuo1uBWo77kVFRWLUqFHCw8ND2NjYiICAADFr1iyRkZFh7Wa3aMaONwDx4Ycf6tcpLi4Ws2fPFu3btxf29vbiwQcfFDdu3LBeo1uBuo57WlqaGDZsmHBzcxMqlUp06dJFLFiwQOTl5Zn0PrK/3oyIiIioReGYGCIiImqRGGKIiIioRWKIISIiohaJIYaIiIhaJIYYIiIiapEYYoiIiKhFYoghIiKiFokhhoiIiFokhhgiIiJqkRhiiIiIqEViiCEiIqIW6f8DttbIptElTl0AAAAASUVORK5CYII=","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["plt.subplot(211)\n","plt.title('Cross Entropy Loss')\n","plt.plot(history.history['loss'], color='blue', label='train')\n","plt.plot(history.history['val_loss'], color='red', label='val')\n","\n","# plot accuracy\n","plt.subplot(212)\n","plt.title('Classification Accuracy')\n","plt.plot(history.history['accuracy'], color='green', label='train')\n","plt.plot(history.history['val_accuracy'], color='red', label='val')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"Dc4OAmYxKnx2"},"source":["**Print the loss and the test accuracy.**"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":681,"status":"ok","timestamp":1667911659942,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"EaCBLBnCuVqS","outputId":"a9ec0947-db5d-40da-ec3e-ce67c973a940"},"outputs":[{"name":"stdout","output_type":"stream","text":["\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 6ms/step - accuracy: 0.9411 - loss: 0.2125\n","Test loss: 0.18668542802333832\n","Test accuracy: 0.9480000138282776\n"]}],"source":["test_loss, test_acc = model.evaluate(x_test, y_test)\n","print('Test loss:', test_loss)\n","print('Test accuracy:', test_acc)"]},{"cell_type":"markdown","metadata":{"id":"aBgqZkJ7Kod0"},"source":["**Print the confusion matrix for the test samples.**"]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":681,"status":"ok","timestamp":1667911662814,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"kAuXj1yGuFI5","outputId":"75d2df87-37e0-45c7-e925-4fc5bf37a75f"},"outputs":[{"name":"stdout","output_type":"stream","text":["\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 7ms/step\n","(10000, 10)\n"]}],"source":["import numpy as np\n","predictions = model.predict(x_test)\n","\n","print(predictions.shape)\n","predictions = np.argmax(predictions, axis=1)"]},{"cell_type":"code","execution_count":29,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3,"status":"ok","timestamp":1667911664497,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"c-0N628nuO4K","outputId":"ad2a7c8c-b226-4ba8-cc0b-6e874dc8122b"},"outputs":[{"data":{"text/plain":["array([[ 967,    0,    1,    2,    0,    2,    3,    2,    3,    0],\n","       [   0, 1119,    2,    2,    0,    2,    4,    1,    5,    0],\n","       [  11,    1,  955,   11,    9,    0,   13,    8,   20,    4],\n","       [   2,    0,   11,  961,    0,   12,    0,    9,   11,    4],\n","       [   1,    2,    2,    1,  939,    0,    9,    3,    4,   21],\n","       [   8,    2,    2,   23,    1,  824,   16,    3,    7,    6],\n","       [  10,    3,    3,    1,    8,   10,  920,    1,    2,    0],\n","       [   0,    7,   20,    8,    8,    0,    0,  961,    2,   22],\n","       [   7,    2,    7,   17,    6,    8,    8,    8,  902,    9],\n","       [  10,    6,    1,   13,   28,    3,    1,    9,    6,  932]])"]},"execution_count":29,"metadata":{},"output_type":"execute_result"}],"source":["confusion_matrix(gt, predictions)"]},{"cell_type":"markdown","metadata":{"id":"D-p2DMcsHOii"},"source":["# **Clearing models**\n","clear_session() is useful when you're creating multiple models in succession, such as during hyperparameter search or cross-validation. Each model that is trained adds nodes (potentially numbering in the thousands) to the graph. Clearing the session removes all the nodes left over from previous models, freeing memory and preventing slowdown."]},{"cell_type":"code","execution_count":30,"metadata":{"executionInfo":{"elapsed":10,"status":"ok","timestamp":1667911262298,"user":{"displayName":"Bhalaji Nagarajan","userId":"08128536337584225726"},"user_tz":-60},"id":"WfWCHxh8HGhN"},"outputs":[],"source":["from keras.backend import clear_session\n","clear_session()"]},{"cell_type":"markdown","metadata":{},"source":["### Thank you for following this tutorial !"]}],"metadata":{"accelerator":"GPU","colab":{"collapsed_sections":[],"provenance":[{"file_id":"1Y4KQehPAgpZLItGPmW0tfLdq3nBrQDpH","timestamp":1576576215149}]},"gpuClass":"standard","kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.11.9"}},"nbformat":4,"nbformat_minor":0}