C4_W1_Convolution_model_Application.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1Q--QkoK_bLZv9QqXI_HhZd7SH0ksYCjr",
      "authorship_tag": "ABX9TyOAQQ+ndmWBoKtMRe21rpwT"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# necessary files to import.....\n",
        "import numpy as np\n",
        "from termcolor import colored\n",
        "\n",
        "from tensorflow.keras.layers import Input\n",
        "from tensorflow.keras.layers import Conv2D\n",
        "from tensorflow.keras.layers import MaxPooling2D\n",
        "from tensorflow.keras.layers import Dropout \n",
        "from tensorflow.keras.layers import Conv2DTranspose\n",
        "from tensorflow.keras.layers import concatenate\n",
        "from tensorflow.keras.layers import ZeroPadding2D\n",
        "from tensorflow.keras.layers import Dense\n",
        "\n",
        "\n",
        "# Compare the two inputs\n",
        "def comparator(learner, instructor):\n",
        "    if learner == instructor:\n",
        "        for a, b in zip(learner, instructor):\n",
        "            if tuple(a) != tuple(b):\n",
        "                print(colored(\"Test failed\", attrs=['bold']),\n",
        "                      \"\\n Expected value \\n\\n\", colored(f\"{b}\", \"green\"), \n",
        "                      \"\\n\\n does not match the input value: \\n\\n\", \n",
        "                      colored(f\"{a}\", \"red\"))\n",
        "                raise AssertionError(\"Error in test\") \n",
        "        print(colored(\"All tests passed!\", \"green\"))\n",
        "        \n",
        "    else:\n",
        "        print(colored(\"Test failed. Your output is not as expected output.\", \"red\"))\n",
        "\n",
        "# extracts the description of a given model\n",
        "def summary(model):\n",
        "    model.compile(optimizer='adam',\n",
        "                  loss='categorical_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "    result = []\n",
        "    for layer in model.layers:\n",
        "        descriptors = [layer.__class__.__name__, layer.output_shape, layer.count_params()]\n",
        "        if (type(layer) == Conv2D):\n",
        "            descriptors.append(layer.padding)\n",
        "            descriptors.append(layer.activation.__name__)\n",
        "            descriptors.append(layer.kernel_initializer.__class__.__name__)\n",
        "        if (type(layer) == MaxPooling2D):\n",
        "            descriptors.append(layer.pool_size)\n",
        "            descriptors.append(layer.strides)\n",
        "            descriptors.append(layer.padding)\n",
        "        if (type(layer) == Dropout):\n",
        "            descriptors.append(layer.rate)\n",
        "        if (type(layer) == ZeroPadding2D):\n",
        "            descriptors.append(layer.padding)\n",
        "        if (type(layer) == Dense):\n",
        "            descriptors.append(layer.activation.__name__)\n",
        "        result.append(descriptors)\n",
        "    return result\n",
        "\n",
        "def datatype_check(expected_output, target_output, error):\n",
        "    success = 0\n",
        "    if isinstance(target_output, dict):\n",
        "        for key in target_output.keys():\n",
        "            try:\n",
        "                success += datatype_check(expected_output[key], \n",
        "                                         target_output[key], error)\n",
        "            except:\n",
        "                print(\"Error: {} in variable {}. Got {} but expected type {}\".format(error,\n",
        "                                                                          key, type(target_output[key]), type(expected_output[key])))\n",
        "        if success == len(target_output.keys()):\n",
        "            return 1\n",
        "        else:\n",
        "            return 0\n",
        "    elif isinstance(target_output, tuple) or isinstance(target_output, list):\n",
        "        for i in range(len(target_output)):\n",
        "            try: \n",
        "                success += datatype_check(expected_output[i], \n",
        "                                         target_output[i], error)\n",
        "            except:\n",
        "                print(\"Error: {} in variable {}, expected type: {}  but expected type {}\".format(error,\n",
        "                                                                          i, type(target_output[i]), type(expected_output[i])))\n",
        "        if success == len(target_output):\n",
        "            return 1\n",
        "        else:\n",
        "            return 0\n",
        "                \n",
        "    else:\n",
        "        assert isinstance(target_output, type(expected_output))\n",
        "        return 1\n",
        "            \n",
        "def equation_output_check(expected_output, target_output, error):\n",
        "    success = 0\n",
        "    if isinstance(target_output, dict):\n",
        "        for key in target_output.keys():\n",
        "            try:\n",
        "                success += equation_output_check(expected_output[key], \n",
        "                                         target_output[key], error)\n",
        "            except:\n",
        "                print(\"Error: {} for variable {}.\".format(error,\n",
        "                                                                          key))\n",
        "        if success == len(target_output.keys()):\n",
        "            return 1\n",
        "        else:\n",
        "            return 0\n",
        "    elif isinstance(target_output, tuple) or isinstance(target_output, list):\n",
        "        for i in range(len(target_output)):\n",
        "            try: \n",
        "                success += equation_output_check(expected_output[i], \n",
        "                                         target_output[i], error)\n",
        "            except:\n",
        "                print(\"Error: {} for variable in position {}.\".format(error, i))\n",
        "        if success == len(target_output):\n",
        "            return 1\n",
        "        else:\n",
        "            return 0\n",
        "                \n",
        "    else:\n",
        "        if hasattr(target_output, 'shape'):\n",
        "            np.testing.assert_array_almost_equal(target_output, expected_output)\n",
        "        else:\n",
        "            assert target_output == expected_output\n",
        "        return 1\n",
        "    \n",
        "def shape_check(expected_output, target_output, error):\n",
        "    success = 0\n",
        "    if isinstance(target_output, dict):\n",
        "        for key in target_output.keys():\n",
        "            try:\n",
        "                success += shape_check(expected_output[key], \n",
        "                                         target_output[key], error)\n",
        "            except:\n",
        "                print(\"Error: {} for variable {}.\".format(error, key))\n",
        "        if success == len(target_output.keys()):\n",
        "            return 1\n",
        "        else:\n",
        "            return 0\n",
        "    elif isinstance(target_output, tuple) or isinstance(target_output, list):\n",
        "        for i in range(len(target_output)):\n",
        "            try: \n",
        "                success += shape_check(expected_output[i], \n",
        "                                         target_output[i], error)\n",
        "            except:\n",
        "                print(\"Error: {} for variable {}.\".format(error, i))\n",
        "        if success == len(target_output):\n",
        "            return 1\n",
        "        else:\n",
        "            return 0\n",
        "                \n",
        "    else:\n",
        "        if hasattr(target_output, 'shape'):\n",
        "            assert target_output.shape == expected_output.shape\n",
        "        return 1\n",
        "                \n",
        "def single_test(test_cases, target):\n",
        "    success = 0\n",
        "    for test_case in test_cases:\n",
        "        try:\n",
        "            if test_case['name'] == \"datatype_check\":\n",
        "                assert isinstance(target(*test_case['input']),\n",
        "                                  type(test_case[\"expected\"]))\n",
        "                success += 1\n",
        "            if test_case['name'] == \"equation_output_check\":\n",
        "                assert np.allclose(test_case[\"expected\"],\n",
        "                                   target(*test_case['input']))\n",
        "                success += 1\n",
        "            if test_case['name'] == \"shape_check\":\n",
        "                assert test_case['expected'].shape == target(*test_case['input']).shape\n",
        "                success += 1\n",
        "        except:\n",
        "            print(\"Error: \" + test_case['error'])\n",
        "            \n",
        "    if success == len(test_cases):\n",
        "        print(\"\\033[92m All tests passed.\")\n",
        "    else:\n",
        "        print('\\033[92m', success,\" Tests passed\")\n",
        "        print('\\033[91m', len(test_cases) - success, \" Tests failed\")\n",
        "        raise AssertionError(\"Not all tests were passed for {}. Check your equations and avoid using global variables inside the function.\".format(target.__name__))\n",
        "        \n",
        "def multiple_test(test_cases, target):\n",
        "    success = 0\n",
        "    for test_case in test_cases:\n",
        "        try:\n",
        "            target_answer = target(*test_case['input'])                   \n",
        "            if test_case['name'] == \"datatype_check\":\n",
        "                success += datatype_check(test_case['expected'], target_answer, test_case['error'])\n",
        "            if test_case['name'] == \"equation_output_check\":\n",
        "                success += equation_output_check(test_case['expected'], target_answer, test_case['error'])\n",
        "            if test_case['name'] == \"shape_check\":\n",
        "                success += shape_check(test_case['expected'], target_answer, test_case['error'])\n",
        "        except:\n",
        "            print(\"Error: \" + test_case['error'])\n",
        "            \n",
        "    if success == len(test_cases):\n",
        "        print(\"\\033[92m All tests passed.\")\n",
        "    else:\n",
        "        print('\\033[92m', success,\" Tests passed\")\n",
        "        print('\\033[91m', len(test_cases) - success, \" Tests failed\")\n",
        "        raise AssertionError(\"Not all tests were passed for {}. Check your equations and avoid using global variables inside the function.\".format(target.__name__))\n",
        "        \n",
        "        \n",
        "        \n"
      ],
      "metadata": {
        "id": "8fIsLrdiBJI0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "import numpy as np\n",
        "import h5py\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from tensorflow.python.framework import ops\n",
        "\n",
        "\n",
        "def load_happy_dataset():\n",
        "    train_dataset = h5py.File('dataset_path/train_happy.h5', \"r\")\n",
        "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
        "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
        "\n",
        "    test_dataset = h5py.File('dataset_path/test_happy.h5', \"r\")\n",
        "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
        "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
        "\n",
        "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
        "    \n",
        "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
        "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
        "    \n",
        "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n",
        "\n",
        "def load_signs_dataset():\n",
        "    train_dataset = h5py.File('dataset_path/train_signs.h5', \"r\")\n",
        "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
        "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
        "\n",
        "    test_dataset = h5py.File('dataset_path/test_signs.h5', \"r\")\n",
        "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
        "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
        "\n",
        "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
        "    \n",
        "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
        "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
        "    \n",
        "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n",
        "\n",
        "def random_mini_batches(X, Y, mini_batch_size=64, seed=0):\n",
        "    \"\"\"\n",
        "    Creates a list of random minibatches from (X, Y)\n",
        "\n",
        "    Arguments:\n",
        "    X -- input data, of shape (input size, number of examples) (m, Hi, Wi, Ci)\n",
        "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples) (m, n_y)\n",
        "    mini_batch_size - size of the mini-batches, integer\n",
        "    seed -- this is only for the purpose of grading, so that you're \"random minibatches are the same as ours.\n",
        "\n",
        "    Returns:\n",
        "    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n",
        "    \"\"\"\n",
        "\n",
        "    m = X.shape[0]                  # number of training examples\n",
        "    mini_batches = []\n",
        "    np.random.seed(seed)\n",
        "\n",
        "    # Step 1: Shuffle (X, Y)\n",
        "    permutation = list(np.random.permutation(m))\n",
        "    shuffled_X = X[permutation, :, :, :]\n",
        "    shuffled_Y = Y[permutation, :]\n",
        "\n",
        "    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n",
        "    # number of mini batches of size mini_batch_size in your partitionning\n",
        "    num_complete_minibatches = math.floor(m/mini_batch_size)\n",
        "    for k in range(0, num_complete_minibatches):\n",
        "        mini_batch_X = shuffled_X[k * mini_batch_size: k *\n",
        "                                  mini_batch_size + mini_batch_size, :, :, :]\n",
        "        mini_batch_Y = shuffled_Y[k * mini_batch_size: k *\n",
        "                                  mini_batch_size + mini_batch_size, :]\n",
        "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
        "        mini_batches.append(mini_batch)\n",
        "\n",
        "    # Handling the end case (last mini-batch < mini_batch_size)\n",
        "    if m % mini_batch_size != 0:\n",
        "        mini_batch_X = shuffled_X[num_complete_minibatches *\n",
        "                                  mini_batch_size: m, :, :, :]\n",
        "        mini_batch_Y = shuffled_Y[num_complete_minibatches *\n",
        "                                  mini_batch_size: m, :]\n",
        "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
        "        mini_batches.append(mini_batch)\n",
        "\n",
        "    return mini_batches\n",
        "\n",
        "\n",
        "def convert_to_one_hot(Y, C):\n",
        "    Y = np.eye(C)[Y.reshape(-1)].T\n",
        "    return Y\n",
        "\n",
        "\n",
        "def forward_propagation_for_predict(X, parameters):\n",
        "    \"\"\"\n",
        "    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX\n",
        "\n",
        "    Arguments:\n",
        "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
        "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\"\n",
        "                  the shapes are given in initialize_parameters\n",
        "\n",
        "    Returns:\n",
        "    Z3 -- the output of the last LINEAR unit\n",
        "    \"\"\"\n",
        "\n",
        "    # Retrieve the parameters from the dictionary \"parameters\"\n",
        "    W1 = parameters['W1']\n",
        "    b1 = parameters['b1']\n",
        "    W2 = parameters['W2']\n",
        "    b2 = parameters['b2']\n",
        "    W3 = parameters['W3']\n",
        "    b3 = parameters['b3']\n",
        "    # Numpy Equivalents:\n",
        "    # Z1 = np.dot(W1, X) + b1\n",
        "    Z1 = tf.add(tf.matmul(W1, X), b1)\n",
        "    A1 = tf.nn.relu(Z1)                                    # A1 = relu(Z1)\n",
        "    # Z2 = np.dot(W2, a1) + b2\n",
        "    Z2 = tf.add(tf.matmul(W2, A1), b2)\n",
        "    A2 = tf.nn.relu(Z2)                                    # A2 = relu(Z2)\n",
        "    # Z3 = np.dot(W3,Z2) + b3\n",
        "    Z3 = tf.add(tf.matmul(W3, A2), b3)\n",
        "\n",
        "    return Z3\n",
        "\n",
        "\n",
        "def predict(X, parameters):\n",
        "\n",
        "    W1 = tf.convert_to_tensor(parameters[\"W1\"])\n",
        "    b1 = tf.convert_to_tensor(parameters[\"b1\"])\n",
        "    W2 = tf.convert_to_tensor(parameters[\"W2\"])\n",
        "    b2 = tf.convert_to_tensor(parameters[\"b2\"])\n",
        "    W3 = tf.convert_to_tensor(parameters[\"W3\"])\n",
        "    b3 = tf.convert_to_tensor(parameters[\"b3\"])\n",
        "\n",
        "    params = {\"W1\": W1,\n",
        "              \"b1\": b1,\n",
        "              \"W2\": W2,\n",
        "              \"b2\": b2,\n",
        "              \"W3\": W3,\n",
        "              \"b3\": b3}\n",
        "\n",
        "    x = tf.placeholder(\"float\", [12288, 1])\n",
        "\n",
        "    z3 = forward_propagation_for_predict(x, params)\n",
        "    p = tf.argmax(z3)\n",
        "\n",
        "    sess = tf.Session()\n",
        "    prediction = sess.run(p, feed_dict={x: X})\n",
        "\n",
        "    return prediction\n",
        "\n",
        "# def predict(X, parameters):\n",
        "#\n",
        "#    W1 = tf.convert_to_tensor(parameters[\"W1\"])\n",
        "#    b1 = tf.convert_to_tensor(parameters[\"b1\"])\n",
        "#    W2 = tf.convert_to_tensor(parameters[\"W2\"])\n",
        "#    b2 = tf.convert_to_tensor(parameters[\"b2\"])\n",
        "##    W3 = tf.convert_to_tensor(parameters[\"W3\"])\n",
        "##    b3 = tf.convert_to_tensor(parameters[\"b3\"])\n",
        "#\n",
        "# params = {\"W1\": W1,\n",
        "# \"b1\": b1,\n",
        "# \"W2\": W2,\n",
        "# \"b2\": b2,\n",
        "# \"W3\": W3,\n",
        "# \"b3\": b3}\n",
        "#\n",
        "#    params = {\"W1\": W1,\n",
        "#              \"b1\": b1,\n",
        "#              \"W2\": W2,\n",
        "#              \"b2\": b2}\n",
        "#\n",
        "#    x = tf.placeholder(\"float\", [12288, 1])\n",
        "#\n",
        "#    z3 = forward_propagation(x, params)\n",
        "#    p = tf.argmax(z3)\n",
        "#\n",
        "#    with tf.Session() as sess:\n",
        "#        prediction = sess.run(p, feed_dict = {x: X})\n",
        "#\n",
        "#    return prediction\n"
      ],
      "metadata": {
        "id": "n7CxR30DBN87"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "import numpy as np\n",
        "import h5py\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.pyplot import imread\n",
        "import scipy\n",
        "from PIL import Image\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "import tensorflow.keras.layers as tfl\n",
        "from tensorflow.python.framework import ops\n",
        "\n",
        "%matplotlib inline\n",
        "np.random.seed(1)"
      ],
      "metadata": {
        "id": "pck970NpBPzC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_happy_dataset()\n",
        "\n",
        "# Normalize image vectors\n",
        "X_train = X_train_orig/255.\n",
        "X_test = X_test_orig/255.\n",
        "\n",
        "# Reshape\n",
        "Y_train = Y_train_orig.T\n",
        "Y_test = Y_test_orig.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))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I9TL_7KZBg6z",
        "outputId": "0a8dc832-bccb-4df5-9a37-839d1aeaad7f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "number of training examples = 600\n",
            "number of test examples = 150\n",
            "X_train shape: (600, 64, 64, 3)\n",
            "Y_train shape: (600, 1)\n",
            "X_test shape: (150, 64, 64, 3)\n",
            "Y_test shape: (150, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "index = 124\n",
        "plt.imshow(X_train_orig[index]) #display sample training image\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 432
        },
        "id": "1fpT8vn5Bjd5",
        "outputId": "4be5bba6-9727-469a-a0d6-352644cdde3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: happyModel\n",
        "\n",
        "def happyModel():\n",
        "    \"\"\"\n",
        "    Implements the forward propagation for the binary classification model:\n",
        "    ZEROPAD2D -> CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> FLATTEN -> DENSE\n",
        "    \n",
        "    Note that for simplicity and grading purposes, you'll hard-code all the values\n",
        "    such as the stride and kernel (filter) sizes. \n",
        "    Normally, functions should take these values as function parameters.\n",
        "    \n",
        "    Arguments:\n",
        "    None\n",
        "\n",
        "    Returns:\n",
        "    model -- TF Keras model (object containing the information for the entire training process) \n",
        "    \"\"\"\n",
        "    model = tf.keras.Sequential([\n",
        "            tf.keras.Input(shape=(64 , 64 ,3)),\n",
        "            ## ZeroPadding2D with padding 3, input shape of 64 x 64 x 3\n",
        "            tfl.ZeroPadding2D(padding=3),\n",
        "            ## Conv2D with 32 7x7 filters and stride of 1\n",
        "            tfl.Conv2D(filters=32,kernel_size=7,strides=1),\n",
        "            ## BatchNormalization for axis 3\n",
        "            tfl.BatchNormalization(axis=3, momentum=0.99, epsilon=0.001),\n",
        "            ## ReLU\n",
        "            tfl.ReLU(),\n",
        "            ## Max Pooling 2D with default parameters\n",
        "            tfl.MaxPool2D(),\n",
        "            ## Flatten layer\n",
        "             tfl.Flatten(),\n",
        "            ## Dense layer with 1 unit for output & 'sigmoid' activation\n",
        "            tfl.Dense(1,activation='sigmoid')\n",
        "            # YOUR CODE STARTS HERE\n",
        "            \n",
        "            \n",
        "            # YOUR CODE ENDS HERE\n",
        "        ])\n",
        "    \n",
        "    return model"
      ],
      "metadata": {
        "id": "psed570XCriR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "happy_model = happyModel()\n",
        "# Print a summary for each layer\n",
        "for layer in summary(happy_model):\n",
        "    print(layer)\n",
        "    \n",
        "output = [['ZeroPadding2D', (None, 70, 70, 3), 0, ((3, 3), (3, 3))],\n",
        "            ['Conv2D', (None, 64, 64, 32), 4736, 'valid', 'linear', 'GlorotUniform'],\n",
        "            ['BatchNormalization', (None, 64, 64, 32), 128],\n",
        "            ['ReLU', (None, 64, 64, 32), 0],\n",
        "            ['MaxPooling2D', (None, 32, 32, 32), 0, (2, 2), (2, 2), 'valid'],\n",
        "            ['Flatten', (None, 32768), 0],\n",
        "            ['Dense', (None, 1), 32769, 'sigmoid']]\n",
        "    \n",
        "comparator(summary(happy_model), output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jozNgMeNC04p",
        "outputId": "a1837e20-1ce9-4c86-9d84-640c962c7e73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['ZeroPadding2D', (None, 70, 70, 3), 0, ((3, 3), (3, 3))]\n",
            "['Conv2D', (None, 64, 64, 32), 4736, 'valid', 'linear', 'GlorotUniform']\n",
            "['BatchNormalization', (None, 64, 64, 32), 128]\n",
            "['ReLU', (None, 64, 64, 32), 0]\n",
            "['MaxPooling2D', (None, 32, 32, 32), 0, (2, 2), (2, 2), 'valid']\n",
            "['Flatten', (None, 32768), 0]\n",
            "['Dense', (None, 1), 32769, 'sigmoid']\n",
            "All tests passed!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "happy_model.compile(optimizer='adam',\n",
        "                   loss='binary_crossentropy',\n",
        "                   metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "9RcJLUM0C3Kx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "happy_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiHaF5seC6Qx",
        "outputId": "48bdf3ec-586c-4e87-d1a1-4b020dcbfd6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " zero_padding2d (ZeroPadding  (None, 70, 70, 3)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d (Conv2D)             (None, 64, 64, 32)        4736      \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 64, 64, 32)       128       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " re_lu (ReLU)                (None, 64, 64, 32)        0         \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 32, 32, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 32768)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1)                 32769     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 37,633\n",
            "Trainable params: 37,569\n",
            "Non-trainable params: 64\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "happy_model.fit(X_train, Y_train, epochs=15, batch_size=16)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4XGHfJKRC8Sq",
        "outputId": "0306b258-9513-4a96-83a1-f76465db88a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "38/38 [==============================] - 6s 121ms/step - loss: 1.9561 - accuracy: 0.6367\n",
            "Epoch 2/15\n",
            "38/38 [==============================] - 7s 189ms/step - loss: 0.2446 - accuracy: 0.9017\n",
            "Epoch 3/15\n",
            "38/38 [==============================] - 4s 113ms/step - loss: 0.1484 - accuracy: 0.9517\n",
            "Epoch 4/15\n",
            "38/38 [==============================] - 5s 143ms/step - loss: 0.1550 - accuracy: 0.9400\n",
            "Epoch 5/15\n",
            "38/38 [==============================] - 6s 145ms/step - loss: 0.1142 - accuracy: 0.9683\n",
            "Epoch 6/15\n",
            "38/38 [==============================] - 5s 130ms/step - loss: 0.1118 - accuracy: 0.9600\n",
            "Epoch 7/15\n",
            "38/38 [==============================] - 7s 178ms/step - loss: 0.1536 - accuracy: 0.9450\n",
            "Epoch 8/15\n",
            "38/38 [==============================] - 8s 214ms/step - loss: 0.0842 - accuracy: 0.9717\n",
            "Epoch 9/15\n",
            "38/38 [==============================] - 4s 114ms/step - loss: 0.0894 - accuracy: 0.9700\n",
            "Epoch 10/15\n",
            "38/38 [==============================] - 6s 150ms/step - loss: 0.0661 - accuracy: 0.9817\n",
            "Epoch 11/15\n",
            "38/38 [==============================] - 5s 137ms/step - loss: 0.0451 - accuracy: 0.9900\n",
            "Epoch 12/15\n",
            "38/38 [==============================] - 6s 147ms/step - loss: 0.0468 - accuracy: 0.9867\n",
            "Epoch 13/15\n",
            "38/38 [==============================] - 9s 243ms/step - loss: 0.0518 - accuracy: 0.9800\n",
            "Epoch 14/15\n",
            "38/38 [==============================] - 4s 115ms/step - loss: 0.0559 - accuracy: 0.9833\n",
            "Epoch 15/15\n",
            "38/38 [==============================] - 6s 155ms/step - loss: 0.0457 - accuracy: 0.9833\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7fd1ef2ccd60>"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "happy_model.evaluate(X_test, Y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0G_YFHdLDBRh",
        "outputId": "c960ad92-4855-48aa-96f1-5581dc54c430"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5/5 [==============================] - 0s 59ms/step - loss: 0.3209 - accuracy: 0.8800\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.32089731097221375, 0.8799999952316284]"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Loading the data (signs)\n",
        "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_signs_dataset()"
      ],
      "metadata": {
        "id": "qVDd5m9ZDSOa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of an image from the dataset\n",
        "index = 9\n",
        "plt.imshow(X_train_orig[index])\n",
        "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "id": "5XG66h-XDSLh",
        "outputId": "b2e08578-410b-4051-f59a-4f47c5bc08de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "y = 4\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "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",
        "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))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1_OC0_RQDSHp",
        "outputId": "00a47b39-f6cb-4b1e-f046-3832e6852db5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: convolutional_model\n",
        "\n",
        "def convolutional_model(input_shape):\n",
        "    \"\"\"\n",
        "    Implements the forward propagation for the model:\n",
        "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> DENSE\n",
        "    \n",
        "    Note that for simplicity and grading purposes, you'll hard-code some values\n",
        "    such as the stride and kernel (filter) sizes. \n",
        "    Normally, functions should take these values as function parameters.\n",
        "    \n",
        "    Arguments:\n",
        "    input_img -- input dataset, of shape (input_shape)\n",
        "\n",
        "    Returns:\n",
        "    model -- TF Keras model (object containing the information for the entire training process) \n",
        "    \"\"\"\n",
        "\n",
        "    input_img = tf.keras.Input(shape=input_shape)\n",
        "    ## CONV2D: 8 filters 4x4, stride of 1, padding 'SAME'\n",
        "    Z1 = tfl.Conv2D(filters= 8. , kernel_size=4 , padding='same',strides=1)(input_img)\n",
        "    ## RELU\n",
        "    A1 = tfl.ReLU()(Z1)\n",
        "    ## MAXPOOL: window 8x8, stride 8, padding 'SAME'\n",
        "    P1 = tfl.MaxPool2D(pool_size=8, strides=8, padding='SAME')(A1)\n",
        "    ## CONV2D: 16 filters 2x2, stride 1, padding 'SAME'\n",
        "    Z2 = tfl.Conv2D(filters= 16. , kernel_size=2 , padding='same',strides=1)(P1)\n",
        "    ## RELU\n",
        "    A2 = tfl.ReLU()(Z2)\n",
        "    ## MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
        "    P2 = tfl.MaxPool2D(pool_size=4, strides=4, padding='SAME')(A2)\n",
        "    ## FLATTEN\n",
        "    F = tfl.Flatten()(P2)\n",
        "    ## Dense layer\n",
        "    ## 6 neurons in output layer. Hint: one of the arguments should be \"activation='softmax'\" \n",
        "    outputs = tfl.Dense(units= 6 , activation='softmax')(F)\n",
        "    # YOUR CODE STARTS HERE\n",
        "    \n",
        "    \n",
        "    # YOUR CODE ENDS HERE\n",
        "    model = tf.keras.Model(inputs=input_img, outputs=outputs)\n",
        "    return model"
      ],
      "metadata": {
        "id": "MfCA47bJDR0C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "conv_model = convolutional_model((64, 64, 3))\n",
        "conv_model.compile(optimizer='adam',\n",
        "                  loss='categorical_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "conv_model.summary()\n",
        "    \n",
        "output = [['InputLayer', [(None, 64, 64, 3)], 0],\n",
        "        ['Conv2D', (None, 64, 64, 8), 392, 'same', 'linear', 'GlorotUniform'],\n",
        "        ['ReLU', (None, 64, 64, 8), 0],\n",
        "        ['MaxPooling2D', (None, 8, 8, 8), 0, (8, 8), (8, 8), 'same'],\n",
        "        ['Conv2D', (None, 8, 8, 16), 528, 'same', 'linear', 'GlorotUniform'],\n",
        "        ['ReLU', (None, 8, 8, 16), 0],\n",
        "        ['MaxPooling2D', (None, 2, 2, 16), 0, (4, 4), (4, 4), 'same'],\n",
        "        ['Flatten', (None, 64), 0],\n",
        "        ['Dense', (None, 6), 390, 'softmax']]\n",
        "    \n",
        "comparator(summary(conv_model), output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bb0aRlQAD4LT",
        "outputId": "a0e48d2f-a47c-40ce-dff1-f9f7a7aa5ae1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_2 (InputLayer)        [(None, 64, 64, 3)]       0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 64, 64, 8)         392       \n",
            "                                                                 \n",
            " re_lu_1 (ReLU)              (None, 64, 64, 8)         0         \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 8, 8, 8)          0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 8, 8, 16)          528       \n",
            "                                                                 \n",
            " re_lu_2 (ReLU)              (None, 8, 8, 16)          0         \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 2, 2, 16)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten_1 (Flatten)         (None, 64)                0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 6)                 390       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,310\n",
            "Trainable params: 1,310\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "All tests passed!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M4hDNYkHD6aR",
        "outputId": "b21c743d-329e-4e6d-849f-d7996b9c1014"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "17/17 [==============================] - 5s 181ms/step - loss: 1.8044 - accuracy: 0.1806 - val_loss: 1.7880 - val_accuracy: 0.1833\n",
            "Epoch 2/100\n",
            "17/17 [==============================] - 2s 125ms/step - loss: 1.7870 - accuracy: 0.2130 - val_loss: 1.7851 - val_accuracy: 0.2417\n",
            "Epoch 3/100\n",
            "17/17 [==============================] - 6s 333ms/step - loss: 1.7833 - accuracy: 0.2231 - val_loss: 1.7809 - val_accuracy: 0.2167\n",
            "Epoch 4/100\n",
            "17/17 [==============================] - 2s 125ms/step - loss: 1.7798 - accuracy: 0.2472 - val_loss: 1.7770 - val_accuracy: 0.2333\n",
            "Epoch 5/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 1.7763 - accuracy: 0.2796 - val_loss: 1.7735 - val_accuracy: 0.2417\n",
            "Epoch 6/100\n",
            "17/17 [==============================] - 3s 196ms/step - loss: 1.7719 - accuracy: 0.2815 - val_loss: 1.7675 - val_accuracy: 0.3083\n",
            "Epoch 7/100\n",
            "17/17 [==============================] - 4s 220ms/step - loss: 1.7656 - accuracy: 0.3102 - val_loss: 1.7618 - val_accuracy: 0.3000\n",
            "Epoch 8/100\n",
            "17/17 [==============================] - 3s 167ms/step - loss: 1.7591 - accuracy: 0.3231 - val_loss: 1.7546 - val_accuracy: 0.3167\n",
            "Epoch 9/100\n",
            "17/17 [==============================] - 3s 204ms/step - loss: 1.7515 - accuracy: 0.3361 - val_loss: 1.7465 - val_accuracy: 0.3917\n",
            "Epoch 10/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 1.7417 - accuracy: 0.3694 - val_loss: 1.7366 - val_accuracy: 0.4000\n",
            "Epoch 11/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 1.7305 - accuracy: 0.3769 - val_loss: 1.7242 - val_accuracy: 0.4250\n",
            "Epoch 12/100\n",
            "17/17 [==============================] - 2s 126ms/step - loss: 1.7163 - accuracy: 0.3880 - val_loss: 1.7100 - val_accuracy: 0.4417\n",
            "Epoch 13/100\n",
            "17/17 [==============================] - 3s 162ms/step - loss: 1.6994 - accuracy: 0.4046 - val_loss: 1.6934 - val_accuracy: 0.4417\n",
            "Epoch 14/100\n",
            "17/17 [==============================] - 5s 289ms/step - loss: 1.6797 - accuracy: 0.4130 - val_loss: 1.6723 - val_accuracy: 0.4583\n",
            "Epoch 15/100\n",
            "17/17 [==============================] - 2s 137ms/step - loss: 1.6566 - accuracy: 0.4287 - val_loss: 1.6475 - val_accuracy: 0.4750\n",
            "Epoch 16/100\n",
            "17/17 [==============================] - 3s 209ms/step - loss: 1.6293 - accuracy: 0.4352 - val_loss: 1.6191 - val_accuracy: 0.4833\n",
            "Epoch 17/100\n",
            "17/17 [==============================] - 5s 303ms/step - loss: 1.5995 - accuracy: 0.4463 - val_loss: 1.5879 - val_accuracy: 0.4833\n",
            "Epoch 18/100\n",
            "17/17 [==============================] - 5s 282ms/step - loss: 1.5657 - accuracy: 0.4556 - val_loss: 1.5553 - val_accuracy: 0.5000\n",
            "Epoch 19/100\n",
            "17/17 [==============================] - 3s 142ms/step - loss: 1.5311 - accuracy: 0.4713 - val_loss: 1.5211 - val_accuracy: 0.5083\n",
            "Epoch 20/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 1.4951 - accuracy: 0.4917 - val_loss: 1.4853 - val_accuracy: 0.5333\n",
            "Epoch 21/100\n",
            "17/17 [==============================] - 2s 127ms/step - loss: 1.4574 - accuracy: 0.5009 - val_loss: 1.4443 - val_accuracy: 0.5167\n",
            "Epoch 22/100\n",
            "17/17 [==============================] - 4s 268ms/step - loss: 1.4176 - accuracy: 0.5176 - val_loss: 1.4019 - val_accuracy: 0.5333\n",
            "Epoch 23/100\n",
            "17/17 [==============================] - 2s 125ms/step - loss: 1.3762 - accuracy: 0.5407 - val_loss: 1.3577 - val_accuracy: 0.5333\n",
            "Epoch 24/100\n",
            "17/17 [==============================] - 2s 126ms/step - loss: 1.3355 - accuracy: 0.5556 - val_loss: 1.3171 - val_accuracy: 0.5417\n",
            "Epoch 25/100\n",
            "17/17 [==============================] - 2s 127ms/step - loss: 1.2949 - accuracy: 0.5704 - val_loss: 1.2743 - val_accuracy: 0.5500\n",
            "Epoch 26/100\n",
            "17/17 [==============================] - 2s 127ms/step - loss: 1.2558 - accuracy: 0.5824 - val_loss: 1.2348 - val_accuracy: 0.5417\n",
            "Epoch 27/100\n",
            "17/17 [==============================] - 3s 160ms/step - loss: 1.2177 - accuracy: 0.5981 - val_loss: 1.1982 - val_accuracy: 0.5667\n",
            "Epoch 28/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 1.1832 - accuracy: 0.6009 - val_loss: 1.1617 - val_accuracy: 0.5833\n",
            "Epoch 29/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 1.1508 - accuracy: 0.6167 - val_loss: 1.1286 - val_accuracy: 0.5917\n",
            "Epoch 30/100\n",
            "17/17 [==============================] - 2s 125ms/step - loss: 1.1206 - accuracy: 0.6213 - val_loss: 1.0967 - val_accuracy: 0.6000\n",
            "Epoch 31/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 1.0926 - accuracy: 0.6222 - val_loss: 1.0674 - val_accuracy: 0.6083\n",
            "Epoch 32/100\n",
            "17/17 [==============================] - 4s 226ms/step - loss: 1.0660 - accuracy: 0.6241 - val_loss: 1.0367 - val_accuracy: 0.6083\n",
            "Epoch 33/100\n",
            "17/17 [==============================] - 2s 139ms/step - loss: 1.0406 - accuracy: 0.6213 - val_loss: 1.0108 - val_accuracy: 0.6167\n",
            "Epoch 34/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 1.0160 - accuracy: 0.6343 - val_loss: 0.9890 - val_accuracy: 0.6417\n",
            "Epoch 35/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 0.9956 - accuracy: 0.6417 - val_loss: 0.9650 - val_accuracy: 0.6500\n",
            "Epoch 36/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.9726 - accuracy: 0.6509 - val_loss: 0.9439 - val_accuracy: 0.6833\n",
            "Epoch 37/100\n",
            "17/17 [==============================] - 2s 148ms/step - loss: 0.9537 - accuracy: 0.6565 - val_loss: 0.9235 - val_accuracy: 0.6833\n",
            "Epoch 38/100\n",
            "17/17 [==============================] - 4s 225ms/step - loss: 0.9347 - accuracy: 0.6657 - val_loss: 0.9056 - val_accuracy: 0.6833\n",
            "Epoch 39/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.9176 - accuracy: 0.6731 - val_loss: 0.8884 - val_accuracy: 0.7083\n",
            "Epoch 40/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 0.8996 - accuracy: 0.6815 - val_loss: 0.8728 - val_accuracy: 0.7250\n",
            "Epoch 41/100\n",
            "17/17 [==============================] - 2s 125ms/step - loss: 0.8847 - accuracy: 0.6870 - val_loss: 0.8578 - val_accuracy: 0.7333\n",
            "Epoch 42/100\n",
            "17/17 [==============================] - 2s 132ms/step - loss: 0.8693 - accuracy: 0.6926 - val_loss: 0.8438 - val_accuracy: 0.7333\n",
            "Epoch 43/100\n",
            "17/17 [==============================] - 4s 214ms/step - loss: 0.8554 - accuracy: 0.6991 - val_loss: 0.8310 - val_accuracy: 0.7417\n",
            "Epoch 44/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.8410 - accuracy: 0.7065 - val_loss: 0.8191 - val_accuracy: 0.7500\n",
            "Epoch 45/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.8280 - accuracy: 0.7102 - val_loss: 0.8083 - val_accuracy: 0.7500\n",
            "Epoch 46/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.8155 - accuracy: 0.7139 - val_loss: 0.7971 - val_accuracy: 0.7500\n",
            "Epoch 47/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 0.8036 - accuracy: 0.7204 - val_loss: 0.7869 - val_accuracy: 0.7417\n",
            "Epoch 48/100\n",
            "17/17 [==============================] - 4s 216ms/step - loss: 0.7925 - accuracy: 0.7269 - val_loss: 0.7769 - val_accuracy: 0.7417\n",
            "Epoch 49/100\n",
            "17/17 [==============================] - 2s 134ms/step - loss: 0.7807 - accuracy: 0.7269 - val_loss: 0.7687 - val_accuracy: 0.7333\n",
            "Epoch 50/100\n",
            "17/17 [==============================] - 2s 122ms/step - loss: 0.7698 - accuracy: 0.7269 - val_loss: 0.7594 - val_accuracy: 0.7250\n",
            "Epoch 51/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.7596 - accuracy: 0.7296 - val_loss: 0.7517 - val_accuracy: 0.7333\n",
            "Epoch 52/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.7500 - accuracy: 0.7343 - val_loss: 0.7444 - val_accuracy: 0.7500\n",
            "Epoch 53/100\n",
            "17/17 [==============================] - 3s 189ms/step - loss: 0.7402 - accuracy: 0.7380 - val_loss: 0.7375 - val_accuracy: 0.7667\n",
            "Epoch 54/100\n",
            "17/17 [==============================] - 4s 223ms/step - loss: 0.7310 - accuracy: 0.7370 - val_loss: 0.7316 - val_accuracy: 0.7667\n",
            "Epoch 55/100\n",
            "17/17 [==============================] - 3s 155ms/step - loss: 0.7220 - accuracy: 0.7435 - val_loss: 0.7255 - val_accuracy: 0.7667\n",
            "Epoch 56/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.7135 - accuracy: 0.7454 - val_loss: 0.7191 - val_accuracy: 0.7667\n",
            "Epoch 57/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.7049 - accuracy: 0.7481 - val_loss: 0.7134 - val_accuracy: 0.7750\n",
            "Epoch 58/100\n",
            "17/17 [==============================] - 3s 182ms/step - loss: 0.6970 - accuracy: 0.7537 - val_loss: 0.7082 - val_accuracy: 0.7750\n",
            "Epoch 59/100\n",
            "17/17 [==============================] - 3s 193ms/step - loss: 0.6896 - accuracy: 0.7565 - val_loss: 0.7025 - val_accuracy: 0.7750\n",
            "Epoch 60/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.6816 - accuracy: 0.7574 - val_loss: 0.6976 - val_accuracy: 0.7833\n",
            "Epoch 61/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.6743 - accuracy: 0.7602 - val_loss: 0.6920 - val_accuracy: 0.7833\n",
            "Epoch 62/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 0.6672 - accuracy: 0.7639 - val_loss: 0.6873 - val_accuracy: 0.7833\n",
            "Epoch 63/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 0.6603 - accuracy: 0.7657 - val_loss: 0.6828 - val_accuracy: 0.7833\n",
            "Epoch 64/100\n",
            "17/17 [==============================] - 4s 224ms/step - loss: 0.6537 - accuracy: 0.7667 - val_loss: 0.6784 - val_accuracy: 0.7917\n",
            "Epoch 65/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.6472 - accuracy: 0.7667 - val_loss: 0.6741 - val_accuracy: 0.7917\n",
            "Epoch 66/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.6408 - accuracy: 0.7713 - val_loss: 0.6702 - val_accuracy: 0.7917\n",
            "Epoch 67/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.6349 - accuracy: 0.7750 - val_loss: 0.6658 - val_accuracy: 0.7917\n",
            "Epoch 68/100\n",
            "17/17 [==============================] - 2s 124ms/step - loss: 0.6288 - accuracy: 0.7759 - val_loss: 0.6625 - val_accuracy: 0.7833\n",
            "Epoch 69/100\n",
            "17/17 [==============================] - 4s 211ms/step - loss: 0.6231 - accuracy: 0.7806 - val_loss: 0.6581 - val_accuracy: 0.8000\n",
            "Epoch 70/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.6173 - accuracy: 0.7833 - val_loss: 0.6549 - val_accuracy: 0.8000\n",
            "Epoch 71/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.6118 - accuracy: 0.7861 - val_loss: 0.6508 - val_accuracy: 0.8167\n",
            "Epoch 72/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.6066 - accuracy: 0.7880 - val_loss: 0.6467 - val_accuracy: 0.8000\n",
            "Epoch 73/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 0.6010 - accuracy: 0.7907 - val_loss: 0.6428 - val_accuracy: 0.8000\n",
            "Epoch 74/100\n",
            "17/17 [==============================] - 4s 211ms/step - loss: 0.5957 - accuracy: 0.7907 - val_loss: 0.6398 - val_accuracy: 0.8000\n",
            "Epoch 75/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.5905 - accuracy: 0.7926 - val_loss: 0.6367 - val_accuracy: 0.8083\n",
            "Epoch 76/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 0.5854 - accuracy: 0.7954 - val_loss: 0.6333 - val_accuracy: 0.8083\n",
            "Epoch 77/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 0.5803 - accuracy: 0.7963 - val_loss: 0.6312 - val_accuracy: 0.8083\n",
            "Epoch 78/100\n",
            "17/17 [==============================] - 2s 134ms/step - loss: 0.5760 - accuracy: 0.7972 - val_loss: 0.6275 - val_accuracy: 0.8083\n",
            "Epoch 79/100\n",
            "17/17 [==============================] - 4s 218ms/step - loss: 0.5710 - accuracy: 0.8009 - val_loss: 0.6242 - val_accuracy: 0.8083\n",
            "Epoch 80/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 0.5664 - accuracy: 0.8000 - val_loss: 0.6214 - val_accuracy: 0.8000\n",
            "Epoch 81/100\n",
            "17/17 [==============================] - 2s 122ms/step - loss: 0.5615 - accuracy: 0.8056 - val_loss: 0.6189 - val_accuracy: 0.8000\n",
            "Epoch 82/100\n",
            "17/17 [==============================] - 2s 119ms/step - loss: 0.5573 - accuracy: 0.8065 - val_loss: 0.6158 - val_accuracy: 0.8000\n",
            "Epoch 83/100\n",
            "17/17 [==============================] - 2s 122ms/step - loss: 0.5530 - accuracy: 0.8093 - val_loss: 0.6128 - val_accuracy: 0.8000\n",
            "Epoch 84/100\n",
            "17/17 [==============================] - 4s 223ms/step - loss: 0.5486 - accuracy: 0.8083 - val_loss: 0.6102 - val_accuracy: 0.8000\n",
            "Epoch 85/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.5442 - accuracy: 0.8111 - val_loss: 0.6079 - val_accuracy: 0.8000\n",
            "Epoch 86/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.5399 - accuracy: 0.8120 - val_loss: 0.6058 - val_accuracy: 0.8000\n",
            "Epoch 87/100\n",
            "17/17 [==============================] - 2s 122ms/step - loss: 0.5357 - accuracy: 0.8130 - val_loss: 0.6038 - val_accuracy: 0.8000\n",
            "Epoch 88/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.5314 - accuracy: 0.8148 - val_loss: 0.6017 - val_accuracy: 0.8000\n",
            "Epoch 89/100\n",
            "17/17 [==============================] - 4s 215ms/step - loss: 0.5276 - accuracy: 0.8157 - val_loss: 0.6000 - val_accuracy: 0.8000\n",
            "Epoch 90/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.5233 - accuracy: 0.8176 - val_loss: 0.5984 - val_accuracy: 0.8000\n",
            "Epoch 91/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.5196 - accuracy: 0.8176 - val_loss: 0.5966 - val_accuracy: 0.8000\n",
            "Epoch 92/100\n",
            "17/17 [==============================] - 3s 152ms/step - loss: 0.5156 - accuracy: 0.8204 - val_loss: 0.5949 - val_accuracy: 0.8000\n",
            "Epoch 93/100\n",
            "17/17 [==============================] - 2s 140ms/step - loss: 0.5121 - accuracy: 0.8222 - val_loss: 0.5930 - val_accuracy: 0.7917\n",
            "Epoch 94/100\n",
            "17/17 [==============================] - 4s 230ms/step - loss: 0.5080 - accuracy: 0.8269 - val_loss: 0.5913 - val_accuracy: 0.8000\n",
            "Epoch 95/100\n",
            "17/17 [==============================] - 2s 123ms/step - loss: 0.5043 - accuracy: 0.8278 - val_loss: 0.5896 - val_accuracy: 0.7917\n",
            "Epoch 96/100\n",
            "17/17 [==============================] - 2s 122ms/step - loss: 0.5007 - accuracy: 0.8296 - val_loss: 0.5885 - val_accuracy: 0.7917\n",
            "Epoch 97/100\n",
            "17/17 [==============================] - 2s 121ms/step - loss: 0.4977 - accuracy: 0.8324 - val_loss: 0.5873 - val_accuracy: 0.7917\n",
            "Epoch 98/100\n",
            "17/17 [==============================] - 2s 120ms/step - loss: 0.4943 - accuracy: 0.8333 - val_loss: 0.5859 - val_accuracy: 0.7917\n",
            "Epoch 99/100\n",
            "17/17 [==============================] - 3s 206ms/step - loss: 0.4909 - accuracy: 0.8333 - val_loss: 0.5844 - val_accuracy: 0.7833\n",
            "Epoch 100/100\n",
            "17/17 [==============================] - 3s 172ms/step - loss: 0.4875 - accuracy: 0.8343 - val_loss: 0.5833 - val_accuracy: 0.7833\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history.history"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Og_9awHMD9Vh",
        "outputId": "b3fda353-648c-4709-e546-38163e9ade14"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'loss': [1.8043972253799438,\n",
              "  1.7870073318481445,\n",
              "  1.7833136320114136,\n",
              "  1.7797670364379883,\n",
              "  1.7762995958328247,\n",
              "  1.7718526124954224,\n",
              "  1.7655584812164307,\n",
              "  1.759086012840271,\n",
              "  1.7515157461166382,\n",
              "  1.7416938543319702,\n",
              "  1.7305045127868652,\n",
              "  1.7163227796554565,\n",
              "  1.699419379234314,\n",
              "  1.6796656847000122,\n",
              "  1.6566238403320312,\n",
              "  1.6293224096298218,\n",
              "  1.5995110273361206,\n",
              "  1.5656864643096924,\n",
              "  1.5311018228530884,\n",
              "  1.4950693845748901,\n",
              "  1.4574472904205322,\n",
              "  1.4176242351531982,\n",
              "  1.3762342929840088,\n",
              "  1.3355181217193604,\n",
              "  1.2949076890945435,\n",
              "  1.2557928562164307,\n",
              "  1.217650055885315,\n",
              "  1.1831516027450562,\n",
              "  1.1508418321609497,\n",
              "  1.1205672025680542,\n",
              "  1.092617154121399,\n",
              "  1.0660076141357422,\n",
              "  1.0406129360198975,\n",
              "  1.015987753868103,\n",
              "  0.9955844283103943,\n",
              "  0.9726395010948181,\n",
              "  0.953737735748291,\n",
              "  0.9346697926521301,\n",
              "  0.9176074266433716,\n",
              "  0.8995617628097534,\n",
              "  0.8847094774246216,\n",
              "  0.8693323135375977,\n",
              "  0.8553972244262695,\n",
              "  0.8410211205482483,\n",
              "  0.8280036449432373,\n",
              "  0.8154860734939575,\n",
              "  0.8035993576049805,\n",
              "  0.7924721837043762,\n",
              "  0.7806527018547058,\n",
              "  0.7697586417198181,\n",
              "  0.7596463561058044,\n",
              "  0.749972939491272,\n",
              "  0.7402198910713196,\n",
              "  0.7310289740562439,\n",
              "  0.7220381498336792,\n",
              "  0.7135260701179504,\n",
              "  0.7048954367637634,\n",
              "  0.697025716304779,\n",
              "  0.6895999908447266,\n",
              "  0.681578516960144,\n",
              "  0.6742797493934631,\n",
              "  0.6672499179840088,\n",
              "  0.6603022813796997,\n",
              "  0.6536856889724731,\n",
              "  0.6471737623214722,\n",
              "  0.640803337097168,\n",
              "  0.6349063515663147,\n",
              "  0.6287955641746521,\n",
              "  0.6230965256690979,\n",
              "  0.6172849535942078,\n",
              "  0.6117936372756958,\n",
              "  0.6065855026245117,\n",
              "  0.600970983505249,\n",
              "  0.5956874489784241,\n",
              "  0.5904984474182129,\n",
              "  0.5853756070137024,\n",
              "  0.5803429484367371,\n",
              "  0.5759610533714294,\n",
              "  0.5710446238517761,\n",
              "  0.5663580298423767,\n",
              "  0.5615400075912476,\n",
              "  0.5573239326477051,\n",
              "  0.5530214905738831,\n",
              "  0.5485879182815552,\n",
              "  0.5442309975624084,\n",
              "  0.5398549437522888,\n",
              "  0.535721480846405,\n",
              "  0.5313533544540405,\n",
              "  0.5275537371635437,\n",
              "  0.5232865214347839,\n",
              "  0.5196406245231628,\n",
              "  0.5156421065330505,\n",
              "  0.5120540857315063,\n",
              "  0.5079881548881531,\n",
              "  0.5043238401412964,\n",
              "  0.5007272362709045,\n",
              "  0.4976634979248047,\n",
              "  0.49426501989364624,\n",
              "  0.49092334508895874,\n",
              "  0.4874725937843323],\n",
              " 'accuracy': [0.1805555522441864,\n",
              "  0.21296297013759613,\n",
              "  0.2231481522321701,\n",
              "  0.24722221493721008,\n",
              "  0.2796296179294586,\n",
              "  0.28148147463798523,\n",
              "  0.31018519401550293,\n",
              "  0.3231481611728668,\n",
              "  0.3361110985279083,\n",
              "  0.36944442987442017,\n",
              "  0.3768518567085266,\n",
              "  0.3879629671573639,\n",
              "  0.4046296179294586,\n",
              "  0.41296297311782837,\n",
              "  0.4287036955356598,\n",
              "  0.43518519401550293,\n",
              "  0.4462963044643402,\n",
              "  0.4555555582046509,\n",
              "  0.4712963104248047,\n",
              "  0.49166667461395264,\n",
              "  0.5009258985519409,\n",
              "  0.5175926089286804,\n",
              "  0.5407407283782959,\n",
              "  0.5555555820465088,\n",
              "  0.5703703761100769,\n",
              "  0.5824074149131775,\n",
              "  0.5981481671333313,\n",
              "  0.6009259223937988,\n",
              "  0.6166666746139526,\n",
              "  0.6212962865829468,\n",
              "  0.6222222447395325,\n",
              "  0.6240741014480591,\n",
              "  0.6212962865829468,\n",
              "  0.6342592835426331,\n",
              "  0.6416666507720947,\n",
              "  0.6509259343147278,\n",
              "  0.6564815044403076,\n",
              "  0.6657407283782959,\n",
              "  0.6731481552124023,\n",
              "  0.6814814805984497,\n",
              "  0.6870370507240295,\n",
              "  0.6925926208496094,\n",
              "  0.6990740895271301,\n",
              "  0.7064814567565918,\n",
              "  0.710185170173645,\n",
              "  0.7138888835906982,\n",
              "  0.720370352268219,\n",
              "  0.7268518805503845,\n",
              "  0.7268518805503845,\n",
              "  0.7268518805503845,\n",
              "  0.729629635810852,\n",
              "  0.7342592477798462,\n",
              "  0.7379629611968994,\n",
              "  0.7370370626449585,\n",
              "  0.7435185313224792,\n",
              "  0.7453703880310059,\n",
              "  0.7481481432914734,\n",
              "  0.7537037134170532,\n",
              "  0.7564814686775208,\n",
              "  0.7574074268341064,\n",
              "  0.760185182094574,\n",
              "  0.7638888955116272,\n",
              "  0.7657407522201538,\n",
              "  0.7666666507720947,\n",
              "  0.7666666507720947,\n",
              "  0.7712963223457336,\n",
              "  0.7749999761581421,\n",
              "  0.7759259343147278,\n",
              "  0.7805555462837219,\n",
              "  0.7833333611488342,\n",
              "  0.7861111164093018,\n",
              "  0.7879629731178284,\n",
              "  0.7907407283782959,\n",
              "  0.7907407283782959,\n",
              "  0.7925925850868225,\n",
              "  0.7953703999519348,\n",
              "  0.7962962985038757,\n",
              "  0.7972221970558167,\n",
              "  0.8009259104728699,\n",
              "  0.800000011920929,\n",
              "  0.8055555820465088,\n",
              "  0.8064814805984497,\n",
              "  0.8092592358589172,\n",
              "  0.8083333373069763,\n",
              "  0.8111110925674438,\n",
              "  0.8120370507240295,\n",
              "  0.8129629492759705,\n",
              "  0.8148148059844971,\n",
              "  0.8157407641410828,\n",
              "  0.8175926208496094,\n",
              "  0.8175926208496094,\n",
              "  0.8203703761100769,\n",
              "  0.8222222328186035,\n",
              "  0.8268518447875977,\n",
              "  0.8277778029441833,\n",
              "  0.8296296000480652,\n",
              "  0.8324074149131775,\n",
              "  0.8333333134651184,\n",
              "  0.8333333134651184,\n",
              "  0.8342592716217041],\n",
              " 'val_loss': [1.787951111793518,\n",
              "  1.7851003408432007,\n",
              "  1.7808946371078491,\n",
              "  1.7769794464111328,\n",
              "  1.7734555006027222,\n",
              "  1.7675033807754517,\n",
              "  1.761756420135498,\n",
              "  1.75462806224823,\n",
              "  1.7465338706970215,\n",
              "  1.7365802526474,\n",
              "  1.7242066860198975,\n",
              "  1.7099653482437134,\n",
              "  1.6933635473251343,\n",
              "  1.672255039215088,\n",
              "  1.6474663019180298,\n",
              "  1.6191039085388184,\n",
              "  1.5879490375518799,\n",
              "  1.5552629232406616,\n",
              "  1.521081805229187,\n",
              "  1.4853094816207886,\n",
              "  1.4442723989486694,\n",
              "  1.4018927812576294,\n",
              "  1.3576951026916504,\n",
              "  1.317058801651001,\n",
              "  1.2742611169815063,\n",
              "  1.2347646951675415,\n",
              "  1.1981745958328247,\n",
              "  1.1616570949554443,\n",
              "  1.1285719871520996,\n",
              "  1.0966509580612183,\n",
              "  1.0674031972885132,\n",
              "  1.036716103553772,\n",
              "  1.0107917785644531,\n",
              "  0.9890326261520386,\n",
              "  0.9649871587753296,\n",
              "  0.9438761472702026,\n",
              "  0.9235480427742004,\n",
              "  0.9055948853492737,\n",
              "  0.8884000182151794,\n",
              "  0.8727506995201111,\n",
              "  0.8578377962112427,\n",
              "  0.8438094854354858,\n",
              "  0.8309980034828186,\n",
              "  0.8191289305686951,\n",
              "  0.8083171844482422,\n",
              "  0.7970766425132751,\n",
              "  0.7868680357933044,\n",
              "  0.7769040465354919,\n",
              "  0.7687225341796875,\n",
              "  0.7593542337417603,\n",
              "  0.751659095287323,\n",
              "  0.7444279789924622,\n",
              "  0.7375364899635315,\n",
              "  0.7315809726715088,\n",
              "  0.7254917621612549,\n",
              "  0.7191317677497864,\n",
              "  0.7134469151496887,\n",
              "  0.7081583142280579,\n",
              "  0.7025492191314697,\n",
              "  0.6975604891777039,\n",
              "  0.692048192024231,\n",
              "  0.6873124837875366,\n",
              "  0.6827682256698608,\n",
              "  0.6784241795539856,\n",
              "  0.6741431355476379,\n",
              "  0.6702410578727722,\n",
              "  0.6657930016517639,\n",
              "  0.6625041961669922,\n",
              "  0.6581235527992249,\n",
              "  0.6548938751220703,\n",
              "  0.6508429050445557,\n",
              "  0.6466761231422424,\n",
              "  0.6428452730178833,\n",
              "  0.6398009061813354,\n",
              "  0.6367204189300537,\n",
              "  0.633331835269928,\n",
              "  0.6311652660369873,\n",
              "  0.6274788975715637,\n",
              "  0.6242123246192932,\n",
              "  0.6214009523391724,\n",
              "  0.6188567876815796,\n",
              "  0.6158096194267273,\n",
              "  0.6127866506576538,\n",
              "  0.6102131009101868,\n",
              "  0.6079080104827881,\n",
              "  0.6058275699615479,\n",
              "  0.6038169860839844,\n",
              "  0.6017101407051086,\n",
              "  0.6000410914421082,\n",
              "  0.5983504056930542,\n",
              "  0.5966159701347351,\n",
              "  0.5948798656463623,\n",
              "  0.5929813385009766,\n",
              "  0.5912570953369141,\n",
              "  0.5896056890487671,\n",
              "  0.5885017514228821,\n",
              "  0.5873172283172607,\n",
              "  0.585866391658783,\n",
              "  0.5844009518623352,\n",
              "  0.5833346247673035],\n",
              " 'val_accuracy': [0.18333333730697632,\n",
              "  0.24166665971279144,\n",
              "  0.21666666865348816,\n",
              "  0.23333333432674408,\n",
              "  0.24166665971279144,\n",
              "  0.3083333373069763,\n",
              "  0.30000001192092896,\n",
              "  0.3166666626930237,\n",
              "  0.3916666805744171,\n",
              "  0.4000000059604645,\n",
              "  0.42500001192092896,\n",
              "  0.4416666626930237,\n",
              "  0.4416666626930237,\n",
              "  0.4583333432674408,\n",
              "  0.4749999940395355,\n",
              "  0.4833333194255829,\n",
              "  0.4833333194255829,\n",
              "  0.5,\n",
              "  0.5083333253860474,\n",
              "  0.5333333611488342,\n",
              "  0.5166666507720947,\n",
              "  0.5333333611488342,\n",
              "  0.5333333611488342,\n",
              "  0.5416666865348816,\n",
              "  0.550000011920929,\n",
              "  0.5416666865348816,\n",
              "  0.5666666626930237,\n",
              "  0.5833333134651184,\n",
              "  0.5916666388511658,\n",
              "  0.6000000238418579,\n",
              "  0.6083333492279053,\n",
              "  0.6083333492279053,\n",
              "  0.6166666746139526,\n",
              "  0.6416666507720947,\n",
              "  0.6499999761581421,\n",
              "  0.6833333373069763,\n",
              "  0.6833333373069763,\n",
              "  0.6833333373069763,\n",
              "  0.7083333134651184,\n",
              "  0.7250000238418579,\n",
              "  0.7333333492279053,\n",
              "  0.7333333492279053,\n",
              "  0.7416666746139526,\n",
              "  0.75,\n",
              "  0.75,\n",
              "  0.75,\n",
              "  0.7416666746139526,\n",
              "  0.7416666746139526,\n",
              "  0.7333333492279053,\n",
              "  0.7250000238418579,\n",
              "  0.7333333492279053,\n",
              "  0.75,\n",
              "  0.7666666507720947,\n",
              "  0.7666666507720947,\n",
              "  0.7666666507720947,\n",
              "  0.7666666507720947,\n",
              "  0.7749999761581421,\n",
              "  0.7749999761581421,\n",
              "  0.7749999761581421,\n",
              "  0.7833333611488342,\n",
              "  0.7833333611488342,\n",
              "  0.7833333611488342,\n",
              "  0.7833333611488342,\n",
              "  0.7916666865348816,\n",
              "  0.7916666865348816,\n",
              "  0.7916666865348816,\n",
              "  0.7916666865348816,\n",
              "  0.7833333611488342,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.8166666626930237,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.8083333373069763,\n",
              "  0.8083333373069763,\n",
              "  0.8083333373069763,\n",
              "  0.8083333373069763,\n",
              "  0.8083333373069763,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.800000011920929,\n",
              "  0.7916666865348816,\n",
              "  0.800000011920929,\n",
              "  0.7916666865348816,\n",
              "  0.7916666865348816,\n",
              "  0.7916666865348816,\n",
              "  0.7916666865348816,\n",
              "  0.7833333611488342,\n",
              "  0.7833333611488342]}"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The history.history[\"loss\"] entry is a dictionary with as many values as epochs that the\n",
        "# model was trained on. \n",
        "df_loss_acc = pd.DataFrame(history.history)\n",
        "df_loss= df_loss_acc[['loss','val_loss']]\n",
        "df_loss.rename(columns={'loss':'train','val_loss':'validation'},inplace=True)\n",
        "df_acc= df_loss_acc[['accuracy','val_accuracy']]\n",
        "df_acc.rename(columns={'accuracy':'train','val_accuracy':'validation'},inplace=True)\n",
        "df_loss.plot(title='Model loss',figsize=(12,8)).set(xlabel='Epoch',ylabel='Loss')\n",
        "df_acc.plot(title='Model Accuracy',figsize=(12,8)).set(xlabel='Epoch',ylabel='Accuracy')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "2AunyzEbEK3Z",
        "outputId": "a62211a0-351c-4d3d-a640-8db81910d0bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-28-55f5ebfbfb89>:5: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  df_loss.rename(columns={'loss':'train','val_loss':'validation'},inplace=True)\n",
            "<ipython-input-28-55f5ebfbfb89>:7: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  df_acc.rename(columns={'accuracy':'train','val_accuracy':'validation'},inplace=True)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Text(0.5, 0, 'Epoch'), Text(0, 0.5, 'Accuracy')]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "lhpqBIfBFM4q"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}