\n",
+ "\n",
+ "## Research Question\n",
+ "\n",
+ "Can AI recognize pictures?\n",
+ "\n",
+ "## Agenda\n",
+ "\n",
+ "This is the standrad image data for developing neural network models and convolutional neural network models. \n",
+ "\n",
+ "- Neural Networks (1st meeting)\n",
+ "- Convolutional Neural Networks (2nd meeting)\n",
+ "\n",
+ "One you have the basic knowledge, there two tasks:\n",
+ "- First, you build a model to make good predictions on MNIST dataset\n",
+ "- Next, you will get a new data set that is similar and you will build advanced models to make good predictions on it. Plan: We use the MNIST Fashion dataset.\n",
+ "\n",
+ "Goal: To develop state-of-the-art CNN models.\n",
+ "\n",
+ "## Notes\n",
+ "\n",
+ "Most of the notes are taken using markdown area. To learn more diverse editting techniques for you to take quick notes using markdown, please click [here](https://colab.research.google.com/notebooks/markdown_guide.ipynb)."
+ ],
+ "metadata": {
+ "id": "ZgxIJ7VDkatT"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "An interesting visualization is here:\n",
+ "\n",
+ "
\n",
+ "\n",
+ "Given a picture, we can look at the pixel values. These pixel values provide information of the content/object in the image. These values are propagated into a network of neurons that are connected with lines (weights or also known as parameters) to be concluded to a final labeled category. The network architecture including width and length is completely dependent on the scientists and the data. "
+ ],
+ "metadata": {
+ "id": "tAPBhtVm72Ep"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Artificial Neural Networks"
+ ],
+ "metadata": {
+ "id": "VV3Qwh9lEiAp"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Load Data"
+ ],
+ "metadata": {
+ "id": "Rcuw1nh5jWmO"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# import library\n",
+ "import tensorflow as tf"
+ ],
+ "metadata": {
+ "id": "HqWLoP6nlSDP"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# use tf API to get data\n",
+ "mnist = tf.keras.datasets.mnist\n",
+ "(training_images, training_labels), (test_images, test_labels) = mnist.load_data()\n",
+ "print(training_images.shape)\n",
+ "print(training_images[0].shape)"
+ ],
+ "metadata": {
+ "id": "_rKryrdplThI",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "cd857924-9d92-4e09-a6ad-23540d1d4950"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
+ "11493376/11490434 [==============================] - 0s 0us/step\n",
+ "11501568/11490434 [==============================] - 0s 0us/step\n",
+ "(60000, 28, 28)\n",
+ "(28, 28)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# display dimension\n",
+ "training_images.shape, training_labels.shape, test_images.shape, test_labels.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "8_sHd0E_t701",
+ "outputId": "7661db24-e257-4424-8644-7b51f0f7ebce"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "((60000, 28, 28), (60000,), (10000, 28, 28), (10000,))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Save Using Pickle\n",
+ "\n",
+ "Sometimes the data you loaded is extremely large in sizes so we use pickle file to dump your data inside. This is to prevent that you lose the memory and record. The way to do this is whenever you run a chunk of cell with large memory you want to make sure have a pickle file ready to dump your data inside."
+ ],
+ "metadata": {
+ "id": "JYncHvoPpUp_"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# import\n",
+ "import os\n",
+ "import pickle"
+ ],
+ "metadata": {
+ "id": "8u_UMgRZpi4H"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# list directory\n",
+ "os.listdir()"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Jf8ZZukupnOn",
+ "outputId": "4c876f60-86d8-45a0-e514-69fadc2cc4d0"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "['.config',\n",
+ " 'my_model.png',\n",
+ " 'your_neuralnet_model.h5',\n",
+ " 'some_sample_nn_model.h5',\n",
+ " '.ipynb_checkpoints',\n",
+ " 'mnist_data.pkl',\n",
+ " 'sample_data']"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 66
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# dump: this means save the desired file into a pickle file\n",
+ "# note: a pickle file is a file ends with .pkl format\n",
+ "# b = (0, 1)\n",
+ "a = (training_images, training_labels), (test_images, test_labels)\n",
+ "with open('mnist_data.pkl', 'wb') as handle: \"write byte\"\n",
+ " pickle.dump(a, handle, protocol=pickle.HIGHEST_PROTOCOL)"
+ ],
+ "metadata": {
+ "id": "aXLSlnL-plEB"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# check if it exists in the current directory\n",
+ "os.listdir()"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "el3SiQwoqACF",
+ "outputId": "abb08fb8-2701-4358-e83c-4434aed14a25"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "['.config', 'mnist_data.pkl', 'sample_data']"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 8
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# load: this means start loading the desired file from the pickle file\n",
+ "# note: this means that you do a with-open clause, and grab whatever \n",
+ "# inside of the .pkl file and defined it as a new object\n",
+ "# please make sure the name and the directory are correct\n",
+ "with open('mnist_data.pkl', 'rb') as handle: \"read byte\"\n",
+ " b = pickle.load(handle)\n",
+ "\n",
+ "# preview\n",
+ "type(b), len(b)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "SvEpbvb5p22H",
+ "outputId": "385af606-d197-45cd-ef14-f8061d58d5ee"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tuple, 2)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 70
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# what is b?\n",
+ "print(b[0][0].shape, b[0][1].shape, b[1][0].shape, b[1][1].shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Us3wRy54qWR6",
+ "outputId": "51c3884d-e0a7-4d9f-f9df-5437f3c87526"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "The dimension says 60,000 by 28 by 28. This means the dataset has 60,000 images. Each image has 28 rows and 28 columns of pixels."
+ ],
+ "metadata": {
+ "id": "bfq_Gs8gmFem"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "'test_test'.split('_')"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "hvcA09KMaqlw",
+ "outputId": "1fe01757-1ea0-4481-edf4-9f72fdd78432"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "['test', 'test']"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 11
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# library\n",
+ "import matplotlib.pyplot as plt"
+ ],
+ "metadata": {
+ "id": "T2lZxDY7mKbs"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# plot one sample\n",
+ "plt.imshow(training_images[0])\n",
+ "plt.title('title: this is digit ' + str(training_labels[0]))\n",
+ "plt.colorbar()"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 298
+ },
+ "id": "HOtoxmiGmPwg",
+ "outputId": "6c727d1f-5292-4cbe-b43d-3b5c4e47ea6e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "execution_count": 13
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# library\n",
+ "import numpy as np"
+ ],
+ "metadata": {
+ "id": "bhTfDKGmrAAv"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# unique digits\n",
+ "np.unique(training_labels)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "YlMsNHasq4fd",
+ "outputId": "6cac861b-cd4e-484c-a38b-6ba3eb21073e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 15
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# display shape\n",
+ "training_labels.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "GPupey3-uwYz",
+ "outputId": "a4215e56-efa7-4052-ee09-4625412b621b"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(60000,)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 16
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### One hot encode\n",
+ "\n",
+ "We need to use *to_categorical* function to do one-hot encode. The operation of one-hot encode will check each unique level of the data and create a new binary vector for that level.\n",
+ "\n",
+ "For example, the vector below has 3 levels: 1, 3, 4. Hence, for each level (for each of the value 1, 3, 4), there will be a new vector created that only takes values 1 or 0.\n",
+ "\n",
+ "$$\n",
+ "\\begin{bmatrix}\n",
+ "1 \\\\\n",
+ "3 \\\\\n",
+ "1 \\\\\n",
+ "4 \\\\\n",
+ "\\end{bmatrix}\n",
+ "\\rightarrow_\\text{one hot}\n",
+ "\\begin{bmatrix}\n",
+ "1 & 0 & 0\\\\\n",
+ "0 & 1 & 0\\\\\n",
+ "1 & 0 & 0\\\\\n",
+ "0 & 0 & 1\\\\\n",
+ "\\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "Source is [here](https://www.tensorflow.org/api_docs/python/tf/keras/utils/to_categorical)."
+ ],
+ "metadata": {
+ "id": "sESMsDDYu-p0"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# unique classes\n",
+ "np.unique(training_labels), len(np.unique(training_labels))"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "PqwkDpjRGUgh",
+ "outputId": "030db2b6-521d-4b6f-c906-253481aa154a"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), 10)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 17
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# one hot encode\n",
+ "training_labels_one_hot_encoded = tf.keras.utils.to_categorical(training_labels, num_classes=10)\n",
+ "test_labels_one_hot_encoded = tf.keras.utils.to_categorical(test_labels, num_classes=10)"
+ ],
+ "metadata": {
+ "id": "_FwaQ3IKu98U"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# display shape\n",
+ "print(training_labels_one_hot_encoded.shape)\n",
+ "print(test_labels_one_hot_encoded.shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "aTpXkpmJ9eEI",
+ "outputId": "aa57190a-28f8-4aaa-abe1-6197ea8694f5"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "(60000, 10)\n",
+ "(10000, 10)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "This means there are 10 classes."
+ ],
+ "metadata": {
+ "id": "5NqgiOyFrCW8"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Process Data\n",
+ "\n",
+ "We want the data to be rescaled to between 0 and 1. We know that the pixel values can range from 0 to 255. To do this, we divide all pixels by 255.\n",
+ "\n",
+ "The purpose is to avoid the error blowing up. "
+ ],
+ "metadata": {
+ "id": "4UMB48rcnEaA"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# check max and min\n",
+ "np.max(training_images), np.min(training_images)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "u4acGxsf7JNZ",
+ "outputId": "f3870131-3570-4140-d9c7-b69924bab2e5"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(255, 0)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 20
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "(255-100)*28*28"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "-y9tyArRHAL4",
+ "outputId": "cdd05a77-1533-48af-fb21-1fc3d5f14fba"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "121520"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 21
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# rescale\n",
+ "training_images = training_images / 255\n",
+ "test_images = test_images / 255"
+ ],
+ "metadata": {
+ "id": "I_Tn8lHnnoY4"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# check max and min\n",
+ "np.max(training_images), np.min(training_images)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "FmsRRLuK7Npa",
+ "outputId": "9e78a5dc-1ed2-4bd1-be06-376339875c90"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(1.0, 0.0)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 23
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Activation Functions\n",
+ "\n",
+ "An Activation Function decides whether a neuron should be activated or not. This means that it will decide whether the neuron's input to the network is important or not in the process of prediction using simpler mathematical operations.\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "\n",
+ "Why use activation function? It is because we need to have non-linear component in each neuron."
+ ],
+ "metadata": {
+ "id": "aZa66Gqxpd6e"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Softmax Function\n",
+ "\n",
+ "The softmax function is used as the activation function in the output layer of neural network models that predict a multinomial probability distribution. That is, softmax is used as the activation function for multi-class classification problems where class membership is required on more than two class labels.\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
"
+ ],
+ "metadata": {
+ "id": "U6QvT3tpqXYM"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Regularization\n",
+ "\n",
+ "Regularization refers to techniques that are used to calibrate machine learning models in order to minimize the adjusted loss function and prevent overfitting or underfitting. Using Regularization, we can fit our machine learning model appropriately on a given test set and hence reduce the errors in it.\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "\n",
+ "If you are using L1 (this is the square one on the left), you are more likely to have sparse results (this means some of your weights are zeros). \n",
+ "\n",
+ "### Question: Is this good or bad?\n",
+ "\n",
+ "It depends. If you want to avoid overfitting way more than you do, use L1. If you don't really care about it, you can use L2. "
+ ],
+ "metadata": {
+ "id": "rQ650jz2sAmd"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Build an Artificial Neural Network"
+ ],
+ "metadata": {
+ "id": "IcgTqS1snuQw"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "test_x = np.array(np.ones((1, 20)))\n",
+ "model = tf.keras.models.Sequential([\n",
+ " tf.keras.layers.Flatten(),\n",
+ " tf.keras.layers.Dense(10, activation='softmax')\n",
+ "])\n",
+ "\n",
+ "result = model.predict(test_x)\n",
+ "final = np.sum(result[0])\n",
+ "final"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "VdWoUc86H4Ps",
+ "outputId": "8a0813dd-398e-4752-f45a-83e24b46051e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "0.99999994"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 24
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# use sequential api to build model\n",
+ "model = tf.keras.models.Sequential([\n",
+ " tf.keras.layers.Flatten(), # neural network requires the input layer to be a vector instead of 2D array\n",
+ " ## Your Changes Start Here ##\n",
+ " # Things to change:\n",
+ " # number of hidden layers\n",
+ " # number of neurons per hidden layer\n",
+ " # the activation functions: Please refer this website: https://keras.io/api/layers/activations/\n",
+ " # the kernel_regularizer: Please refer this website: https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/Regularizer\n",
+ " tf.keras.layers.Dense(1024, activation='relu', use_bias=True), # input units (usually starts with 128) and activation (it's a choice, usually relu)\n",
+ " tf.keras.layers.Dense(512, activation='relu', use_bias=True), # create more hidden layer if desired\n",
+ " tf.keras.layers.Dense(64, activation='relu', use_bias=True), # create more hidden layer if desired\n",
+ " # ... you can have however many you want\n",
+ " ## Your Changes Ends Here ##\n",
+ " tf.keras.layers.Dense(10, activation='softmax') # output layer or end layer | you have to match the number of classes\n",
+ "])"
+ ],
+ "metadata": {
+ "id": "vQU1dPsyn4un"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "(100+25)/2"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "C-JXsiSVbLFI",
+ "outputId": "8ed83150-3704-47b2-9598-8032b4d79bfe"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "62.5"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 26
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Loss Function: MSE\n",
+ "\n",
+ "What is a loss function? A loss function helps you to identify how many mistakes the model is making. The most common one (originated from linear regression) is L2 loss or also known as the square loss. This loss function is written below\n",
+ "\n",
+ "$$\\mathcal{L}(Y, \\hat{Y}) = \\frac{1}{n} \\sum_{i=1}^n (y_i - \\hat{y}_i)^2$$\n",
+ "\n",
+ "where the $Y$ is ground truth at a vector level and the $\\hat{Y}$ is the educated guess or estimate from the model at a vector level. The left hand side of the formula is defined by the right hand side which means that the vectors can be expanded using sub-index $i$. This sub-index $i$ is a running index indicating which sample the function is referring to. For example, let us take a look at the baby version below.\n",
+ "\n",
+ "For example, suppose we have a few data points below. Denote $y_i - \\hat{y}_i$ as \"diff\" for short hand nickname. Then the table below walks you through how to execute the above formula mathematically.\n",
+ "\n",
+ "| $i$ | $y_i$ | $\\hat{y}_i$ | $\\text{diff}$ | $\\text{diff}^2$ |\n",
+ "| --- | --- | --- | --- | --- |\n",
+ "| 1 | 10 | 20 | -10 | 100 |\n",
+ "| 2 | 10 | 5 | 5 | 25 |\n",
+ "\n",
+ "If you watch carefully, the formula is essentially $\\text{something}^2$ (we read \"something square\" or \"square of something\"), this means that it is a [convex function](https://en.wikipedia.org/wiki/Convex_function). Hence, there always exists an optimal point!!!"
+ ],
+ "metadata": {
+ "id": "aJHM4Ew8qxRt"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Loss Function: BCE\n",
+ "\n",
+ "If you are training a binary classifier, chances are you are using binary cross-entropy / log loss as your loss function. Loss Function: Binary Cross-Entropy / Log Loss takes the following form\n",
+ "\n",
+ "$$\\mathcal{L}(y, \\hat{y}) = -\\frac{1}{n} \\sum_{i=1}^n y_i \\log(\\hat{y}_i) + (1 - y_i) \\log (1-\\hat{y}_i)$$\n",
+ "\n",
+ "where $y$ is the label and $\\hat{y}$ is the predicted probability of the data point for all $n$ points.\n",
+ "\n",
+ "The plot below gives us a clear picture —as the predicted probability of the true class gets closer to zero, the loss increases exponentially:\n",
+ "\n",
+ "
\n",
+ "\n",
+ "Consider the following scenarios:\n",
+ "- If predicted probabilities $\\hat{y}_i$ is small (close to 0) and truth $y_i = 0$, what happens? \n",
+ "- If predicted probabilities $\\hat{y}_i$ is small (close to 0) and truth $y_i = 1$, what happens?\n",
+ "- If predicted probabilities $\\hat{y}_i$ is large (close to 1) and truth $y_i = 0$, what happens?\n",
+ "- If predicted probabilities $\\hat{y}_i$ is large (close to 1) and truth $y_i = 1$, what happens?\n",
+ "\n",
+ "Answers:\n",
+ "- If prediction $\\hat{y}_i = 0.001$ and $y_i = 0$, then the loss is $-(1-0)\\log(1-0.001)=-\\log(0.999) \\approx 0$, i.e. error is small so the model is good\n",
+ "- If prediction $\\hat{y}_i = 0.001$ and $y_i = 1$, then the loss is $-\\log(0.001)=-\\log(0.001) = 3$, i.e. the error is large so the model is bad\n",
+ "- If prediction $\\hat{y}_i = 0.999$ and $y_i = 0$, then the loss is $-(1-0)\\log(1-0.999)=-\\log(0.001)=3$, i.e. the error is large so the model is bad\n",
+ "- If prediction $\\hat{y}_i = 0.999$ and $y_i = 1$, then the loss is $-\\log(0.999) \\approx 0$, i.e. error is small so the model is good"
+ ],
+ "metadata": {
+ "id": "6rg8dWmS_Z2S"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "A good paper to refer to is [here](https://www.semanticscholar.org/paper/On-Loss-Functions-for-Deep-Neural-Networks-in-Janocha-Czarnecki/d589392ab606a3d2861988ebcba95176517939ec).\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
"
+ ],
+ "metadata": {
+ "id": "yukTGCV1BAK8"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Optimization\n",
+ "\n",
+ "An optimizer is an algorithm to search for the most optimal (some minimum value) on a loss surface. Recall the loss surface is how many mistakes the model is making, so it is intuitive that the desired point (the optimal point) is where the loss is small. The location where the loss is small is the \"best\" parameters we need in our model.\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "\n",
+ "- Animation of gradient descent is [here](https://towardsdatascience.com/a-visual-explanation-of-gradient-descent-methods-momentum-adagrad-rmsprop-adam-f898b102325c)\n",
+ "- Other animation can be found [here](https://towardsai.net/p/machine-learning/analysis-of-learning-rate-in-gradient-descent-algorithm-using-python)\n",
+ "\n",
+ "Today, there are many different upgrades of optimization algorithm. Please see below:\n",
+ "\n",
+ "
\n",
+ "\n",
+ "Given an image, we can use filters and matrix operation to combine a group of pixels into one feature. We can repeatedly do this for everywhere on the original image and we are able to create a list of new features. This is called feature mapping, which gives us new information to be connected into a neural network (or also known as dense layers in `tensorflow`) to create classified labels. "
+ ],
+ "metadata": {
+ "id": "h6QRHlwt8V7b"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "First, we introduce convolution operation. A convolution operation is like a matrix operation. It is defined as element-wise matrix multiplication.\n",
+ "\n",
+ "$$\n",
+ "\\underbrace{\n",
+ "\\begin{bmatrix}\n",
+ "1 & 2 & 3 \\\\\n",
+ "3 & 4 & 5 \\\\\n",
+ "5 & 6 & 7 \\\\\n",
+ "\\end{bmatrix}\n",
+ "}_\\text{image}\n",
+ "⊗\n",
+ "\\underbrace{\n",
+ "\\begin{bmatrix}\n",
+ "1 & 0 \\\\\n",
+ "1 & 0 \\\\ \n",
+ "\\end{bmatrix}\n",
+ "}_\\text{filter}\n",
+ "= \n",
+ "\\begin{bmatrix}\n",
+ "1 \\times 1 + 0 + 3 \\times 1 + 0 & 2 \\times 1 + 0 + 4 \\times 1 + 0 \\\\\n",
+ "3 \\times 1 + 0 + 5 \\times 1 + 0 & 4 \\times 1 + 0 + 6 \\times 1 + 0 \\\\\n",
+ "\\end{bmatrix}\n",
+ "=\n",
+ "\\begin{bmatrix}\n",
+ "4 & 6 \\\\\n",
+ "8 & 10 \\\\\n",
+ "\\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "Next, we introduce pooling. There are two types of pooling: (1) average pooling, and (2) maximum pooling.\n",
+ "\n",
+ "This is average pooling.\n",
+ "$$\n",
+ "\\text{ave}\\bigg(\n",
+ "\\begin{bmatrix}\n",
+ "4 & 6 \\\\\n",
+ "8 & 10 \\\\\n",
+ "\\end{bmatrix}\n",
+ "\\bigg) = (4 + 6 + 8 + 10) \\frac{1}{4} = 28/4 = 7\n",
+ "$$\n",
+ "\n",
+ "This is maximum pooling.\n",
+ "$$\n",
+ "\\text{max}\\bigg(\n",
+ "\\begin{bmatrix}\n",
+ "4 & 6 \\\\\n",
+ "8 & 10 \\\\\n",
+ "\\end{bmatrix}\n",
+ "\\bigg) = \\max\\{4, 6, 8, 10\\} = 10\n",
+ "$$\n"
+ ],
+ "metadata": {
+ "id": "u-OOkRPXzits"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## How does this work in a CNN?\n",
+ "\n",
+ "### Convolution layer (CONV)\n",
+ "\n",
+ "The convolution layer (CONV) uses filters that perform convolution operations as it is scanning the input $I$ with respect to its dimensions. Its hyperparameters include the filter size $F$ and stride $S$. The resulting output $O$ is called feature map or activation map. \n",
+ "\n",
+ "
\n",
+ "\n",
+ "### Pooling (POOL)\n",
+ "\n",
+ "The pooling layer (POOL) is a downsampling operation, typically applied after a convolution layer, which does some spatial invariance. In particular, max and average pooling are special kinds of pooling where the maximum and average value is taken, respectively.\n",
+ "\n",
+ "| Type | Max Pooling | Ave Pooling |\n",
+ "| --- | ----- | ------ |\n",
+ "| Purpose | Each pooling operation selects the maximum value of the current view | Each pooling operation averages the values of the current view |\n",
+ "| Illustration | | |\n",
+ "| Comments | Preserves detected features; Most commonly used | Downsamples feature map; Used in LeNet |\n",
+ "\n",
+ "### Fully Connected (FC)\n",
+ "\n",
+ "The fully connected layer (FC) operates on a flattened input where each input is connected to all neurons. If present, FC layers are usually found towards the end of CNN architectures and can be used to optimize objectives such as class scores.\n",
+ "\n",
+ "
\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "GYI5n8WO89wf"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# create a small convolutional layer\n",
+ "model = tf.keras.models.Sequential()\n",
+ "model.add(tf.keras.layers.Conv2D(1, (3,3), input_shape=(28, 28, 1)))\n",
+ "model.add(tf.keras.layers.MaxPooling2D())\n",
+ "\n",
+ "# remark:\n",
+ "# This is a very simple model. Though it is called a model,\n",
+ "# it is actually not a neural network yet. Because there is \n",
+ "# no dense layers yet. We just want to see what the Conv2D function\n",
+ "# does to the pictures.\n",
+ "# summary\n",
+ "model.summary()"
+ ],
+ "metadata": {
+ "id": "zWiAHXVl-1gh",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "64045251-c74b-4fa2-d132-4d1463b0a0eb"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Model: \"sequential_2\"\n",
+ "_________________________________________________________________\n",
+ " Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ " conv2d (Conv2D) (None, 26, 26, 1) 10 \n",
+ " \n",
+ " max_pooling2d (MaxPooling2D (None, 13, 13, 1) 0 \n",
+ " ) \n",
+ " \n",
+ "=================================================================\n",
+ "Total params: 10\n",
+ "Trainable params: 10\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# before model fitting, let us just throw in 1 image\n",
+ "sample_output_before_fitting = model.predict(training_images[0].reshape((1, 28, 28, 1)))"
+ ],
+ "metadata": {
+ "id": "O54e0JCuCQRQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# reshape\n",
+ "sample_output_2darray = sample_output_before_fitting.reshape((13, 13))\n",
+ "plt.imshow(sample_output_2darray)"
+ ],
+ "metadata": {
+ "id": "2rBCKRhXC3Ku",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 282
+ },
+ "outputId": "ca2c1d79-4864-43b3-b5dc-ad5bc949eaa7"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "execution_count": 48
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# build a CNN (Convolutional Neural Network) model\n",
+ "model = tf.keras.models.Sequential(name=\"MODEL_JohnSmith\")\n",
+ "## Your Changes Start Here ##\n",
+ "model.add(tf.keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation='relu', input_shape=(28, 28, 1), name=\"Conv_1\"))\n",
+ "model.add(tf.keras.layers.MaxPooling2D())\n",
+ "model.add(tf.keras.layers.Conv2D(filters=64, kernel_size=(2,2), activation='relu', name=\"Conv_2\"))\n",
+ "model.add(tf.keras.layers.MaxPooling2D()) \n",
+ "# You can have more CONVOLUTIONAL layers! # <===== TRY TO TUNE THIS!!!\n",
+ "# Each convolutional layer can have arbitrary different number of units! # <===== TRY TO TUNE THIS!!!\n",
+ "# ... you can have however many you want\n",
+ "## Your Changes Ends Here ##\n",
+ "# up to here, we finish coding the convolutional layers, we have not done neural network layers\n",
+ "\n",
+ "# build neural network layers\n",
+ "model.add(tf.keras.layers.Flatten()) # neural network requires the input layer to be a vector instead of 2D array\n",
+ "## Your Changes Start Here ##\n",
+ "model.add(tf.keras.layers.Dense(256, activation='relu', use_bias=True)) # input units (usually starts with 128) and activation (it's a choice, usually relu)\n",
+ "model.add(tf.keras.layers.Dense(128, activation='relu', use_bias=True)) # input units (usually starts with 128) and activation (it's a choice, usually relu)\n",
+ "# You can have more DENSE layers! # <===== TRY TO TUNE THIS!!!\n",
+ "# Each dense layer can have arbitrary different number of units! # <===== TRY TO TUNE THIS!!!\n",
+ "# ... you can have however many you want\n",
+ "## Your Changes Ends Here ##\n",
+ "model.add(tf.keras.layers.Dense(10, activation='softmax')) # output layer or end layer | you have to match the number of classes\n",
+ "# summary\n",
+ "model.summary()"
+ ],
+ "metadata": {
+ "id": "S7hWzQHGDwBL",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "349a460b-7ac8-4b3e-875e-9697fcfa8d3a"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Model: \"MODEL_JohnSmith\"\n",
+ "_________________________________________________________________\n",
+ " Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ " Conv_1 (Conv2D) (None, 26, 26, 32) 320 \n",
+ " \n",
+ " max_pooling2d_1 (MaxPooling (None, 13, 13, 32) 0 \n",
+ " 2D) \n",
+ " \n",
+ " Conv_2 (Conv2D) (None, 12, 12, 64) 8256 \n",
+ " \n",
+ " max_pooling2d_2 (MaxPooling (None, 6, 6, 64) 0 \n",
+ " 2D) \n",
+ " \n",
+ " flatten_2 (Flatten) (None, 2304) 0 \n",
+ " \n",
+ " dense_5 (Dense) (None, 256) 590080 \n",
+ " \n",
+ " dense_6 (Dense) (None, 128) 32896 \n",
+ " \n",
+ " dense_7 (Dense) (None, 10) 1290 \n",
+ " \n",
+ "=================================================================\n",
+ "Total params: 632,842\n",
+ "Trainable params: 632,842\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# plot using a utility function\n",
+ "tf.keras.utils.plot_model(model, to_file=\"my_model.png\", show_shapes=True, show_layer_names=True)\n",
+ "# where is it? \n",
+ "# This file, my_model.png, is under your Colab folder.\n",
+ "# Go to the left, click on the \"Folder\" button, and you should see this png file."
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 976
+ },
+ "id": "eEQfok7KEzdN",
+ "outputId": "358edf3d-d1f9-4d18-ba45-7a193f8daf74"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "execution_count": 50
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# compile\n",
+ "model.compile(\n",
+ " ## Your Changes Start Here ##\n",
+ " # optimizer: https://keras.io/api/optimizers/\n",
+ " # loss: https://keras.io/api/losses/\n",
+ " optimizer=\"adam\",\n",
+ " loss=\"categorical_crossentropy\",\n",
+ " ## Your Changes Ends Here ##\n",
+ " metrics=['accuracy']\n",
+ ")"
+ ],
+ "metadata": {
+ "id": "AeaYQBpqFBRF"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# load gpu\n",
+ "%tensorflow_version 2.x\n",
+ "import tensorflow as tf\n",
+ "device_name = tf.test.gpu_device_name()\n",
+ "if device_name != '/device:GPU:0':\n",
+ " raise SystemError('GPU device not found')\n",
+ "print('Found GPU at: {}'.format(device_name))"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "BG9ViI6IFh-c",
+ "outputId": "7ca78c1b-a9a8-407d-a69f-fbc866250e13"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found GPU at: /device:GPU:0\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# fit | we train the model here\n",
+ "# use GPU\n",
+ "with tf.device('/device:GPU:0'):\n",
+ " history = model.fit(\n",
+ " training_images, training_labels_one_hot_encoded,\n",
+ " validation_split=0.2,\n",
+ " ## Your Changes Start Here ##\n",
+ " # there is a sweet spot, you don't want to overfit, but you also want to make sure your model learned something\n",
+ " epochs=10\n",
+ " ## Your Changes Ends Here ##\n",
+ " )"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "e5Ud7WCuFbnU",
+ "outputId": "304890ef-3fe2-4bb1-9d2a-2f2debf08148"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Epoch 1/10\n",
+ "1500/1500 [==============================] - 6s 3ms/step - loss: 0.1449 - accuracy: 0.9550 - val_loss: 0.0569 - val_accuracy: 0.9818\n",
+ "Epoch 2/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0457 - accuracy: 0.9861 - val_loss: 0.0664 - val_accuracy: 0.9784\n",
+ "Epoch 3/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0316 - accuracy: 0.9898 - val_loss: 0.0424 - val_accuracy: 0.9879\n",
+ "Epoch 4/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0236 - accuracy: 0.9923 - val_loss: 0.0422 - val_accuracy: 0.9880\n",
+ "Epoch 5/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0184 - accuracy: 0.9942 - val_loss: 0.0446 - val_accuracy: 0.9870\n",
+ "Epoch 6/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0153 - accuracy: 0.9948 - val_loss: 0.0596 - val_accuracy: 0.9855\n",
+ "Epoch 7/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0118 - accuracy: 0.9963 - val_loss: 0.0444 - val_accuracy: 0.9889\n",
+ "Epoch 8/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0110 - accuracy: 0.9965 - val_loss: 0.0474 - val_accuracy: 0.9893\n",
+ "Epoch 9/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0094 - accuracy: 0.9967 - val_loss: 0.0508 - val_accuracy: 0.9888\n",
+ "Epoch 10/10\n",
+ "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0084 - accuracy: 0.9974 - val_loss: 0.0569 - val_accuracy: 0.9879\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Evaluation"
+ ],
+ "metadata": {
+ "id": "39NRc5Tm6dH9"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# quick evaluation on test set\n",
+ "this_final_loss_, this_final_acc_ = model.evaluate(test_images, test_labels_one_hot_encoded)\n",
+ "print('Test Result: Loss is '+str(this_final_loss_)+', and accuracy is '+str(this_final_acc_))"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "8593abcf-4f00-4412-c8b4-16af01003479",
+ "id": "Wwf9NNPF6dIC"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "313/313 [==============================] - 1s 3ms/step - loss: 0.0457 - accuracy: 0.9889\n",
+ "Test Result: Loss is 0.045678623020648956, and accuracy is 0.9889000058174133\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Visualize Performance"
+ ],
+ "metadata": {
+ "id": "xIb2ZZKxGEHu"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "plt.plot(history.history['loss'])\n",
+ "plt.plot(history.history['val_loss'])\n",
+ "plt.legend(['loss', 'val_loss'])\n",
+ "plt.title('loss')"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 298
+ },
+ "outputId": "99ed35bc-ba56-4316-cfde-c6e2e96b25bf",
+ "id": "odz4GzkbGEHz"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "Text(0.5, 1.0, 'loss')"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 55
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEICAYAAABRSj9aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3xU1bn/8c+TZHJPSALhEggkKF64iiSoVdGWqlgFar3gteppa39VtFZrtbW11tqLtbZ6WlvrsV7qpUBRj6hUWpUW7bGYyNWAUoQQQkBCEgIkhNye3x9rQiYhwIRMmMye5/168crMnj0zK/Mi373m2WuvJaqKMcYY74oJdwOMMcb0Lgt6Y4zxOAt6Y4zxOAt6Y4zxOAt6Y4zxOAt6Y4zxOAt6E/VEpFREPh/udhjTWyzojTHG4yzojTHG4yzojfETkQQReVhEKvz/HhaRBP9jA0TkNRHZKSLVIvKOiMT4H7tTRLaIyG4R+VhEpob3NzGmo7hwN8CYPuRu4FTgJECBV4DvAz8AbgfKgWz/vqcCKiLHA7OBQlWtEJE8IPboNtuYQ7MevTHtrgLuU9XtqloJ/Ai4xv9YEzAEGKGqTar6jrqJolqABGC0iPhUtVRVPwlL6405CAt6Y9rlAJsC7m/ybwN4EFgP/E1ENojIXQCquh64FbgX2C4ic0QkB2P6EAt6Y9pVACMC7g/3b0NVd6vq7ao6EpgB3NZWi1fVF1T1DP9zFXjg6DbbmEOzoDem3Z+B74tItogMAO4BngMQkQtF5FgREaAWV7JpFZHjReRz/pO2DcBeoDVM7TemSxb0xrS7HygGVgGrgWX+bQCjgDeBPcB7wO9UdTGuPv9zYAewDRgIfPfoNtuYQxNbeMQYY7zNevTGGONxFvTGGONxFvTGGONxFvTGGONxfW4KhAEDBmheXl64m2GMMRHlgw8+2KGq2V091ueCPi8vj+Li4nA3wxhjIoqIbDrYY1a6McYYj7OgN8YYj7OgN8YYj+tzNXpjTHRqamqivLychoaGcDelT0tMTGTYsGH4fL6gn2NBb4zpE8rLy0lLSyMvLw83d5zpTFWpqqqivLyc/Pz8oJ9npRtjTJ/Q0NBA//79LeQPQUTo379/t7/1WNAbY/oMC/nDO5LPyDNBv7O+kUfe/A8fbqkNd1OMMaZP8UyNPjZGeOStdbSqMnZov3A3xxgTgVJTU9mzZ0+4mxFynunRpyX6OGFwOsWbqsPdFGOM6VM8E/QAhXmZLC/bSVOLreRmjDlyqsodd9zB2LFjGTduHHPnzgVg69atTJkyhZNOOomxY8fyzjvv0NLSwnXXXbd/31//+tdhbv2BPFO6ASjIy+KZ9zaxdusuxg/LCHdzjDFH6EevlrCmYldIX3N0Tjo/nD4mqH1feuklVqxYwcqVK9mxYweFhYVMmTKFF154gfPOO4+7776blpYW6uvrWbFiBVu2bOHDDz8EYOfOnSFtdygE1aMXkWki8rGIrBeRu7p4fIqILBORZhG5pIvH00WkXER+G4pGH0xhXhYA72+08o0x5si9++67XHHFFcTGxjJo0CDOOussioqKKCws5KmnnuLee+9l9erVpKWlMXLkSDZs2MDNN9/MG2+8QXp6eribf4DD9uhFJBZ4FDgHKAeKRGSBqq4J2K0MuA749kFe5sfAkp419fAG90skNyuJ4tIavnpmb7+bMaa3BNvzPtqmTJnCkiVLeP3117nuuuu47bbb+PKXv8zKlStZtGgRjz32GPPmzePJJ58Md1M7CKZHPxlYr6obVLURmAPMDNxBVUtVdRVwQHFcRCYBg4C/haC9h1U4IoviTdXYoufGmCN15plnMnfuXFpaWqisrGTJkiVMnjyZTZs2MWjQIL72ta/x1a9+lWXLlrFjxw5aW1u5+OKLuf/++1m2bFm4m3+AYGr0Q4HNAffLgVOCeXERiQEeAq4GPn+I/W4AbgAYPnx4MC99UAV5Wby0fAulVfXkD0jp0WsZY6LTRRddxHvvvceECRMQEX7xi18wePBgnnnmGR588EF8Ph+pqan86U9/YsuWLVx//fW0trp+7s9+9rMwt/5AvX0y9kZgoaqWH+pqLlV9HHgcoKCgoEdd8cn5mQAUbay2oDfGdEvbGHoR4cEHH+TBBx/s8Pi1117Ltddee8Dz+mIvPlAwpZstQG7A/WH+bcE4DZgtIqXAL4Evi8jPu9XCbjomO5XMZB9FpXZC1hhjILgefREwSkTycQF/OXBlMC+uqle13RaR64ACVT1g1E4oiQiTRmRRvKmmN9/GGGMixmF79KraDMwGFgFrgXmqWiIi94nIDAARKRSRcuBS4A8iUtKbjT6cwrxMNu6oo3L3vnA2wxhj+oSgavSquhBY2GnbPQG3i3AlnUO9xtPA091u4REozHfj6YtLqzl/3JCj8ZbGGNNneWoKhDZjc/qREBdDUamVb4wxxpNBHx8Xw0m5GTbBmTHG4NGgBzcdQknFLur2NYe7KcYYE1beDfr8LFpaleVlfW+CIWNM5EtNTT3oY6WlpYwdO/YotubQPBv0Jw/PIEaw8fTGmKjnqWmKA9lCJMZEsL/eBdtWh/Y1B4+D8w9+veZdd91Fbm4uN910EwD33nsvcXFxLF68mJqaGpqamrj//vuZOXPmQV+jKw0NDXzjG9+guLiYuLg4fvWrX/HZz36WkpISrr/+ehobG2ltbeXFF18kJyeHyy67jPLyclpaWvjBD37ArFmzevRrg4eDHtx4+r98UE5TSyu+WM9+eTHGhMCsWbO49dZb9wf9vHnzWLRoEbfccgvp6ens2LGDU089lRkzZnRrge5HH30UEWH16tV89NFHnHvuuaxbt47HHnuMb37zm1x11VU0NjbS0tLCwoULycnJ4fXXXwegtjY0a2B7O+jz3UIkayp2MSHXFiIxJmIcoufdWyZOnMj27dupqKigsrKSzMxMBg8ezLe+9S2WLFlCTEwMW7Zs4dNPP2Xw4MFBv+67777LzTffDMAJJ5zAiBEjWLduHaeddho/+clPKC8v50tf+hKjRo1i3Lhx3H777dx5551ceOGFnHlmaOZb93Q3t2CEu3DK6vTGmGBceumlzJ8/n7lz5zJr1iyef/55Kisr+eCDD1ixYgWDBg2ioaEhJO915ZVXsmDBApKSkvjCF77A22+/zXHHHceyZcsYN24c3//+97nvvvtC8l6eDvrAhUiMMeZwZs2axZw5c5g/fz6XXnoptbW1DBw4EJ/Px+LFi9m0aVO3X/PMM8/k+eefB2DdunWUlZVx/PHHs2HDBkaOHMktt9zCzJkzWbVqFRUVFSQnJ3P11Vdzxx13hGxWTE+XbsCNp1+yrhJV7VZdzRgTfcaMGcPu3bsZOnQoQ4YM4aqrrmL69OmMGzeOgoICTjjhhG6/5o033sg3vvENxo0bR1xcHE8//TQJCQnMmzePZ599Fp/Px+DBg/ne975HUVERd9xxBzExMfh8Pn7/+9+H5PeSvrYSU0FBgRYXF4fs9f78fhnffWk1b99+FiOzDz7u1RgTXmvXruXEE08MdzMiQleflYh8oKoFXe3v6dINuJE3gJVvjDFRy/Olm8CFSC4rzD38E4wxJkirV6/mmmuu6bAtISGBpUuXhqlFXfN80IsIBXm2EIkxkSDSzqWNGzeOFStWHNX3PJJyu+dLN9C+EMn23aEZFmWMCb3ExESqqqqOKMiihapSVVVFYmJit57n+R49QEGeG0//QWmNLURiTB81bNgwysvLqaysDHdT+rTExESGDTvkOk8HiIqgH5vTj0SfW4jEgt6Yvsnn85Gfnx/uZnhSVJRubCESY0w0i4qgB1uIxBgTvYIKehGZJiIfi8h6Ebmri8eniMgyEWkWkUsCtp8kIu+JSImIrBKRns+3eYQK8mwhEmNMdDps0ItILPAocD4wGrhCREZ32q0MuA54odP2euDLqjoGmAY8LCJhmUbSFiIxxkSrYE7GTgbWq+oGABGZA8wE1rTtoKql/sdaA5+oqusCbleIyHYgGzjq3eq0RB8nDrGFSIwx0SeY0s1QYHPA/XL/tm4RkclAPPBJF4/dICLFIlLcm0OrCvOyWLZpJ00trYff2RhjPOKonIwVkSHAs8D1qnpAyqrq46paoKoF2dnZvdaOgrxM9ja1sKZiV6+9hzHG9DXBBP0WIHCSmGH+bUERkXTgdeBuVf1395oXWoV5thCJMSb6BBP0RcAoEckXkXjgcmBBMC/u3/9l4E+qOv/Imxkag9ITGZ6VbEFvjIkqhw16VW0GZgOLgLXAPFUtEZH7RGQGgIgUikg5cCnwBxEp8T/9MmAKcJ2IrPD/O6lXfpMgFeRlUlxaY/NpGGOiRlBTIKjqQmBhp233BNwuwpV0Oj/vOeC5HrYxpArzsnhp2RY27qizhUiMMVEhaq6MbWMLkRhjok3UBX3bQiTvW53eGBMloi7o9y9EYkFvjIkSURf04Mo3pVX1thCJMSYqRGXQBy5EYowxXheVQd+2EInV6Y0x0SAqg37/QiTWozfGRIGoDHpoW4iklj22EIkxxuOiOuhbFVbYQiTGGI+L2qCf6F+IxOr0xhivi9qg378QiQW9McbjojbowZVvlpfZQiTGGG+L+qC3hUiMMV4X1UFf4J/gzOanN8Z4WVQHvS1EYoyJBlEd9GALkRhjvC/qg35yXhZVdY1s3FEX7qYYY0yviPqgL7AFw40xHhf1QX9MdgqZyT6KbN4bY4xHRX3Q20IkxhivCyroRWSaiHwsIutF5K4uHp8iIstEpFlELun02LUi8h//v2tD1fBQmpyXZQuRGGM867BBLyKxwKPA+cBo4AoRGd1ptzLgOuCFTs/NAn4InAJMBn4oIpk9b3ZoFdiC4cYYDwumRz8ZWK+qG1S1EZgDzAzcQVVLVXUV0HkugfOAv6tqtarWAH8HpoWg3SE1xr8QiZ2QNcZ4UTBBPxTYHHC/3L8tGEE9V0RuEJFiESmurKwM8qVDxxYiMcZ4WZ84Gauqj6tqgaoWZGdnh6UNk20hEmOMRwUT9FuA3ID7w/zbgtGT5x5VBf6FSJaXWa/eGOMtwQR9ETBKRPJFJB64HFgQ5OsvAs4VkUz/Sdhz/dv6nLaFSGw8vTHGaw4b9KraDMzGBfRaYJ6qlojIfSIyA0BECkWkHLgU+IOIlPifWw38GHewKALu82/rc2whEmOMV8UFs5OqLgQWdtp2T8DtIlxZpqvnPgk82YM2HjWFeVnMLdpMU0srvtg+cfrCGGN6zNIsQNtCJCW2EIkxxkMs6AO0Xzhl5RtjjHdY0AewhUiMMV5kQd9JYV6WLURijPEUC/pOCvMyqaprZIMtRGKM8QgL+k7aFiKxOr0xxiss6Ds5JjuFrJR4u3DKGOMZFvSdiAgFIzLthKwxxjMs6LtQmJfFpqp6tu+yhUiMMZHPgr4L+8fTb7LyjTEm8lnQd2HsUFuIxBjjHRb0XfDFxjAx1+r0xhhvsKA/iMK8TNZU7LKFSIwxEc+C/iBsIRJjjFdY0B/EySMybSESY4wnWNAfRGpCHKNz0inaaHV6Y0xks6A/hIIRWSzfXENTS2u4m2KMMUfMgv4QCvOyaGhqtYVIjDERzYL+EAptIRJjjAdY0B/CwPRERvRP5n2r0xtjIlhQQS8i00TkYxFZLyJ3dfF4gojM9T++VETy/Nt9IvKMiKwWkbUi8t3QNr/3FYzIoniTLURijIlchw16EYkFHgXOB0YDV4jI6E67fQWoUdVjgV8DD/i3XwokqOo4YBLw9baDQKQozMuk2hYiMcZEsGB69JOB9aq6QVUbgTnAzE77zASe8d+eD0wVEQEUSBGROCAJaAQi6sxmYb4tRGKMiWzBBP1QYHPA/XL/ti73UdVmoBbojwv9OmArUAb8UlUPSEwRuUFEikWkuLKystu/RG8aOcAtRPL+RrtwyhgTmXr7ZOxkoAXIAfKB20VkZOedVPVxVS1Q1YLs7OxeblL3tC1EUrzJevTGmMgUTNBvAXID7g/zb+tyH3+Zph9QBVwJvKGqTaq6HfgXUNDTRh9tthCJMSaSBRP0RcAoEckXkXjgcmBBp30WANf6b18CvK1umEoZ8DkAEUkBTgU+CkXDj6b9dXpbiMQYE4EOG/T+mvtsYBGwFpinqiUicp+IzPDv9kegv4isB24D2oZgPgqkikgJ7oDxlKquCvUv0dvG5KST6Iux8fTGmIgUF8xOqroQWNhp2z0BtxtwQyk7P29PV9sjTdtCJFanN8ZEIrsyNki2EIkxJlJZ0AepMN8WIjHGRCYL+iBNHO5fiMTq9MaYCGNBH6T9C5HYilPGmAhjQd8NthCJMSYSWdB3w+R8W4jEGBN5LOi7oWCEW4jE6vTGmEhiQd8NbQuRFNlMlsaYCGJB302FebYQiTEmsljQd5MtRGKMiTQW9N1UkOcmOLM6vTEmUljQd9PIASn0T4m38fTGmIhhQd9NIkJBnk1wZoyJHBb0R+CgC5Hs3gb/fBCevhC2RtxszMYYjwpqmmLT0f46fWkNF4wdBBv/CcVPwscLobUZ4lPhTzPhutdh0Ogwt9YYE+0s6I/AmJx0hvjq8C39LfxjIVRvgKQsOOX/waTrQQSe+gL8aYYL++zjw91kY0wUs6DvDlUo+ze+4idZEvsyvi1NMPw0OPu7cOIM8CW273vtq/D0BfDMDLh+IfQ/JnztNsZENavRB6OhFpY+Dr87DZ6aBuve4MMhFzGt8QH2XPUajL+sY8gDZB8H1y6A1iZ4ZjpUbwxP240xUc+C/lC2LINXZsNDJ8Bf7wBfEsz4Ddz+EXs+91M+as1l2aEWDB94Inz5FWiqdz37nWVHr+3GGONnpZvO9u2BD+e7k6tbV4IvGcZdCgXXQ87E/btNHJ5AjEBxaTVTjss++OsNHgfX/K+r1z8zHa5bCP2GHoVfxBhjnKB69CIyTUQ+FpH1InJXF48niMhc/+NLRSQv4LHxIvKeiJSIyGoRSez8/D7h0xJ4/XbXe3/1m9DSBF/4Jdz+Ecz47w4hD24hkjE5/YK7cCrnJLj6ZaircmG/e1sv/RLGGHOgw/boRSQWeBQ4BygHikRkgaquCdjtK0CNqh4rIpcDDwCzRCQOeA64RlVXikh/oCnkv8WRatoLa15xvffNSyE2AcZcBAX/BbmT3eiZQyjIy+TP75fR2NxKfNxhjpnDJsHVL8KzF/l79q9D6sAQ/jLGGNO1YHr0k4H1qrpBVRuBOcDMTvvMBJ7x354PTBURAc4FVqnqSgBVrVLVltA0vQd2rIdFd8OvToSXvw71VXDuT1zv/Ut/gOGnHDbkwV045RYiqQ3ufYefAlf9BXZuduPs66p6+IuYiGOznpowCCbohwKbA+6X+7d1uY+qNgO1QH/gOEBFZJGILBOR73T1BiJyg4gUi0hxZWVld3+H4DQ3QsnLrjf920mw9DEYebYbBjm7GD4zG5KzuvWSBXluIZLi7sx7k3c6XDnHjb1/dibU21QKUUEVVs93pcG511j5zhxVvT3qJg44A7jK//MiEZnaeSdVfVxVC1S1IDv7ECc2j0TNJnjrPvj1GPjLdVBTClPvgW+tgUufhvwpQfXeuzIwLZG8I1mIZOTZcPnzUPkxPPclN3zTeFdtOfz5cnjxK5CUCesWwaOTYflz1sM3R0Uwo262ALkB94f5t3W1T7m/Lt8PqML1/peo6g4AEVkInAy81cN2H1pLM/znb672vv5NF+THne9GzhzzOYiJDdlbFeRl8fZH21FVpDsHjGM/D5c9C3OvhucuhmtehoS0kLXL9AGtrVD8R3jzXtBWOO9ncMrX3be5BTfDKze5Xv70RyBzRLhbazwsmB59ETBKRPJFJB64HFjQaZ8FwLX+25cAb6tbgmkRME5Ekv0HgLOANfSWXRXwjwfgkfEw5wr49EM46064dTVc8QKMOiekIQ/tC5F8UnkEC5EcPw0ufcqN13/+Umi0xUw8o/Jjd3Hdwm+7E/s3vgen3ej+/w0Y5YbZfuGXUF7kLsT792PQGv7TVyaM6qrg096Jx8P26FW1WURm40I7FnhSVUtE5D6gWFUXAH8EnhWR9UA17mCAqtaIyK9wBwsFFqrq673ym1R9Ar8tBG2BY6bC+b+A46ZBbO9eKtA2wVlxaTXHDkzt/gucOB0ufsJ9rX9hFlw5D+KTQ9xKc9Q0N8K7v4Z3fgnxKfDFx2DC5QeWB2NiYPLX3P/R126FN+6EkpfcBXk2N1J0aKyDTe/BhsVuYsRtH7ph3DcsDvlbSV9b+7SgoECLi4u7/0RV+Pfv4PjzIWtk6Bt20LdVCu5/k7OPH8hDl0048hdaNQ9eusHV76+Yc+CUCqbvKy92JZnta2DsxTDtAUgN4pyTKqyaC2/c5f74z/oOnH4rxPp6v83m6GluhC0fuFDf8E/3ba61CWLjIfcUyD/L/f3nFh7Ry4vIB6pa0NVj3rkyVgROuykMb+sWIun2CdnOxl/mLtJ65UaYdw3Meg7iEkLTSNO79u2Bt+93I7nSc+CKua4sFywR1+s/5nPw1++41yp5BWb+5oAL9UwEaW115eO2YN/0f9BUB4i7iPK0m2DkWZB7aq9/i/dO0IdRYV4Wi0o+5dNdDQxK70FPfOJV0NLovsr/5Tq49BmIiw9ZO00vWP8mvPotqC2Dwq+5EV2J6Uf2WqkD3UiwsZe4q7T/Zyp85mY4+y43z5Lp21Tdifa2YC99x12jA9B/FJx0heux553hRl8dRRb0IdBep6/hgvFDevhi17vFSxZ+29XtL3mq188zmCNQVwWLvger5sCA4+C/FsHwU0Pz2ide6MLgb9+Hfz0Ma191tfu800Pz+iZ0dm+DjUtcsG/8J9T6LzlKy4FR5/rLMWe5b3phZAkSAmNy0knyxVJUWt3zoAd3kq6l0QXJyzfAl/4n5KOFzBFqu/DpjTvd9Q9TvgNTvh36MltSBsz8LYy7BBbcAk9/AQq/ClN/eOTfGEzPNdRC6bvtwV75kduemAH5Z8Lp33S99v7HHvH1Ob3Bgj4EfLExTBye0fM6faDTbnI1+zd/6E7WzPydG6lhwmfnZnj9NneNxtBJrpc9aEzvvufIs93QzLfvh3//Hj5+A6Y/7IYKm97X1ACb/90e7BXL3TURcUkw4jSYcIXrsQ8e36c7Yxb0IVKQl8Vv3/4PuxuaSEsM0WiJM251PfvFP3EjMC58xMI+HFpboegJeOtH7o982s9h8g1H7w87PgWm/QzGfAkWzIbnL4Hxs9wFWCn9j04bokVLM2xdARv+4YK9bCm07AOJdQf3M2935ZjcyRE1WMKCPkQm52XRqrC8bOeh56fvrrO+48J+yYMQ44MLHupTXwk9b/tHbshk+ftuVMyFD4fvKtbcQvj6EnjnIfdv/VvwhQfdjKv2f6L7VKFuB1R/4tae2PBPV5bZ55+SZOAYKPyKC/YRn4nokpkFfYicNDyD2Bg5/EIkR+Kzd7uw/9cjrowz7Wf2h93bOl/4dNEfXC863J97XAJ89ntujeIFs2H+9e6cwQUPQXoIzg95UX21Gw1T9YkL9cCf+3a175cxAsbMdMGef1Zw10BECAv6EElNiGP0kHTeD2Wdvo0IfP5Hrmb/79+5UTjn/Dj8oeNVm4tcL75yrRvqOO3nfe+PfvBY+Mqb7v/D4p/Ao6fAeffDxGui8//Fvt0dAzzw9t7Av0mBjFzIOsZdu5J1jDtxmn28p+cbsqAPoW4tRNJdInDeT13P/v9+43r2n/tBdP5R95Z9e+DtH8PSP0D6UDcdxXHnhbtVBxcbB6ffAidc4EbmLLgZVv8Fpv83ZOWHu3Wh11jveuZdhXnd9o77pg91V8iPntEe5v2Pgcy8iKqth4oFfQhNzsviqX+VUlJRy8ThvXBBhAic/6Dr2b/zkFsR6+w7Q/8+0eg/b7oL1WrL3fDWqfdEzmyi/Y9x6yosewb+9gP4/WdcJ+CUr/fpkSBdat4H1RsPLLFUfQK7KzrumzrIhfhx5/rD3B/omfk2X1QnFvQhNClgIZJeCXpwo24ufNhdVPWPn7rROGfe1jvvFQ3qqtwcM6vnwYDj/Rc+nRLuVnVfTIy72G7UufDat2DRd+HDF91Y/IEnhrt1He3bAzs3ubUiako7hnptuRvZ1Ca5vwvxkWf5w3xke6hHyoG4D7CgD6G2hUjeL63ma1N6cWK1mBg3hrul0Q35i413K2SZ4Km6Mscbd0HDLjed9Zm3R/7X+n5D4cq5LuT/+h147EyYcgec8a2jN51Gc6O7QrSmtD3QA3/Wd1pCM6GfC+7cU2DCle52W6gf5akCvMqCPsQK8rJ4a+2n3V+IpLtiYt0UuC1N8Le7XdifckPvvZ+X7CyD126D9X+HoQX+C59Gh7tVoSPirqgdeTb89U73zW+Nf5K0oZN6/vqtLbB764EB3vZzVwVuVnK/GJ87AZoxwk3LnTHCnfjMyHM/k/vbuaZeZkEfYpPzspj/QTl/KS7n0oJhvRv2sXFuLvvWZvjrHe5+wX/13vtFutYWd+HTmz9y96c94OrxkVbHDlbKALjkjy70X7sNnvi8u+L67O8duoat6nrdNZtgZ+mBQb5zs5tedz9xc7lkjHBLc+4Pcv/PtCHe/YwjhHfmo+8jauubuObJpawqr+XUkVncN3Msxw3q5Vpic6NbkvA/i2DGb+Hka3r3/SJJ09723ufin7g5wI+ZChf+2tPD6Q7QUAt//yF88JQ7WXnhryBlYNc98p1l0Lin4/OT+x8Y4Bkj3CiWfsMiv+TlAYeaj96Cvhe0tCpzisp4cNHH7Glo5vrT8/jm548jNaEXv0A1NbjlEz9Z7C7umTCr996rL2hpdkPqdm11Qb7/3zZXOti9zY3SCFx4PSnLjYkff1n0lgo2LnFDMWs2dtwen3qQIB8BGcPtxGcEsKAPk+q6Rh5c9BFzijYzMC2Buy8YzfTxQ3qvnNO0F164zF3GffETbpWjSKMKe2s6hvXubS7EA0N9z3Y61IHBzUeSNtj/b4j7lz6k/XbOSXZyD9x49A9fdOUbq5N7hgV9mC0vq+GeV0pYvaWW00b250czx/ReOaexDp67BDYvdUPrhk4CiXH/YmJdGHb4eajHQvyH31h3+B747m1uNFFnyf39gX2QEE8b4k8aTnkAAA9bSURBVGrSVgs2UcqCvg9oK+f84o2PqdvXzH+dkc8tU0f1Tjln32549ktuIq4ekYMcBGI6HSg6bwv4KQLNDS7AA+cVaeNL6RTYg7sI8cFWAzbmMHoc9CIyDXgEiAWeUNWfd3o8AfgTMAmoAmapamnA48OBNcC9qvrLQ72XV4O+TXVdI794w5VzBqX3Yjmnsc7V61v2uWl2tcWNOunwM3B7p9sH7NviyiqHfZ3A5/t/xsW7FXfSBrvRGYG98oQ0KxkYEwI9CnoRiQXWAecA5UARcIWqrgnY50ZgvKr+PxG5HLhIVWcFPD4fV1BdGu1B36ZzOee+mWMY1dujc4wxnnWooA9m5q3JwHpV3aCqjcAcYGanfWYCz/hvzwemir+LKiJfBDYCJUfSeK+aODyT/73pdO7/4ljWbN3F+Y+8w08XrmXPvuZwN80Y4zHBBP1QYHPA/XL/ti73UdVmoBboLyKpwJ3Ajw71BiJyg4gUi0hxZWVlsG2PeLExwtWnjmDxt8/mkknDeHzJBqY+9A8WrKygr507McZErt5el+5e4NequudQO6nq46paoKoF2dl9bN7voyArJZ6fXzyel2/8DAPTErnlz8u58n+W8p9Pd4e7acYYDwgm6LcAuQH3h/m3dbmPiMQB/XAnZU8BfiEipcCtwPdExGbfOggr5xhjekMwQV8EjBKRfBGJBy4HFnTaZwFwrf/2JcDb6pypqnmqmgc8DPxUVX8borZ7Uls55+3bz+Lik9vLOa9aOccYc4QOG/T+mvtsYBGwFpinqiUicp+IzPDv9kdcTX49cBtwV281OFr0T03ggUvG89KNnyE7LYGb/7ycq56wco4xpvvsgqkI0NKqvPB+Gb9c5C62+soZ+dzcWxdbGWMiUk+HV5owi40Rrgko5/zByjnGmG6woI8gByvnrN9u5RxjzMFZ0Eegk4dn8spNZ/DjL47lwy21THv4HX5mo3OMMQdhQR+h2so5i7999v5yzucf+qeVc4wxB7Cgj3Bt5ZwXv/EZ+qfGWznHGHMAC3qPmDQikwWzO5ZzfvzaGgt8Y4wNr/Siqj37eOCNj5j/QTmtCicMTmPGSTlMH59DbtYhFoU2xkQsW3gkSm3f3cDCVVtZsLKCZWU7AZg4PIPp43O4cPwQBqYnhrmFxphQsaA3bK6u57VVW3l1ZQVrtu5CBE7N78/0CTmcP3YwmSnx4W6iMaYHLOhNB+u37+bVlS70N+yoIy5GOHPUAGaclMM5owfbFbfGRCALetMlVaWkYhevrqzg1ZUVVNQ2kBAXw9QTBzJ9fA6fPWEgiT5bbNuYSGBBbw6rtVVZvrmGBSsqeH31VnbsaSQ1IY5zRw9i+oQczhg1AF+sDdIypq+yoDfd0tzSyr83VPPqygr++uFWdjU0k5Hs4/yxQ5gxIYfJ+VnExtiC3sb0JRb05ojta27hnXU7WLCygr+v+ZS9TS0MTEvgwvE5TJ8whJNyM/AvD2yMCSMLehMS9Y3NvLV2O6+urOAfH1fS2NJKblYS08fnMH1CDicMTrPQNyZMLOhNyNXubeJvJdtYsLKC//ukipZWZdTAVKZPcKGfPyAl3E00JqpY0JtetWPPPv764TZeXVHB+6XVAIwb2o8ZE3K4YPwQcjKSwtxCY7zPgt4cNRU79/K6/2rc1VtqAZiQm8Gk4ZlMHJ7BySMyyemXaCUeY0LMgt6ExcYddby6soJ3/7ODleU72dfcCsDAtARODgj+cUP72Xh9Y3rIgt6EXVNLK2u37mJ52U6WldWwvGwnZdX1AMTFCKNz0tvDf3gmwzKTrNdvTDf0OOhFZBrwCBALPKGqP+/0eALwJ2ASUAXMUtVSETkH+DkQDzQCd6jq24d6Lwv66FG5ex8rNrcFfw0rN9eyt6kFgAGpCftDf+LwDMYP60dyvE3NYMzBHCroD/uXIyKxwKPAOUA5UCQiC1R1TcBuXwFqVPVYEbkceACYBewApqtqhYiMBRYBQ3v26xivyE5L4JzRgzhn9CDAXaj10bbdLN+8k+Wbali+eSd/X/Mp4FbUOmFwGicPz+TkERlMzM1kRP9k6/UbE4TD9uhF5DTgXlU9z3//uwCq+rOAfRb593lPROKAbUC2Bry4uL/IKmCIqu472PtZj94Eqq5rZLm/1LOsrIaVm3dS1+h6/Vkp8UzMdXX+ibkZTMjNIMUmZDNRqkc9elwPfHPA/XLglIPto6rNIlIL9Mf16NtcDCzrKuRF5AbgBoDhw4cH0SQTLbJS4pl64iCmnuh6/S2tyrpPd+8P/mVlNbz10XYAYgSOH5zeoeQzckCK9fpN1Dsq3R8RGYMr55zb1eOq+jjwOLge/dFok4lMsTHCiUPSOXFIOlee4joFO+sbXbmnbCfLy2p4dUUFLywtAyAj2cfE3AwmDs/kxCHpDM9KJjcryer9JqoE8799C5AbcH+Yf1tX+5T7Szf9cGUaRGQY8DLwZVX9pMctNqaTjOR4Pnv8QD57/EDAzcS5vnIPyza1l3wWf1zZ4TkDUuPJzUp2wZ/p/5mVzPD+yQxOT7RJ24ynBBP0RcAoEcnHBfrlwJWd9lkAXAu8B1wCvK2qKiIZwOvAXar6r9A125iDi4kRjhuUxnGD0rh8suv172poYkNlHWXV9Wz2/yurrmdZWQ2vrdpKS2v7F0lfrDA0I6n9QOD/2XZQ6JfsC9evZswROWzQ+2vus3EjZmKBJ1W1RETuA4pVdQHwR+BZEVkPVOMOBgCzgWOBe0TkHv+2c1V1e6h/EWMOJT3Rx0m5GZyUm3HAY00trWzd2eAOAjXuAFBWXU95dT0LV2+lpr6p02vFMbx/e/AHHghyMpKIj7N5+03fYhdMGXMYuxqa/N8C9u7/JtB2QCiv3ktjS+v+fWMEhvRLIjcrqb0s1N8dDHIzkxmQGm8nh02v6OmoG2OiWnqijzE5/RiT0++Ax1pblU93N7C5em+HbwJl1fX84+NKtu/uOMgsOT6WEf1TGDkghZHZKeQPSGFkdir5A1Lol2QlIdM7LOiN6YGYGGFIvySG9Eticn7WAY83NLVQ3lYOqqqnrHovpVV1lFTU8kbJtg7nBgakxrvgH5BKfnbbwSCV4VnJVg4yPWJBb0wvSvTFcuzANI4dmHbAY43NrZRV17Ohcg8bd9SxobKOjTvqeOujT9lR3Lh/v9gYITczqUPvf2S2OyAMSk+wUpA5LAt6Y8IkPi6GYwemcuzA1AMeq93bxMYddWzcsYcNlXVs8B8I3ttQRUNT+zmB5PjYDgeAY/zloPwBKaQlWinIOBb0xvRB/ZK6HiXU2qps29Xg7/3v4RP/t4AVm2t4bVUFgWMrstMS9p8LGDmg/ZtAblYyvlgrBUUTC3pjIkhMjJCTkURORhJnjBrQ4bGGphZ/KaiODTv2sNH/TWBRyadU17XPYhIXIwzLTCIt0UdCXAyJvlgSfTEkxMWS4PPfb7sd1/ZY236x+2+37dvVY4lxMcTZwaTPsKA3xiMSfbH7LxTrbGd94/7e/4bKPWyqrqd+XzMNTa3UNzZTXddKQ3ML+5pa2dfcQoP/Z1PLkQ+/jo0REjsdBBJ8HQ8cSb5Y+iX56JfkIz3JR0ayb//9jKR4dzvZR1pCHDF2tfIRs6A3JgpkJMczaUQ8k0Zkdut5zS2t7Gt2/xqaWmhoagm43fGgsK/JHSwamgJvt+8T+Nx9Ta3U1DWypbGF2r1N1O5t2r8CWVdiBNISOx4IAv913B7fYVtyfGzUn7C2oDfGHFRcrCvBpCT0/ns1NLWH/s76poDbjexqu723ffuWmr37bze3HvybR1yMkJHsvjG4bwoBB4Vkd1BIT4wjJSGO5PhYkuPdz5SEOFLiY0nyb4vk+Y8s6I0xfUJbiWdQemK3nqeq1Pm/Geysb6R2bxO7Oh8s/D937W1ixx5Xxqrd28SuhiaCnRwg0RdDSnwcSfGxpMTHkZwQG3A/luT9B4a4DvfbDh4pCe0Hkbb7Sb6j823Dgt4YE9FEhNSEOFIT4hiakdSt57a2KrsbmtnV0ER9Ywt1jc3U72uhvrG50323LfB+nX+fHXv2sbephbqA5wXfdkjytQf/+GEZ/OaKid39CA7Lgt4YE7ViYoR+yb6Qzkja2qo0NLcHf92+FvY2NXe4X9/UQv2+Zuoa3c+2+0Mzu3egCpYFvTHGhFBMjPhLNHHAUTi5EQQb6GqMMR5nQW+MMR5nQW+MMR5nQW+MMR5nQW+MMR5nQW+MMR5nQW+MMR5nQW+MMR4nGuxED0eJiFQCm3rwEgOAHSFqTqSzz6Ij+zw6ss+jnRc+ixGqmt3VA30u6HtKRIpVtSDc7egL7LPoyD6PjuzzaOf1z8JKN8YY43EW9MYY43FeDPrHw92APsQ+i47s8+jIPo92nv4sPFejN8YY05EXe/TGGGMCWNAbY4zHeSboRWSaiHwsIutF5K5wtyecRCRXRBaLyBoRKRGRb4a7TeEmIrEislxEXgt3W8JNRDJEZL6IfCQia0XktHC3KZxE5Fv+v5MPReTPItK9RWsjgCeCXkRigUeB84HRwBUiMjq8rQqrZuB2VR0NnArcFOWfB8A3gbXhbkQf8QjwhqqeAEwgij8XERkK3AIUqOpYIBa4PLytCj1PBD0wGVivqhtUtRGYA8wMc5vCRlW3quoy/+3duD/koeFtVfiIyDDgAuCJcLcl3ESkHzAF+COAqjaq6s7wtirs4oAkEYkDkoGKMLcn5LwS9EOBzQH3y4niYAskInnARGBpeFsSVg8D3wFaw92QPiAfqASe8peynhCRlHA3KlxUdQvwS6AM2ArUqurfwtuq0PNK0JsuiEgq8CJwq6ruCnd7wkFELgS2q+oH4W5LHxEHnAz8XlUnAnVA1J7TEpFM3Lf/fCAHSBGRq8PbqtDzStBvAXID7g/zb4taIuLDhfzzqvpSuNsTRqcDM0SkFFfS+5yIPBfeJoVVOVCuqm3f8Objgj9afR7YqKqVqtoEvAR8JsxtCjmvBH0RMEpE8kUkHncyZUGY2xQ2IiK4GuxaVf1VuNsTTqr6XVUdpqp5uP8Xb6uq53pswVLVbcBmETnev2kqsCaMTQq3MuBUEUn2/91MxYMnp+PC3YBQUNVmEZkNLMKdNX9SVUvC3KxwOh24BlgtIiv8276nqgvD2CbTd9wMPO/vFG0Arg9ze8JGVZeKyHxgGW602nI8OB2CTYFgjDEe55XSjTHGmIOwoDfGGI+zoDfGGI+zoDfGGI+zoDfGGI+zoDfGGI+zoDfGGI/7/4nJI4d8WsRvAAAAAElFTkSuQmCC\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# predict\n",
+ "test_labels_one_hot_encoded_predicted = model.predict(test_images)\n",
+ "test_labels_predicted = np.argmax(test_labels_one_hot_encoded_predicted, axis=1)\n",
+ "print(test_labels.shape)\n",
+ "print(test_labels_predicted.shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "FNWWb7-gOP-i",
+ "outputId": "f2fd3be1-eada-4fee-f3f3-99bcf92f0fa4"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "(10000,)\n",
+ "(10000,)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# confusion matrix\n",
+ "conf_mat = metrics.confusion_matrix(y_true=test_labels, y_pred=test_labels_predicted)\n",
+ "conf_mat"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "278ENobkOP-j",
+ "outputId": "09d4e09e-464e-4b71-b378-703013990e95"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "array([[ 977, 1, 0, 0, 0, 0, 1, 1, 0, 0],\n",
+ " [ 0, 1132, 0, 0, 1, 0, 0, 0, 2, 0],\n",
+ " [ 2, 1, 1016, 0, 1, 0, 2, 8, 2, 0],\n",
+ " [ 0, 1, 0, 1005, 0, 2, 0, 0, 2, 0],\n",
+ " [ 0, 1, 0, 0, 978, 0, 1, 0, 0, 2],\n",
+ " [ 2, 1, 0, 13, 0, 866, 3, 0, 4, 3],\n",
+ " [ 3, 3, 0, 0, 1, 2, 944, 0, 5, 0],\n",
+ " [ 0, 6, 3, 0, 1, 0, 0, 1015, 1, 2],\n",
+ " [ 1, 0, 0, 1, 0, 0, 0, 1, 969, 2],\n",
+ " [ 1, 2, 0, 0, 10, 1, 0, 3, 5, 987]])"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 57
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# waht are the diagonals\n",
+ "np.diagonal(conf_mat)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "DZP-xO_kOP-j",
+ "outputId": "90ff55ce-8942-48d2-a7be-60087f94ed89"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "array([ 977, 1132, 1016, 1005, 978, 866, 944, 1015, 969, 987])"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 58
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# sum of diagonal\n",
+ "np.sum(np.diagonal(conf_mat))"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "mgl9jfKaOP-j",
+ "outputId": "58852cac-bc23-430f-8be8-b26d5a3be983"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "9889"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 59
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# sum of the matrix\n",
+ "np.sum(conf_mat)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "G691BwcNOP-j",
+ "outputId": "603f36fd-b3a7-436c-9490-52d76390f43a"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "10000"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 60
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# accuracy\n",
+ "np.sum(np.diagonal(conf_mat))/np.sum(conf_mat)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "miOhZQzhOP-j",
+ "outputId": "bef4c74b-46f7-4f23-fc06-96344109a5cb"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "0.9889"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 61
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# quick way\n",
+ "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay"
+ ],
+ "metadata": {
+ "id": "nIxoU1XvOP-j"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# plot\n",
+ "cm = confusion_matrix(test_labels, test_labels_predicted, labels=np.arange(10))\n",
+ "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=np.arange(10))\n",
+ "disp.plot()\n",
+ "plt.title('test acc='+str(round(np.sum(np.diagonal(conf_mat))/np.sum(conf_mat),3)))\n",
+ "plt.show()"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 295
+ },
+ "id": "iniM0DE_OP-j",
+ "outputId": "3c25e0dd-5e05-4a1b-d6e7-88a09f6858ef"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Research Proposal\n",
+ "\n",
+ "Research proposal is a guideline of what you want to do with your project. You should start with a topic title and a punchline of your project.\n",
+ "\n",
+ "### Topic\n",
+ "\n",
+ "This project designs a deep Convolutional Neural Network (CNN) to classify images into different labels. The goal is to see whether advanced AI models such as deep CNN can recognize the patterns in the images.\n",
+ "\n",
+ "### Proposed Experiment\n",
+ "\n",
+ "This project starts with a baseline model. This is a simple neural network, also known as Artificial Neural Network (ANN). An ANN has dense layers and the layers are formed using a linear combination (these are the neurons in the dense layers) and an activation function.\n",
+ "\n",
+ "This project also investigates advanced models. This is a family of different Convolutional Neural Network (CNN). Models such as CNN are consist of convolutional layers. Give an example of a convolution operation.\n",
+ "\n",
+ "### Expected Results\n",
+ "\n",
+ "In a simple data such as MNIST Handwritten Digits, we expect baseline model to perform about 97% and advanced model to perform about 98%.\n",
+ "\n",
+ "For example, from the above experiments attempted, we can summarize the following table.\n",
+ "\n",
+ "| No. | Conv | Hidden | Performance |\n",
+ "| --- | --- | --- | --- | \n",
+ "| 1 | 0 | [256, 128, 64] | 98% |\n",
+ "| 2 | [32, 64] | [256, 128] | 99% |\n",
+ "| ... | ... | ... | ... |\n",
+ "\n",
+ "Can you detect a pattern here? If yes, how would you propose the next step?\n",
+ "\n",
+ "### Future Work\n",
+ "\n",
+ "This project will implement baseline model and advanced models on Chest X-ray image dataset. The project will build deep CNN model to help doctors to make diagnosis of lung cancer. \n",
+ "\n",
+ "In addition, optional work can be to investigate the explainability of the deep CNN models. CNN models, after tuning, can have high prediction performance. However, it requires additional work to help the doctors to explain how CNN work. This is the explainability side of the project that we can do if we have more time. "
+ ],
+ "metadata": {
+ "id": "dIG8zolUFkRl"
+ }
+ }
+ ]
+}
\ No newline at end of file
\n",
+ "![](\"https://github.com/AviatorMoser/keras-mnist-tutorial/blob/master/mnist.png?raw=1\")
\n",
+ "![](\"https://miro.medium.com/max/1400/1*p_hyqAtyI8pbt2kEl6siOQ.png\")
\n",
+ "![](\"https://miro.medium.com/max/805/1*ReYpdIZ3ZSAPb2W8cJpkBg.jpeg\")
\n",
+ "![](\"https://miro.medium.com/proxy/1*mh-QVwSKbe2kYCBh9mwA0Q.png\")
\n",
+ "
![](\"https://d3i71xaburhd42.cloudfront.net/d589392ab606a3d2861988ebcba95176517939ec/2-Table1-1.png\")
\n",
+ "![](\"https://miro.medium.com/max/1400/1*47skUygd3tWf3yB9A10QHg.gif\")
\n",
+ "![](\"https://user-images.githubusercontent.com/11681225/49325458-fc785480-f585-11e8-8d2a-9012d6024c6e.gif\")
\n",
+ "![](\"https://i.makeagif.com/media/3-08-2021/48032H.gif\")
\n",
+ "\n",
+ "Given an image, we can use filters and matrix operation to combine a group of pixels into one feature. We can repeatedly do this for everywhere on the original image and we are able to create a list of new features. This is called feature mapping, which gives us new information to be connected into a neural network (or also known as dense layers in `tensorflow`) to create classified labels. "
+ ],
+ "metadata": {
+ "id": "h6QRHlwt8V7b"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "First, we introduce convolution operation. A convolution operation is like a matrix operation. It is defined as element-wise matrix multiplication.\n",
+ "\n",
+ "$$\n",
+ "\\underbrace{\n",
+ "\\begin{bmatrix}\n",
+ "1 & 2 & 3 \\\\\n",
+ "3 & 4 & 5 \\\\\n",
+ "5 & 6 & 7 \\\\\n",
+ "\\end{bmatrix}\n",
+ "}_\\text{image}\n",
+ "⊗\n",
+ "\\underbrace{\n",
+ "\\begin{bmatrix}\n",
+ "1 & 0 \\\\\n",
+ "1 & 0 \\\\ \n",
+ "\\end{bmatrix}\n",
+ "}_\\text{filter}\n",
+ "= \n",
+ "\\begin{bmatrix}\n",
+ "1 \\times 1 + 0 + 3 \\times 1 + 0 & 2 \\times 1 + 0 + 4 \\times 1 + 0 \\\\\n",
+ "3 \\times 1 + 0 + 5 \\times 1 + 0 & 4 \\times 1 + 0 + 6 \\times 1 + 0 \\\\\n",
+ "\\end{bmatrix}\n",
+ "=\n",
+ "\\begin{bmatrix}\n",
+ "4 & 6 \\\\\n",
+ "8 & 10 \\\\\n",
+ "\\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "Next, we introduce pooling. There are two types of pooling: (1) average pooling, and (2) maximum pooling.\n",
+ "\n",
+ "This is average pooling.\n",
+ "$$\n",
+ "\\text{ave}\\bigg(\n",
+ "\\begin{bmatrix}\n",
+ "4 & 6 \\\\\n",
+ "8 & 10 \\\\\n",
+ "\\end{bmatrix}\n",
+ "\\bigg) = (4 + 6 + 8 + 10) \\frac{1}{4} = 28/4 = 7\n",
+ "$$\n",
+ "\n",
+ "This is maximum pooling.\n",
+ "$$\n",
+ "\\text{max}\\bigg(\n",
+ "\\begin{bmatrix}\n",
+ "4 & 6 \\\\\n",
+ "8 & 10 \\\\\n",
+ "\\end{bmatrix}\n",
+ "\\bigg) = \\max\\{4, 6, 8, 10\\} = 10\n",
+ "$$\n"
+ ],
+ "metadata": {
+ "id": "u-OOkRPXzits"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## How does this work in a CNN?\n",
+ "\n",
+ "### Convolution layer (CONV)\n",
+ "\n",
+ "The convolution layer (CONV) uses filters that perform convolution operations as it is scanning the input $I$ with respect to its dimensions. Its hyperparameters include the filter size $F$ and stride $S$. The resulting output $O$ is called feature map or activation map. \n",
+ "\n",
+ "![](\"https://stanford.edu/~shervine/teaching/cs-230/illustrations/convolution-layer-a.png?1c517e00cb8d709baf32fc3d39ebae67\")
![](\"https://stanford.edu/~shervine/teaching/cs-230/illustrations/max-pooling-a.png?711b14799d07f9306864695e2713ae07\")
| ![](\"https://stanford.edu/~shervine/teaching/cs-230/illustrations/average-pooling-a.png?58f9ab6d61248c3ec8d526ef65763d2f\")
|\n",
+ "| Comments | Preserves detected features; Most commonly used | Downsamples feature map; Used in LeNet |\n",
+ "\n",
+ "### Fully Connected (FC)\n",
+ "\n",
+ "The fully connected layer (FC) operates on a flattened input where each input is connected to all neurons. If present, FC layers are usually found towards the end of CNN architectures and can be used to optimize objectives such as class scores.\n",
+ "\n",
+ "![](\"https://stanford.edu/~shervine/teaching/cs-230/illustrations/fully-connected-ltr.png?32caf9e07c79d652faa292812579d063\")
![](\"https://media.licdn.com/dms/image/C4D12AQFKRQOp_aXz0g/article-cover_image-shrink_600_2000/0/1577211633664?e=2147483647&v=beta&t=pZ5TdXalXICIqPXTDBX6NP-CYlGS3wE2Kn6y1XiYjHI\")