DL_algorithms/Convolutional Neural Network/CNN_from_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0228026d",
   "metadata": {},
   "source": [
    "### Convolutional Neural Network Implementation from scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "971984a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['image.cmap'] = 'Blues'\n",
    "plt.rcParams['figure.figsize'] = (8.0,8.0) \n",
    "plt.rcParams['image.interpolation'] = 'nearest'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3a83433d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def zero_padding(X, pad):\n",
    "    X_pad = np.pad(X, ((0,0), (pad,pad), (pad,pad), (0,0)), mode='constant', constant_values = (0,0))\n",
    "    return X_pad"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54d31777",
   "metadata": {},
   "source": [
    "### Padding"
   ]
  },
  {
   "cell_type": "raw",
   "id": "652b7ac3",
   "metadata": {},
   "source": [
    "Padding is applied to the height and width of an image.\n",
    "Here we'll pad with zeros all images of the dataset.\n",
    "Arguments:\n",
    "X => python numpy array of shape (m, num_height, num_width, num_channel) which represents a batch of m images\n",
    "pad => amount of padding around each image on vertical and horizontal dimensions\n",
    "Returns:\n",
    "X_pad => padded image of shape (m, num_height + 2 * padding, num_width + 2 * padding, num_channel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e299df47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x.shape =  (4, 3, 3, 2) \n",
      "\n",
      "x_pad.shape =  (4, 5, 5, 2) \n",
      "\n",
      "x[1,1] =\n",
      " [[ 0.90085595 -0.68372786]\n",
      " [-0.12289023 -0.93576943]\n",
      " [-0.26788808  0.53035547]] \n",
      "\n",
      "x_pad[1,1] =\n",
      " [[ 0.          0.        ]\n",
      " [ 0.04221375  0.58281521]\n",
      " [-1.10061918  1.14472371]\n",
      " [ 0.90159072  0.50249434]\n",
      " [ 0.          0.        ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize random number generator\n",
    "np.random.seed(1) \n",
    "\n",
    "# batch of 4 images of 3 x 3 x 2 dimension\n",
    "x = np.random.randn(4, 3, 3, 2)\n",
    "\n",
    "#function calling\n",
    "x_pad = zero_padding(x, 1) \n",
    "print (\"x.shape = \", x.shape,\"\\n\")\n",
    "print (\"x_pad.shape = \", x_pad.shape,\"\\n\")\n",
    "print (\"x[1,1] =\\n\", x[1, 1],\"\\n\")\n",
    "print (\"x_pad[1,1] =\\n\", x_pad[1, 1])\n",
    "\n",
    "fig, axarr = plt.subplots(1, 2)\n",
    "axarr[0].set_title('x')\n",
    "axarr[0].imshow(x[0, :, :, 0])\n",
    "\n",
    "axarr[1].set_title('x_pad')\n",
    "axarr[1].imshow(x_pad[0, :, :, 0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5509a208",
   "metadata": {},
   "source": [
    "### Convolution operation \n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f43f4e50",
   "metadata": {},
   "source": [
    "One filter is defined by parameters W on a single slice (prev_slice) of the output activation \n",
    "of the previous layer.\n",
    "    \n",
    "    Arguments:\n",
    "    prev_slice => slice of input data of shape (f, f, num_channel_prev)\n",
    "    W => Weight parameters contained in a window - matrix of shape (f, f, num_channel_prev)\n",
    "    b => Bias parameters contained in a window - matrix of shape (1, 1, 1)\n",
    "    \n",
    "    Returns:\n",
    "    Z => a scalar value, the result of convolving the sliding window (W, b) on a slice x of the input data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "dab0c89a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_single_step(A_prev_slice, W, b):  \n",
    "    # Element-wise product between A_prev_slice and W.\n",
    "    s = np.multiply(A_prev_slice , W)\n",
    "    # Sum over all entries of the volume s.\n",
    "    Z = np.sum(s)\n",
    "    # Added bias b to Z. \n",
    "    # squeeze -> 3d tensor to 2d tensor\n",
    "    b = np.squeeze(b)\n",
    "    Z = Z + b\n",
    "    return Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c2beaa73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z = -6.999089450680221\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "A_prev_slice = np.random.randn(4, 4, 3)\n",
    "W = np.random.randn(4, 4, 3)\n",
    "b = np.random.randn(1, 1, 1)\n",
    "\n",
    "Z = conv_single_step(A_prev_slice, W, b)\n",
    "print(\"Z =\", Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63cc0020",
   "metadata": {},
   "source": [
    "### Forward Propagation"
   ]
  },
  {
   "cell_type": "raw",
   "id": "466f9035",
   "metadata": {},
   "source": [
    "Implements the forward propagation for a convolution function\n",
    "    \n",
    "    Arguments:\n",
    "    A_prev => output activations of the previous layer, \n",
    "        numpy array of shape (m, num_height_prev, num_width_prev, num_channel_prev)\n",
    "    W => Weights, numpy array of shape (f, f, num_channel_prev, num_channel)\n",
    "    b => Biases, numpy array of shape (1, 1, 1, num_channel)\n",
    "    hparameters -- python dictionary containing \"stride\" and \"pad\"\n",
    "        \n",
    "    Returns:\n",
    "    Z => conv output, numpy array of shape (m, num_height, num_width, num_channel)\n",
    "    cache => cache of values needed for the conv_backward() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "71cceba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_forward(A_prev, W, b, hparameters):\n",
    "    (m, num_height_prev, num_width_prev, num_channel_prev) = A_prev.shape\n",
    "\n",
    "    (f, f, num_channel_prev, num_channel) = W.shape\n",
    "    \n",
    "    stride = hparameters[\"stride\"]\n",
    "    pad = hparameters[\"pad\"]\n",
    "    \n",
    "    num_height = int((num_height_prev - f + 2*pad)/stride) + 1\n",
    "    num_width = int((num_width_prev - f + 2*pad)/stride) + 1\n",
    "    \n",
    "    Z = np.zeros((m, num_height, num_width, num_channel))\n",
    "    \n",
    "    A_prev_pad = zero_padding(A_prev, pad)\n",
    "    \n",
    "    for i in range(m):              \n",
    "        a_prev_pad = A_prev_pad[i]              \n",
    "        for h in range(num_height):           \n",
    "            vert_start = stride * h\n",
    "            vert_end = vert_start + f\n",
    "            \n",
    "            for w in range(num_width):       \n",
    "                horiz_start = stride * w\n",
    "                horiz_end = horiz_start + f\n",
    "                \n",
    "                for c in range(num_channel):   \n",
    "                                        \n",
    "                    A_prev_slice = a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]\n",
    "                    \n",
    "                    weights = W[:,:,:,c]\n",
    "                    biases = b[:,:,:,c]\n",
    "                    Z[i, h, w, c] = conv_single_step(A_prev_slice,weights,biases)    \n",
    "    return Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b5690608",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z's mean =\n",
      " 0.5511276474566768\n",
      "\n",
      "Z[0,2,1] =\n",
      " [-2.17796037  8.07171329 -0.5772704   3.36286738  4.48113645 -2.89198428\n",
      " 10.99288867  3.03171932]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "A_prev = np.random.randn(2, 5, 7, 4)\n",
    "W = np.random.randn(3, 3, 4, 8)\n",
    "b = np.random.randn(1, 1, 1, 8)\n",
    "hparameters = {\"pad\" : 1,\n",
    "               \"stride\": 2}\n",
    "\n",
    "Z = conv_forward(A_prev, W, b, hparameters)\n",
    "z_mean = np.mean(Z)\n",
    "z_0_2_1 = Z[0, 2, 1]\n",
    "print(\"Z's mean =\\n\", z_mean)\n",
    "print(\"\\nZ[0,2,1] =\\n\", z_0_2_1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc9bf1b5",
   "metadata": {},
   "source": [
    "## Pooling"
   ]
  },
  {
   "cell_type": "raw",
   "id": "3137a845",
   "metadata": {},
   "source": [
    "Implements the forward pass of the pooling layer\n",
    "    \n",
    "    Arguments:\n",
    "    A_prev => Input data, numpy array of shape (m, num_height_prev, num_width_prev, num_channel_prev)\n",
    "    hparameters => python dictionary containing \"f\" and \"stride\"\n",
    "    mode => the pooling mode you would like to use, defined as a string (\"max\" or \"average\")\n",
    "    \n",
    "    Returns:\n",
    "    A => output of the pool layer, a numpy array of shape (m, num_height, num_width, num_channel)\n",
    "    cache => cache used in the backward pass of the pooling layer, contains the input and hparameters "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dd7630c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pool_forward(A_prev, hparameters, mode = \"max\"):\n",
    "    (m, num_height_prev, num_width_prev, num_channel_prev) = A_prev.shape\n",
    "    \n",
    "    f = hparameters[\"f\"]\n",
    "    stride = hparameters[\"stride\"]\n",
    "    \n",
    "    num_height = int(1 + (num_height_prev - f) / stride)\n",
    "    num_width = int(1 + (num_width_prev - f) / stride)\n",
    "    num_channel = num_channel_prev\n",
    "    A = np.zeros((m, num_height, num_width, num_channel))              \n",
    "    \n",
    "    for i in range(m):                         \n",
    "        temp_prev_slice = A_prev[i]\n",
    "        for h in range(num_height): \n",
    "            vert_start = stride * h\n",
    "            vert_end = vert_start + f\n",
    "            \n",
    "            for w in range(num_width):  \n",
    "                horiz_start = stride * w\n",
    "                horiz_end = horiz_start + f\n",
    "                \n",
    "                for c in range (num_channel): \n",
    "                    A_prev_slice =temp_prev_slice[vert_start:vert_end,horiz_start:horiz_end,c]\n",
    "\n",
    "                    if mode == \"max\":\n",
    "                        A[i, h, w, c] = np.max(A_prev_slice)\n",
    "                    elif mode == \"average\":\n",
    "                        A[i, h, w, c] = np.mean(A_prev_slice)    \n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "98bf7338",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mode = max\n",
      "A.shape = (3, 3, 3)\n",
      "A[1, 1] =\n",
      " [1.14472371 0.90159072 1.65980218]\n",
      "\n",
      "mode = average\n",
      "A.shape = (3, 3, 3)\n",
      "A[1, 1] =\n",
      " [0.04737072 0.02592447 0.09203384]\n"
     ]
    }
   ],
   "source": [
    "# For Stride = 1\n",
    "np.random.seed(1)\n",
    "A_prev = np.random.randn(2, 5, 5, 3)\n",
    "hparameters = {\"stride\" : 1, \"f\": 3}\n",
    "\n",
    "A, cache = pool_forward(A_prev, hparameters, mode = \"max\")\n",
    "print(\"mode = max\")\n",
    "print(\"A.shape = \" + str(A.shape))\n",
    "print(\"A[1, 1] =\\n\", A[1, 1])\n",
    "A, cache = pool_forward(A_prev, hparameters, mode = \"average\")\n",
    "print(\"\\nmode = average\")\n",
    "print(\"A.shape = \" + str(A.shape))\n",
    "print(\"A[1, 1] =\\n\", A[1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c375c974",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mode = max\n",
      "A.shape = (2, 2, 3)\n",
      "A[0] =\n",
      " [[1.74481176 0.90159072 1.65980218]\n",
      " [1.74481176 1.6924546  1.65980218]]\n",
      "\n",
      "mode = average\n",
      "A.shape = (2, 2, 3)\n",
      "A[1] =\n",
      " [[-0.38268052  0.23257995  0.6259979 ]\n",
      " [-0.09525515  0.268511    0.46605637]]\n"
     ]
    }
   ],
   "source": [
    "# For Stride = 2\n",
    "np.random.seed(1)\n",
    "A_prev = np.random.randn(2, 5, 5, 3)\n",
    "hparameters = {\"stride\" : 2, \"f\": 3}\n",
    "\n",
    "A, cache = pool_forward(A_prev, hparameters)\n",
    "print(\"mode = max\")\n",
    "print(\"A.shape = \" + str(A.shape))\n",
    "print(\"A[0] =\\n\", A[0])\n",
    "print()\n",
    "\n",
    "A, cache = pool_forward(A_prev, hparameters, mode = \"average\")\n",
    "print(\"mode = average\")\n",
    "print(\"A.shape = \" + str(A.shape))\n",
    "print(\"A[1] =\\n\", A[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e4a7848",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2585c724",
   "metadata": {},
   "source": [
    "# Implementation "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de99e2d0",
   "metadata": {},
   "source": [
    "### ConvNet to identify Sign language digits "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "442e2875",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imread\n",
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras.layers as tfl\n",
    "from CNN import *\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7fa951da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the signs dataset\n",
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_signs_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f25f1304",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 100\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d305916c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (1080, 64, 64, 3)\n",
      "Y_train shape: (1080, 6)\n",
      "X_test shape: (120, 64, 64, 3)\n",
      "Y_test shape: (120, 6)\n"
     ]
    }
   ],
   "source": [
    "X_train = X_train_orig/255.\n",
    "X_test = X_test_orig/255.\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6).T\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6).T\n",
    "\n",
    "print (\"number of training examples = \" + str(X_train.shape[0]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[0]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e912433",
   "metadata": {},
   "source": [
    "#### Forward Propagation for the model:\n",
    "\n",
    "   ##### CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> DENSE  "
   ]
  },
  {
   "cell_type": "raw",
   "id": "38760c3f",
   "metadata": {},
   "source": [
    "Arguments:\n",
    "input_img => input dataset, of shape (input_shape)\n",
    "Returns:\n",
    "model => TF Keras model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f84e1880",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convNet_model(input_shape):\n",
    "    input_img = tf.keras.Input(shape=input_shape)\n",
    "    Z1 = tfl.Conv2D(filters = 8,kernel_size = 4,strides=1,padding = 'same')(input_img)\n",
    "    A1 = tfl.ReLU()(Z1)\n",
    "    P1 = tfl.MaxPool2D(strides=8, padding='same', pool_size=8)(A1)\n",
    "    Z2 = tfl.Conv2D(filters = 16,kernel_size = 2,strides=1,padding='same')(P1)\n",
    "    A2 = tfl.ReLU()(Z2)\n",
    "    P2 = tfl.MaxPool2D(strides=4, padding='same', pool_size=4)(A2)\n",
    "    F = tfl.Flatten()(P2)\n",
    "    outputs = tfl.Dense(units=6,activation='softmax')(F)\n",
    "    model = tf.keras.Model(inputs=input_img, outputs=outputs)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "46266dc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 64, 64, 3)]       0         \n",
      "                                                                 \n",
      " conv2d (Conv2D)             (None, 64, 64, 8)         392       \n",
      "                                                                 \n",
      " re_lu (ReLU)                (None, 64, 64, 8)         0         \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 8, 8, 8)          0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 8, 8, 16)          528       \n",
      "                                                                 \n",
      " re_lu_1 (ReLU)              (None, 8, 8, 16)          0         \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 2, 2, 16)         0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 64)                0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 6)                 390       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1,310\n",
      "Trainable params: 1,310\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "conv_model = convNet_model((64, 64, 3))\n",
    "conv_model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])\n",
    "conv_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fd105e0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "17/17 [==============================] - 1s 46ms/step - loss: 1.8255 - accuracy: 0.1667 - val_loss: 1.7955 - val_accuracy: 0.1667\n",
      "Epoch 2/100\n",
      "17/17 [==============================] - 1s 35ms/step - loss: 1.7940 - accuracy: 0.1648 - val_loss: 1.7933 - val_accuracy: 0.2000\n",
      "Epoch 3/100\n",
      "17/17 [==============================] - 1s 34ms/step - loss: 1.7923 - accuracy: 0.1685 - val_loss: 1.7917 - val_accuracy: 0.1667\n",
      "Epoch 4/100\n",
      "17/17 [==============================] - 1s 39ms/step - loss: 1.7900 - accuracy: 0.1722 - val_loss: 1.7878 - val_accuracy: 0.1167\n",
      "Epoch 5/100\n",
      "17/17 [==============================] - 1s 44ms/step - loss: 1.7851 - accuracy: 0.2259 - val_loss: 1.7842 - val_accuracy: 0.2083\n",
      "Epoch 6/100\n",
      "17/17 [==============================] - 1s 44ms/step - loss: 1.7791 - accuracy: 0.2306 - val_loss: 1.7782 - val_accuracy: 0.1833\n",
      "Epoch 7/100\n",
      "17/17 [==============================] - 1s 45ms/step - loss: 1.7707 - accuracy: 0.3111 - val_loss: 1.7703 - val_accuracy: 0.2750\n",
      "Epoch 8/100\n",
      "17/17 [==============================] - 1s 47ms/step - loss: 1.7615 - accuracy: 0.3352 - val_loss: 1.7630 - val_accuracy: 0.2583\n",
      "Epoch 9/100\n",
      "17/17 [==============================] - 1s 52ms/step - loss: 1.7502 - accuracy: 0.3370 - val_loss: 1.7526 - val_accuracy: 0.3250\n",
      "Epoch 10/100\n",
      "17/17 [==============================] - 1s 37ms/step - loss: 1.7360 - accuracy: 0.3981 - val_loss: 1.7410 - val_accuracy: 0.3500\n",
      "Epoch 11/100\n",
      "17/17 [==============================] - 1s 34ms/step - loss: 1.7181 - accuracy: 0.4056 - val_loss: 1.7242 - val_accuracy: 0.3500\n",
      "Epoch 12/100\n",
      "17/17 [==============================] - 1s 35ms/step - loss: 1.6953 - accuracy: 0.4278 - val_loss: 1.7038 - val_accuracy: 0.3750\n",
      "Epoch 13/100\n",
      "17/17 [==============================] - 1s 36ms/step - loss: 1.6672 - accuracy: 0.4528 - val_loss: 1.6794 - val_accuracy: 0.3750\n",
      "Epoch 14/100\n",
      "17/17 [==============================] - 1s 34ms/step - loss: 1.6320 - accuracy: 0.4815 - val_loss: 1.6499 - val_accuracy: 0.3667\n",
      "Epoch 15/100\n",
      "17/17 [==============================] - 1s 34ms/step - loss: 1.5940 - accuracy: 0.4907 - val_loss: 1.6213 - val_accuracy: 0.3667\n",
      "Epoch 16/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 1.5535 - accuracy: 0.4935 - val_loss: 1.5878 - val_accuracy: 0.3917\n",
      "Epoch 17/100\n",
      "17/17 [==============================] - 1s 52ms/step - loss: 1.5102 - accuracy: 0.5046 - val_loss: 1.5494 - val_accuracy: 0.4333\n",
      "Epoch 18/100\n",
      "17/17 [==============================] - 1s 36ms/step - loss: 1.4676 - accuracy: 0.5083 - val_loss: 1.5140 - val_accuracy: 0.4333\n",
      "Epoch 19/100\n",
      "17/17 [==============================] - 1s 37ms/step - loss: 1.4244 - accuracy: 0.5167 - val_loss: 1.4732 - val_accuracy: 0.4250\n",
      "Epoch 20/100\n",
      "17/17 [==============================] - 1s 36ms/step - loss: 1.3880 - accuracy: 0.5306 - val_loss: 1.4432 - val_accuracy: 0.4417\n",
      "Epoch 21/100\n",
      "17/17 [==============================] - 1s 37ms/step - loss: 1.3487 - accuracy: 0.5389 - val_loss: 1.4062 - val_accuracy: 0.4500\n",
      "Epoch 22/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 1.3141 - accuracy: 0.5491 - val_loss: 1.3729 - val_accuracy: 0.4500\n",
      "Epoch 23/100\n",
      "17/17 [==============================] - 1s 39ms/step - loss: 1.2826 - accuracy: 0.5602 - val_loss: 1.3405 - val_accuracy: 0.4583\n",
      "Epoch 24/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 1.2506 - accuracy: 0.5704 - val_loss: 1.3081 - val_accuracy: 0.4833\n",
      "Epoch 25/100\n",
      "17/17 [==============================] - 1s 39ms/step - loss: 1.2208 - accuracy: 0.5769 - val_loss: 1.2768 - val_accuracy: 0.5083\n",
      "Epoch 26/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 1.1914 - accuracy: 0.5833 - val_loss: 1.2463 - val_accuracy: 0.5167\n",
      "Epoch 27/100\n",
      "17/17 [==============================] - 1s 36ms/step - loss: 1.1651 - accuracy: 0.5917 - val_loss: 1.2179 - val_accuracy: 0.5167\n",
      "Epoch 28/100\n",
      "17/17 [==============================] - 1s 32ms/step - loss: 1.1393 - accuracy: 0.6019 - val_loss: 1.1907 - val_accuracy: 0.5333\n",
      "Epoch 29/100\n",
      "17/17 [==============================] - 1s 31ms/step - loss: 1.1137 - accuracy: 0.6083 - val_loss: 1.1648 - val_accuracy: 0.5583\n",
      "Epoch 30/100\n",
      "17/17 [==============================] - 1s 31ms/step - loss: 1.0902 - accuracy: 0.6185 - val_loss: 1.1404 - val_accuracy: 0.5667\n",
      "Epoch 31/100\n",
      "17/17 [==============================] - 1s 32ms/step - loss: 1.0685 - accuracy: 0.6306 - val_loss: 1.1161 - val_accuracy: 0.5667\n",
      "Epoch 32/100\n",
      "17/17 [==============================] - 1s 31ms/step - loss: 1.0462 - accuracy: 0.6361 - val_loss: 1.0936 - val_accuracy: 0.5667\n",
      "Epoch 33/100\n",
      "17/17 [==============================] - 1s 31ms/step - loss: 1.0250 - accuracy: 0.6472 - val_loss: 1.0719 - val_accuracy: 0.5667\n",
      "Epoch 34/100\n",
      "17/17 [==============================] - 1s 32ms/step - loss: 1.0054 - accuracy: 0.6546 - val_loss: 1.0515 - val_accuracy: 0.5750\n",
      "Epoch 35/100\n",
      "17/17 [==============================] - 1s 36ms/step - loss: 0.9864 - accuracy: 0.6602 - val_loss: 1.0332 - val_accuracy: 0.5917\n",
      "Epoch 36/100\n",
      "17/17 [==============================] - 1s 44ms/step - loss: 0.9689 - accuracy: 0.6685 - val_loss: 1.0154 - val_accuracy: 0.6000\n",
      "Epoch 37/100\n",
      "17/17 [==============================] - 1s 62ms/step - loss: 0.9520 - accuracy: 0.6750 - val_loss: 0.9988 - val_accuracy: 0.6000\n",
      "Epoch 38/100\n",
      "17/17 [==============================] - 1s 43ms/step - loss: 0.9360 - accuracy: 0.6787 - val_loss: 0.9827 - val_accuracy: 0.6167\n",
      "Epoch 39/100\n",
      "17/17 [==============================] - 1s 57ms/step - loss: 0.9203 - accuracy: 0.6889 - val_loss: 0.9686 - val_accuracy: 0.6250\n",
      "Epoch 40/100\n",
      "17/17 [==============================] - 1s 56ms/step - loss: 0.9072 - accuracy: 0.6972 - val_loss: 0.9542 - val_accuracy: 0.6417\n",
      "Epoch 41/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.8931 - accuracy: 0.7074 - val_loss: 0.9406 - val_accuracy: 0.6417\n",
      "Epoch 42/100\n",
      "17/17 [==============================] - 1s 53ms/step - loss: 0.8793 - accuracy: 0.7157 - val_loss: 0.9279 - val_accuracy: 0.6417\n",
      "Epoch 43/100\n",
      "17/17 [==============================] - 1s 47ms/step - loss: 0.8668 - accuracy: 0.7185 - val_loss: 0.9160 - val_accuracy: 0.6417\n",
      "Epoch 44/100\n",
      "17/17 [==============================] - 1s 50ms/step - loss: 0.8553 - accuracy: 0.7287 - val_loss: 0.9043 - val_accuracy: 0.6417\n",
      "Epoch 45/100\n",
      "17/17 [==============================] - 1s 43ms/step - loss: 0.8432 - accuracy: 0.7361 - val_loss: 0.8929 - val_accuracy: 0.6417\n",
      "Epoch 46/100\n",
      "17/17 [==============================] - 1s 47ms/step - loss: 0.8313 - accuracy: 0.7454 - val_loss: 0.8827 - val_accuracy: 0.6500\n",
      "Epoch 47/100\n",
      "17/17 [==============================] - 1s 43ms/step - loss: 0.8205 - accuracy: 0.7472 - val_loss: 0.8721 - val_accuracy: 0.6500\n",
      "Epoch 48/100\n",
      "17/17 [==============================] - 1s 45ms/step - loss: 0.8096 - accuracy: 0.7509 - val_loss: 0.8624 - val_accuracy: 0.6667\n",
      "Epoch 49/100\n",
      "17/17 [==============================] - 1s 42ms/step - loss: 0.7992 - accuracy: 0.7537 - val_loss: 0.8529 - val_accuracy: 0.6833\n",
      "Epoch 50/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 0.7893 - accuracy: 0.7556 - val_loss: 0.8438 - val_accuracy: 0.6917\n",
      "Epoch 51/100\n",
      "17/17 [==============================] - 1s 42ms/step - loss: 0.7795 - accuracy: 0.7602 - val_loss: 0.8354 - val_accuracy: 0.7083\n",
      "Epoch 52/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.7704 - accuracy: 0.7648 - val_loss: 0.8269 - val_accuracy: 0.7167\n",
      "Epoch 53/100\n",
      "17/17 [==============================] - 1s 44ms/step - loss: 0.7617 - accuracy: 0.7685 - val_loss: 0.8185 - val_accuracy: 0.7000\n",
      "Epoch 54/100\n",
      "17/17 [==============================] - 1s 42ms/step - loss: 0.7526 - accuracy: 0.7731 - val_loss: 0.8112 - val_accuracy: 0.7000\n",
      "Epoch 55/100\n",
      "17/17 [==============================] - 1s 41ms/step - loss: 0.7449 - accuracy: 0.7741 - val_loss: 0.8032 - val_accuracy: 0.7000\n",
      "Epoch 56/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 0.7363 - accuracy: 0.7722 - val_loss: 0.7960 - val_accuracy: 0.7083\n",
      "Epoch 57/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 0.7287 - accuracy: 0.7750 - val_loss: 0.7889 - val_accuracy: 0.7083\n",
      "Epoch 58/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17/17 [==============================] - 1s 37ms/step - loss: 0.7210 - accuracy: 0.7759 - val_loss: 0.7825 - val_accuracy: 0.7000\n",
      "Epoch 59/100\n",
      "17/17 [==============================] - 1s 45ms/step - loss: 0.7133 - accuracy: 0.7787 - val_loss: 0.7760 - val_accuracy: 0.7000\n",
      "Epoch 60/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.7066 - accuracy: 0.7815 - val_loss: 0.7693 - val_accuracy: 0.7000\n",
      "Epoch 61/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.6990 - accuracy: 0.7852 - val_loss: 0.7637 - val_accuracy: 0.7083\n",
      "Epoch 62/100\n",
      "17/17 [==============================] - 1s 39ms/step - loss: 0.6927 - accuracy: 0.7824 - val_loss: 0.7570 - val_accuracy: 0.7083\n",
      "Epoch 63/100\n",
      "17/17 [==============================] - 1s 51ms/step - loss: 0.6854 - accuracy: 0.7833 - val_loss: 0.7516 - val_accuracy: 0.7083\n",
      "Epoch 64/100\n",
      "17/17 [==============================] - 1s 48ms/step - loss: 0.6791 - accuracy: 0.7843 - val_loss: 0.7454 - val_accuracy: 0.7083\n",
      "Epoch 65/100\n",
      "17/17 [==============================] - 1s 53ms/step - loss: 0.6723 - accuracy: 0.7880 - val_loss: 0.7400 - val_accuracy: 0.7083\n",
      "Epoch 66/100\n",
      "17/17 [==============================] - 1s 53ms/step - loss: 0.6662 - accuracy: 0.7870 - val_loss: 0.7339 - val_accuracy: 0.7167\n",
      "Epoch 67/100\n",
      "17/17 [==============================] - 1s 44ms/step - loss: 0.6601 - accuracy: 0.7880 - val_loss: 0.7287 - val_accuracy: 0.7250\n",
      "Epoch 68/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.6537 - accuracy: 0.7907 - val_loss: 0.7235 - val_accuracy: 0.7333\n",
      "Epoch 69/100\n",
      "17/17 [==============================] - 1s 37ms/step - loss: 0.6479 - accuracy: 0.7926 - val_loss: 0.7182 - val_accuracy: 0.7250\n",
      "Epoch 70/100\n",
      "17/17 [==============================] - 1s 38ms/step - loss: 0.6424 - accuracy: 0.7926 - val_loss: 0.7130 - val_accuracy: 0.7333\n",
      "Epoch 71/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.6364 - accuracy: 0.7963 - val_loss: 0.7085 - val_accuracy: 0.7333\n",
      "Epoch 72/100\n",
      "17/17 [==============================] - 1s 34ms/step - loss: 0.6314 - accuracy: 0.8000 - val_loss: 0.7031 - val_accuracy: 0.7333\n",
      "Epoch 73/100\n",
      "17/17 [==============================] - 1s 34ms/step - loss: 0.6257 - accuracy: 0.8028 - val_loss: 0.6978 - val_accuracy: 0.7250\n",
      "Epoch 74/100\n",
      "17/17 [==============================] - 1s 43ms/step - loss: 0.6206 - accuracy: 0.8028 - val_loss: 0.6930 - val_accuracy: 0.7333\n",
      "Epoch 75/100\n",
      "17/17 [==============================] - 1s 53ms/step - loss: 0.6149 - accuracy: 0.8056 - val_loss: 0.6884 - val_accuracy: 0.7250\n",
      "Epoch 76/100\n",
      "17/17 [==============================] - 1s 64ms/step - loss: 0.6103 - accuracy: 0.8065 - val_loss: 0.6829 - val_accuracy: 0.7417\n",
      "Epoch 77/100\n",
      "17/17 [==============================] - 1s 51ms/step - loss: 0.6042 - accuracy: 0.8083 - val_loss: 0.6785 - val_accuracy: 0.7417\n",
      "Epoch 78/100\n",
      "17/17 [==============================] - 1s 54ms/step - loss: 0.5986 - accuracy: 0.8102 - val_loss: 0.6739 - val_accuracy: 0.7417\n",
      "Epoch 79/100\n",
      "17/17 [==============================] - 1s 62ms/step - loss: 0.5929 - accuracy: 0.8130 - val_loss: 0.6680 - val_accuracy: 0.7417\n",
      "Epoch 80/100\n",
      "17/17 [==============================] - 1s 46ms/step - loss: 0.5873 - accuracy: 0.8139 - val_loss: 0.6639 - val_accuracy: 0.7500\n",
      "Epoch 81/100\n",
      "17/17 [==============================] - 1s 50ms/step - loss: 0.5811 - accuracy: 0.8139 - val_loss: 0.6594 - val_accuracy: 0.7500\n",
      "Epoch 82/100\n",
      "17/17 [==============================] - 1s 66ms/step - loss: 0.5757 - accuracy: 0.8167 - val_loss: 0.6543 - val_accuracy: 0.7417\n",
      "Epoch 83/100\n",
      "17/17 [==============================] - 1s 52ms/step - loss: 0.5705 - accuracy: 0.8148 - val_loss: 0.6497 - val_accuracy: 0.7500\n",
      "Epoch 84/100\n",
      "17/17 [==============================] - 1s 49ms/step - loss: 0.5653 - accuracy: 0.8176 - val_loss: 0.6459 - val_accuracy: 0.7667\n",
      "Epoch 85/100\n",
      "17/17 [==============================] - 1s 57ms/step - loss: 0.5607 - accuracy: 0.8194 - val_loss: 0.6413 - val_accuracy: 0.7667\n",
      "Epoch 86/100\n",
      "17/17 [==============================] - 1s 61ms/step - loss: 0.5554 - accuracy: 0.8222 - val_loss: 0.6371 - val_accuracy: 0.7667\n",
      "Epoch 87/100\n",
      "17/17 [==============================] - 1s 52ms/step - loss: 0.5507 - accuracy: 0.8241 - val_loss: 0.6332 - val_accuracy: 0.7667\n",
      "Epoch 88/100\n",
      "17/17 [==============================] - 1s 54ms/step - loss: 0.5463 - accuracy: 0.8259 - val_loss: 0.6293 - val_accuracy: 0.7667\n",
      "Epoch 89/100\n",
      "17/17 [==============================] - 1s 51ms/step - loss: 0.5420 - accuracy: 0.8296 - val_loss: 0.6253 - val_accuracy: 0.7667\n",
      "Epoch 90/100\n",
      "17/17 [==============================] - 1s 52ms/step - loss: 0.5376 - accuracy: 0.8315 - val_loss: 0.6220 - val_accuracy: 0.7667\n",
      "Epoch 91/100\n",
      "17/17 [==============================] - 1s 44ms/step - loss: 0.5336 - accuracy: 0.8296 - val_loss: 0.6175 - val_accuracy: 0.7667\n",
      "Epoch 92/100\n",
      "17/17 [==============================] - 1s 51ms/step - loss: 0.5290 - accuracy: 0.8352 - val_loss: 0.6147 - val_accuracy: 0.7667\n",
      "Epoch 93/100\n",
      "17/17 [==============================] - 1s 40ms/step - loss: 0.5251 - accuracy: 0.8343 - val_loss: 0.6111 - val_accuracy: 0.7667\n",
      "Epoch 94/100\n",
      "17/17 [==============================] - 1s 54ms/step - loss: 0.5212 - accuracy: 0.8361 - val_loss: 0.6077 - val_accuracy: 0.7667\n",
      "Epoch 95/100\n",
      "17/17 [==============================] - 1s 50ms/step - loss: 0.5171 - accuracy: 0.8407 - val_loss: 0.6044 - val_accuracy: 0.7667\n",
      "Epoch 96/100\n",
      "17/17 [==============================] - 1s 55ms/step - loss: 0.5135 - accuracy: 0.8407 - val_loss: 0.6014 - val_accuracy: 0.7667\n",
      "Epoch 97/100\n",
      "17/17 [==============================] - 1s 51ms/step - loss: 0.5098 - accuracy: 0.8426 - val_loss: 0.5980 - val_accuracy: 0.7667\n",
      "Epoch 98/100\n",
      "17/17 [==============================] - 1s 50ms/step - loss: 0.5062 - accuracy: 0.8435 - val_loss: 0.5950 - val_accuracy: 0.7667\n",
      "Epoch 99/100\n",
      "17/17 [==============================] - 1s 47ms/step - loss: 0.5027 - accuracy: 0.8444 - val_loss: 0.5918 - val_accuracy: 0.7750\n",
      "Epoch 100/100\n",
      "17/17 [==============================] - 1s 54ms/step - loss: 0.4993 - accuracy: 0.8444 - val_loss: 0.5890 - val_accuracy: 0.7667\n"
     ]
    }
   ],
   "source": [
    "train_dataset = tf.data.Dataset.from_tensor_slices((X_train, Y_train)).batch(64)\n",
    "test_dataset = tf.data.Dataset.from_tensor_slices((X_test, Y_test)).batch(64)\n",
    "history = conv_model.fit(train_dataset, epochs=100, validation_data=test_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "794338b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.8255070447921753,\n",
       "  1.794019103050232,\n",
       "  1.7922600507736206,\n",
       "  1.7900253534317017,\n",
       "  1.7850762605667114,\n",
       "  1.7791301012039185,\n",
       "  1.7707260847091675,\n",
       "  1.7614636421203613,\n",
       "  1.7501829862594604,\n",
       "  1.7359579801559448,\n",
       "  1.718066930770874,\n",
       "  1.6953332424163818,\n",
       "  1.6671961545944214,\n",
       "  1.6320053339004517,\n",
       "  1.5940057039260864,\n",
       "  1.5534759759902954,\n",
       "  1.510178804397583,\n",
       "  1.4675817489624023,\n",
       "  1.4244296550750732,\n",
       "  1.387988567352295,\n",
       "  1.348676323890686,\n",
       "  1.3140696287155151,\n",
       "  1.2825777530670166,\n",
       "  1.2505916357040405,\n",
       "  1.2207928895950317,\n",
       "  1.191436529159546,\n",
       "  1.165116310119629,\n",
       "  1.1393455266952515,\n",
       "  1.1137467622756958,\n",
       "  1.0901761054992676,\n",
       "  1.068477749824524,\n",
       "  1.0461757183074951,\n",
       "  1.0249881744384766,\n",
       "  1.0054453611373901,\n",
       "  0.9864470362663269,\n",
       "  0.9689068794250488,\n",
       "  0.9520480632781982,\n",
       "  0.9360290765762329,\n",
       "  0.9203451871871948,\n",
       "  0.9071886539459229,\n",
       "  0.8930919170379639,\n",
       "  0.8793073296546936,\n",
       "  0.8668051362037659,\n",
       "  0.8553116321563721,\n",
       "  0.8432214260101318,\n",
       "  0.8312721252441406,\n",
       "  0.8204699754714966,\n",
       "  0.8095873594284058,\n",
       "  0.7991784811019897,\n",
       "  0.7892515659332275,\n",
       "  0.7794538140296936,\n",
       "  0.770409107208252,\n",
       "  0.761714518070221,\n",
       "  0.7525640726089478,\n",
       "  0.7448534965515137,\n",
       "  0.7363253831863403,\n",
       "  0.7287267446517944,\n",
       "  0.7209761142730713,\n",
       "  0.7133059501647949,\n",
       "  0.7065980434417725,\n",
       "  0.6989631652832031,\n",
       "  0.6926602125167847,\n",
       "  0.6853976249694824,\n",
       "  0.6790769696235657,\n",
       "  0.6723007559776306,\n",
       "  0.6662456393241882,\n",
       "  0.6600525975227356,\n",
       "  0.6536700129508972,\n",
       "  0.6479401588439941,\n",
       "  0.642361581325531,\n",
       "  0.6364255547523499,\n",
       "  0.6314011216163635,\n",
       "  0.6257439255714417,\n",
       "  0.6205586791038513,\n",
       "  0.6148954629898071,\n",
       "  0.6103192567825317,\n",
       "  0.6042236685752869,\n",
       "  0.5985682010650635,\n",
       "  0.5928908586502075,\n",
       "  0.5873380899429321,\n",
       "  0.5810508728027344,\n",
       "  0.5756628513336182,\n",
       "  0.5704737305641174,\n",
       "  0.565308153629303,\n",
       "  0.5607399344444275,\n",
       "  0.5554201602935791,\n",
       "  0.5506853461265564,\n",
       "  0.5462508201599121,\n",
       "  0.5419711470603943,\n",
       "  0.5375634431838989,\n",
       "  0.5335944294929504,\n",
       "  0.52897709608078,\n",
       "  0.525102436542511,\n",
       "  0.5211694240570068,\n",
       "  0.5170938372612,\n",
       "  0.513489305973053,\n",
       "  0.5097553730010986,\n",
       "  0.506158173084259,\n",
       "  0.5026578903198242,\n",
       "  0.4993005692958832],\n",
       " 'accuracy': [0.1666666716337204,\n",
       "  0.1648148149251938,\n",
       "  0.16851851344108582,\n",
       "  0.17222222685813904,\n",
       "  0.22592592239379883,\n",
       "  0.23055554926395416,\n",
       "  0.31111112236976624,\n",
       "  0.3351851999759674,\n",
       "  0.33703702688217163,\n",
       "  0.39814814925193787,\n",
       "  0.4055555462837219,\n",
       "  0.4277777671813965,\n",
       "  0.45277777314186096,\n",
       "  0.48148149251937866,\n",
       "  0.49074074625968933,\n",
       "  0.49351853132247925,\n",
       "  0.5046296119689941,\n",
       "  0.5083333253860474,\n",
       "  0.5166666507720947,\n",
       "  0.5305555462837219,\n",
       "  0.5388888716697693,\n",
       "  0.5490740537643433,\n",
       "  0.5601851940155029,\n",
       "  0.5703703761100769,\n",
       "  0.5768518447875977,\n",
       "  0.5833333134651184,\n",
       "  0.5916666388511658,\n",
       "  0.6018518805503845,\n",
       "  0.6083333492279053,\n",
       "  0.6185185313224792,\n",
       "  0.6305555701255798,\n",
       "  0.6361111402511597,\n",
       "  0.6472222208976746,\n",
       "  0.654629647731781,\n",
       "  0.6601851582527161,\n",
       "  0.6685185432434082,\n",
       "  0.675000011920929,\n",
       "  0.6787037253379822,\n",
       "  0.6888889074325562,\n",
       "  0.6972222328186035,\n",
       "  0.7074074149131775,\n",
       "  0.7157407402992249,\n",
       "  0.7185184955596924,\n",
       "  0.7287036776542664,\n",
       "  0.7361111044883728,\n",
       "  0.7453703880310059,\n",
       "  0.7472222447395325,\n",
       "  0.7509258985519409,\n",
       "  0.7537037134170532,\n",
       "  0.7555555701255798,\n",
       "  0.760185182094574,\n",
       "  0.7648147940635681,\n",
       "  0.7685185074806213,\n",
       "  0.7731481194496155,\n",
       "  0.7740740776062012,\n",
       "  0.7722222208976746,\n",
       "  0.7749999761581421,\n",
       "  0.7759259343147278,\n",
       "  0.7787036895751953,\n",
       "  0.7814815044403076,\n",
       "  0.7851851582527161,\n",
       "  0.7824074029922485,\n",
       "  0.7833333611488342,\n",
       "  0.7842592597007751,\n",
       "  0.7879629731178284,\n",
       "  0.7870370149612427,\n",
       "  0.7879629731178284,\n",
       "  0.7907407283782959,\n",
       "  0.7925925850868225,\n",
       "  0.7925925850868225,\n",
       "  0.7962962985038757,\n",
       "  0.800000011920929,\n",
       "  0.8027777671813965,\n",
       "  0.8027777671813965,\n",
       "  0.8055555820465088,\n",
       "  0.8064814805984497,\n",
       "  0.8083333373069763,\n",
       "  0.8101851940155029,\n",
       "  0.8129629492759705,\n",
       "  0.8138889074325562,\n",
       "  0.8138889074325562,\n",
       "  0.8166666626930237,\n",
       "  0.8148148059844971,\n",
       "  0.8175926208496094,\n",
       "  0.8194444179534912,\n",
       "  0.8222222328186035,\n",
       "  0.8240740895271301,\n",
       "  0.8259259462356567,\n",
       "  0.8296296000480652,\n",
       "  0.8314814567565918,\n",
       "  0.8296296000480652,\n",
       "  0.835185170173645,\n",
       "  0.8342592716217041,\n",
       "  0.8361111283302307,\n",
       "  0.8407407402992249,\n",
       "  0.8407407402992249,\n",
       "  0.8425925970077515,\n",
       "  0.8435184955596924,\n",
       "  0.8444444537162781,\n",
       "  0.8444444537162781],\n",
       " 'val_loss': [1.795526385307312,\n",
       "  1.7932673692703247,\n",
       "  1.7917035818099976,\n",
       "  1.7877652645111084,\n",
       "  1.7841565608978271,\n",
       "  1.7781872749328613,\n",
       "  1.7702839374542236,\n",
       "  1.763000249862671,\n",
       "  1.7525537014007568,\n",
       "  1.7410247325897217,\n",
       "  1.7242473363876343,\n",
       "  1.7038187980651855,\n",
       "  1.679426670074463,\n",
       "  1.6498795747756958,\n",
       "  1.6213423013687134,\n",
       "  1.5877937078475952,\n",
       "  1.549420952796936,\n",
       "  1.5139777660369873,\n",
       "  1.473241925239563,\n",
       "  1.4432045221328735,\n",
       "  1.4062435626983643,\n",
       "  1.3728879690170288,\n",
       "  1.3405317068099976,\n",
       "  1.3081395626068115,\n",
       "  1.2767561674118042,\n",
       "  1.246277093887329,\n",
       "  1.217875599861145,\n",
       "  1.1906731128692627,\n",
       "  1.1648478507995605,\n",
       "  1.1403828859329224,\n",
       "  1.1160647869110107,\n",
       "  1.09359872341156,\n",
       "  1.0719131231307983,\n",
       "  1.0514925718307495,\n",
       "  1.0331827402114868,\n",
       "  1.0153851509094238,\n",
       "  0.9988129734992981,\n",
       "  0.9826987981796265,\n",
       "  0.9686214923858643,\n",
       "  0.954156219959259,\n",
       "  0.9405638575553894,\n",
       "  0.9279106259346008,\n",
       "  0.9160217046737671,\n",
       "  0.9042707085609436,\n",
       "  0.8929418325424194,\n",
       "  0.8826895356178284,\n",
       "  0.8721445798873901,\n",
       "  0.8623924851417542,\n",
       "  0.8529214262962341,\n",
       "  0.8438014388084412,\n",
       "  0.8353723287582397,\n",
       "  0.8269193768501282,\n",
       "  0.8184899687767029,\n",
       "  0.8112366199493408,\n",
       "  0.8032411932945251,\n",
       "  0.7959570288658142,\n",
       "  0.7888765931129456,\n",
       "  0.7825101017951965,\n",
       "  0.7760074138641357,\n",
       "  0.7692896127700806,\n",
       "  0.7637258768081665,\n",
       "  0.7569824457168579,\n",
       "  0.7516477108001709,\n",
       "  0.7453726530075073,\n",
       "  0.7399726510047913,\n",
       "  0.7339454889297485,\n",
       "  0.7286786437034607,\n",
       "  0.7235361933708191,\n",
       "  0.7181994318962097,\n",
       "  0.7130086421966553,\n",
       "  0.7084882259368896,\n",
       "  0.7031046152114868,\n",
       "  0.6978041529655457,\n",
       "  0.6929747462272644,\n",
       "  0.6884149312973022,\n",
       "  0.6829392313957214,\n",
       "  0.6785292029380798,\n",
       "  0.6739073991775513,\n",
       "  0.6679998636245728,\n",
       "  0.6639118194580078,\n",
       "  0.6593754887580872,\n",
       "  0.6543349623680115,\n",
       "  0.6496763825416565,\n",
       "  0.6458605527877808,\n",
       "  0.6412865519523621,\n",
       "  0.6371269226074219,\n",
       "  0.633236289024353,\n",
       "  0.6292522549629211,\n",
       "  0.6252943873405457,\n",
       "  0.6219978332519531,\n",
       "  0.617535412311554,\n",
       "  0.6147107481956482,\n",
       "  0.6110896468162537,\n",
       "  0.6077377200126648,\n",
       "  0.6043931245803833,\n",
       "  0.6014067530632019,\n",
       "  0.5980090498924255,\n",
       "  0.59499192237854,\n",
       "  0.5917975902557373,\n",
       "  0.5889580249786377],\n",
       " 'val_accuracy': [0.1666666716337204,\n",
       "  0.20000000298023224,\n",
       "  0.1666666716337204,\n",
       "  0.11666666716337204,\n",
       "  0.2083333283662796,\n",
       "  0.18333333730697632,\n",
       "  0.2750000059604645,\n",
       "  0.25833332538604736,\n",
       "  0.32499998807907104,\n",
       "  0.3499999940395355,\n",
       "  0.3499999940395355,\n",
       "  0.375,\n",
       "  0.375,\n",
       "  0.36666667461395264,\n",
       "  0.36666667461395264,\n",
       "  0.3916666805744171,\n",
       "  0.4333333373069763,\n",
       "  0.4333333373069763,\n",
       "  0.42500001192092896,\n",
       "  0.4416666626930237,\n",
       "  0.44999998807907104,\n",
       "  0.44999998807907104,\n",
       "  0.4583333432674408,\n",
       "  0.4833333194255829,\n",
       "  0.5083333253860474,\n",
       "  0.5166666507720947,\n",
       "  0.5166666507720947,\n",
       "  0.5333333611488342,\n",
       "  0.5583333373069763,\n",
       "  0.5666666626930237,\n",
       "  0.5666666626930237,\n",
       "  0.5666666626930237,\n",
       "  0.5666666626930237,\n",
       "  0.574999988079071,\n",
       "  0.5916666388511658,\n",
       "  0.6000000238418579,\n",
       "  0.6000000238418579,\n",
       "  0.6166666746139526,\n",
       "  0.625,\n",
       "  0.6416666507720947,\n",
       "  0.6416666507720947,\n",
       "  0.6416666507720947,\n",
       "  0.6416666507720947,\n",
       "  0.6416666507720947,\n",
       "  0.6416666507720947,\n",
       "  0.6499999761581421,\n",
       "  0.6499999761581421,\n",
       "  0.6666666865348816,\n",
       "  0.6833333373069763,\n",
       "  0.6916666626930237,\n",
       "  0.7083333134651184,\n",
       "  0.7166666388511658,\n",
       "  0.699999988079071,\n",
       "  0.699999988079071,\n",
       "  0.699999988079071,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.699999988079071,\n",
       "  0.699999988079071,\n",
       "  0.699999988079071,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7166666388511658,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.7250000238418579,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.7416666746139526,\n",
       "  0.75,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7749999761581421,\n",
       "  0.7666666507720947]}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a70041be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0, 'Epoch'), Text(0, 0.5, 'Accuracy')]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss_acc_df = pd.DataFrame(history.history)\n",
    "loss_df= loss_acc_df[['loss','val_loss']]\n",
    "acc_df= loss_acc_df[['accuracy','val_accuracy']]\n",
    "loss_df.plot(title='Model loss',figsize=(10,6)).set(xlabel='Epoch',ylabel='Loss')\n",
    "acc_df.plot(title='Model Accuracy',figsize=(10,6)).set(xlabel='Epoch',ylabel='Accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f9b169c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.0 64-bit",
   "language": "python",
   "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.6.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "ee8e310ee70c2d1fd17cffc2ca4c08cbec67492a7c8702e7f3795ba9a6e21f31"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}