01- CIFAR10-My vgg Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9e84f383",
   "metadata": {
    "id": "9e84f383"
   },
   "outputs": [],
   "source": [
    "# Import\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPool2D, Flatten, GlobalAveragePooling2D, Dropout, Add, BatchNormalization\n",
    "from tensorflow.keras.activations import relu\n",
    "from tensorflow.keras.regularizers import l2\n",
    "from tensorflow.keras.callbacks import LearningRateScheduler\n",
    "from tensorflow.keras.optimizers import SGD\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3628955d",
   "metadata": {
    "id": "3628955d"
   },
   "source": [
    "### Load and preprocessing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2a1c6cc",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f2a1c6cc",
    "outputId": "e64c4927-7a11-4473-f47f-ffb4d80ad689"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
      "170500096/170498071 [==============================] - 4s 0us/step\n",
      "170508288/170498071 [==============================] - 4s 0us/step\n"
     ]
    }
   ],
   "source": [
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b77e107",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1b77e107",
    "outputId": "5ac7e281-ff69-485f-9f18-32bec0f4bcef"
   },
   "outputs": [],
   "source": [
    "x_train.shape, y_train.shape, x_test.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ac53970",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1ac53970",
    "outputId": "bdf0fb59-4345-40ed-dba8-13b23a5bbcbe"
   },
   "outputs": [],
   "source": [
    "y_train = to_categorical(y_train, num_classes=10)\n",
    "y_test = to_categorical(y_test, num_classes=10)\n",
    "\n",
    "y_train.shape, y_test.shape, y_train.dtype, y_test.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e6d057a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3e6d057a",
    "outputId": "9872ebc4-7e76-465c-ffeb-cb67f6db9c50"
   },
   "outputs": [],
   "source": [
    "x_train = x_train.astype(np.float32) / 255.0\n",
    "x_test = x_test.astype(np.float32) / 255.0\n",
    "\n",
    "x_train.shape, x_train.min(), x_train.max(), x_train.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cc70ee9b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 301
    },
    "id": "cc70ee9b",
    "outputId": "0330d327-d85d-47af-9f9d-404a48ad3461"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<matplotlib.image.AxesImage at 0x7fcc7f914950>,\n",
       " array([0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], dtype=float32))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(x_train[0]), y_train[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9944b78",
   "metadata": {
    "id": "c9944b78"
   },
   "source": [
    "### Train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a864694d",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a864694d",
    "outputId": "27e513f4-876f-442e-a7e5-0d7136fdfe37"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((37500, 32, 32, 3), (37500, 10), (12500, 32, 32, 3), (12500, 10))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "x_train, x_val, y_train, y_val = train_test_split(x_train, y_train)\n",
    "\n",
    "x_train.shape, y_train.shape, x_val.shape, y_val.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "z1r5zsR_PcLM",
   "metadata": {
    "id": "z1r5zsR_PcLM"
   },
   "source": [
    "### Data generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "Vv0bwD5LPfMV",
   "metadata": {
    "id": "Vv0bwD5LPfMV"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "batch_size = 32\n",
    "\n",
    "data_generator = ImageDataGenerator(\n",
    "    width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True)\n",
    "\n",
    "train_generator = data_generator.flow(x_train, y_train, batch_size=batch_size)\n",
    "step_per_epoch = x_train.shape[0] // batch_size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53f9557c",
   "metadata": {
    "id": "53f9557c"
   },
   "source": [
    "### Define, Complile and fit model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c43f8e39",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c43f8e39",
    "outputId": "7e3910a9-fbb0-423c-d8cb-5ec5872b50a7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 32, 32, 3)]  0           []                               \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)                (None, 32, 32, 32)   896         ['input_1[0][0]']                \n",
      "                                                                                                  \n",
      " batch_normalization (BatchNorm  (None, 32, 32, 32)  128         ['conv2d[0][0]']                 \n",
      " alization)                                                                                       \n",
      "                                                                                                  \n",
      " tf.nn.relu (TFOpLambda)        (None, 32, 32, 32)   0           ['batch_normalization[0][0]']    \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)              (None, 32, 32, 32)   9248        ['tf.nn.relu[0][0]']             \n",
      "                                                                                                  \n",
      " batch_normalization_1 (BatchNo  (None, 32, 32, 32)  128         ['conv2d_1[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_1 (TFOpLambda)      (None, 32, 32, 32)   0           ['batch_normalization_1[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)              (None, 32, 32, 32)   9248        ['tf.nn.relu_1[0][0]']           \n",
      "                                                                                                  \n",
      " batch_normalization_2 (BatchNo  (None, 32, 32, 32)  128         ['conv2d_2[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_2 (TFOpLambda)      (None, 32, 32, 32)   0           ['batch_normalization_2[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_3 (Conv2D)              (None, 16, 16, 32)   9248        ['tf.nn.relu_2[0][0]']           \n",
      "                                                                                                  \n",
      " conv2d_4 (Conv2D)              (None, 16, 16, 64)   18496       ['conv2d_3[0][0]']               \n",
      "                                                                                                  \n",
      " batch_normalization_3 (BatchNo  (None, 16, 16, 64)  256         ['conv2d_4[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_3 (TFOpLambda)      (None, 16, 16, 64)   0           ['batch_normalization_3[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_5 (Conv2D)              (None, 16, 16, 64)   36928       ['tf.nn.relu_3[0][0]']           \n",
      "                                                                                                  \n",
      " add (Add)                      (None, 16, 16, 64)   0           ['tf.nn.relu_3[0][0]',           \n",
      "                                                                  'conv2d_5[0][0]']               \n",
      "                                                                                                  \n",
      " tf.nn.relu_4 (TFOpLambda)      (None, 16, 16, 64)   0           ['add[0][0]']                    \n",
      "                                                                                                  \n",
      " conv2d_6 (Conv2D)              (None, 16, 16, 64)   36928       ['tf.nn.relu_4[0][0]']           \n",
      "                                                                                                  \n",
      " batch_normalization_4 (BatchNo  (None, 16, 16, 64)  256         ['conv2d_6[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_5 (TFOpLambda)      (None, 16, 16, 64)   0           ['batch_normalization_4[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_7 (Conv2D)              (None, 8, 8, 32)     18464       ['tf.nn.relu_5[0][0]']           \n",
      "                                                                                                  \n",
      " conv2d_8 (Conv2D)              (None, 8, 8, 128)    36992       ['conv2d_7[0][0]']               \n",
      "                                                                                                  \n",
      " batch_normalization_5 (BatchNo  (None, 8, 8, 128)   512         ['conv2d_8[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_6 (TFOpLambda)      (None, 8, 8, 128)    0           ['batch_normalization_5[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_9 (Conv2D)              (None, 8, 8, 128)    147584      ['tf.nn.relu_6[0][0]']           \n",
      "                                                                                                  \n",
      " batch_normalization_6 (BatchNo  (None, 8, 8, 128)   512         ['conv2d_9[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_7 (TFOpLambda)      (None, 8, 8, 128)    0           ['batch_normalization_6[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_10 (Conv2D)             (None, 8, 8, 128)    147584      ['tf.nn.relu_7[0][0]']           \n",
      "                                                                                                  \n",
      " batch_normalization_7 (BatchNo  (None, 8, 8, 128)   512         ['conv2d_10[0][0]']              \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.nn.relu_8 (TFOpLambda)      (None, 8, 8, 128)    0           ['batch_normalization_7[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_11 (Conv2D)             (None, 4, 4, 32)     36896       ['tf.nn.relu_8[0][0]']           \n",
      "                                                                                                  \n",
      " global_average_pooling2d (Glob  (None, 32)          0           ['conv2d_11[0][0]']              \n",
      " alAveragePooling2D)                                                                              \n",
      "                                                                                                  \n",
      " dense (Dense)                  (None, 10)           330         ['global_average_pooling2d[0][0]'\n",
      "                                                                 ]                                \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 511,274\n",
      "Trainable params: 510,058\n",
      "Non-trainable params: 1,216\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Define Model\n",
    "\n",
    "input_layer = Input(shape=(32, 32, 3))\n",
    "\n",
    "conv11 = Conv2D(filters=32, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(input_layer)\n",
    "conv11 = BatchNormalization()(conv11)\n",
    "conv11 = relu(conv11)\n",
    "conv12 = Conv2D(filters=32, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(conv11)\n",
    "conv12 = BatchNormalization()(conv12)\n",
    "conv12 = relu(conv12)\n",
    "conv13 = Conv2D(filters=32, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(conv12)\n",
    "conv13 = BatchNormalization()(conv13)\n",
    "conv13 = relu(conv13)\n",
    "maxpool1 = Conv2D(filters=32, kernel_size=(3, 3), strides=2, padding='same', kernel_initializer='HeNormal')(conv13)\n",
    "\n",
    "conv21 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(maxpool1)\n",
    "conv21 = BatchNormalization()(conv21)\n",
    "conv21 = relu(conv21)\n",
    "conv22 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(conv21)\n",
    "conv22 = Add()([conv21, conv22])\n",
    "conv22 = relu(conv22)\n",
    "conv23 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(conv22)\n",
    "conv23 = BatchNormalization()(conv23)\n",
    "conv23 = relu(conv23)\n",
    "maxpool2 = Conv2D(filters=32, kernel_size=(3, 3), strides=2, padding='same', kernel_initializer='HeNormal')(conv23)\n",
    "\n",
    "conv31 = Conv2D(filters=128, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(maxpool2)\n",
    "conv31 = BatchNormalization()(conv31)\n",
    "conv31 = relu(conv31)\n",
    "conv32 = Conv2D(filters=128, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(conv31)\n",
    "conv32 = BatchNormalization()(conv32)\n",
    "conv32 = relu(conv32)\n",
    "conv33 = Conv2D(filters=128, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer='HeNormal', kernel_regularizer=l2(1e-4))(conv32)\n",
    "conv33 = BatchNormalization()(conv33)\n",
    "conv33 = relu(conv33)\n",
    "maxpool3 = Conv2D(filters=32, kernel_size=(3, 3), strides=2, padding='same', kernel_initializer='HeNormal')(conv33)\n",
    "\n",
    "flatten = GlobalAveragePooling2D()(maxpool3)\n",
    "\n",
    "output_layer = Dense(units=10, activation='softmax')(flatten)\n",
    "\n",
    "model = Model(input_layer, output_layer)\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5123e527",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5123e527",
    "outputId": "c0b9d30c-fc76-499c-8ef0-666a099fdb92"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate:  0.01\n"
     ]
    }
   ],
   "source": [
    "# Learning Rate Schedule\n",
    "\n",
    "def lr_schedule(epoch):\n",
    "    \"\"\"Learning Rate Schedule\n",
    "\n",
    "    Learning rate is scheduled to be reduced after 80, 120, 160, 180 epochs.\n",
    "    Called automatically every epoch as part of callbacks during training.\n",
    "\n",
    "    # Arguments\n",
    "        epoch (int): The number of epochs\n",
    "\n",
    "    # Returns\n",
    "        lr (float32): learning rate\n",
    "    \"\"\"\n",
    "    lr = 1e-2\n",
    "    if epoch > 180:\n",
    "        lr *= 0.5e-3\n",
    "    elif epoch > 160:\n",
    "        lr *= 1e-3\n",
    "    elif epoch > 120:\n",
    "        lr *= 1e-2\n",
    "    elif epoch > 80:\n",
    "        lr *= 1e-1\n",
    "    print('Learning rate: ', lr)\n",
    "    return lr\n",
    "\n",
    "\n",
    "# opt = SGD(learning_rate=0.01, momentum=0.9, decay=0.0001)\n",
    "opt = SGD(learning_rate=lr_schedule(0), momentum=0.9)\n",
    "\n",
    "model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "28178146",
   "metadata": {
    "id": "28178146"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import ReduceLROnPlateau\n",
    "\n",
    "lr_scheduler = LearningRateScheduler(lr_schedule)\n",
    "\n",
    "lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.001),\n",
    "                               cooldown=0,\n",
    "                               patience=5,\n",
    "                               min_lr=0.5e-6)\n",
    "# alpha = 0.01\n",
    "# decay_steps = 25\n",
    "# learning_rate = 0.1\n",
    "# def cosine_decay(epoch):\n",
    "#         step = min(epoch, 50)\n",
    "#         cosine_decay = 0.5 * (1 + math.cos(math.pi * step / decay_steps))\n",
    "#         decayed = (1 - alpha) * cosine_decay + alpha\n",
    "#         return learning_rate * decayed\n",
    "\n",
    "\n",
    "\n",
    "# initial_learning_rate = 0.01\n",
    "# def schedule(epoch, lr):\n",
    "#     if epoch < 200:\n",
    "#         learning_rate = 0.01\n",
    "#     else:\n",
    "#         learning_rate = 0.1\n",
    "#     return learning_rate\n",
    "\n",
    "\n",
    "\n",
    "# LearningRateScheduler = LearningRateScheduler(cosine_decay)\n",
    "early_stop = EarlyStopping(monitor='val_accuracy', mode='max', patience=50, restore_best_weights=True)\n",
    "callbacks = [early_stop, lr_reducer, lr_scheduler]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2d79600",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "d2d79600",
    "outputId": "9b122c2a-8cfc-40d6-c0e1-2621281b1be0"
   },
   "outputs": [],
   "source": [
    "# Fit\n",
    "\n",
    "model.fit(train_generator, epochs=600, validation_data=(x_val, y_val), callbacks= callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "be3e5859",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "be3e5859",
    "outputId": "6f0b3a37-2c59-41a4-882c-29baaa95e9bc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fcb8f800210>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot History\n",
    "\n",
    "history = pd.DataFrame(model.history.history)\n",
    "history.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "90ec4a21",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "90ec4a21",
    "outputId": "54046fac-31ad-45ae-bd24-44ecf80aa8e7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fcc036df110>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history[['loss', 'val_loss']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "55ad2153",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "55ad2153",
    "outputId": "a6c3f8bb-465f-41da-e05d-eda40c9c27e6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fcc036b2190>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history[['accuracy', 'val_accuracy']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hX-Ig9jQDdTS",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hX-Ig9jQDdTS",
    "outputId": "abc75e24-484e-4f21-b7f8-e746ff3b3908"
   },
   "outputs": [],
   "source": [
    "# Save Model\n",
    "\n",
    "model.save(\"cifar10.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "02580992",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "02580992",
    "outputId": "918e9a43-5ace-41ed-d0d0-f49ed0e4f69d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 4s 12ms/step - loss: 0.6112 - accuracy: 0.9125\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.6112092137336731, 0.9125000238418579]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Model Evaluate\n",
    "\n",
    "model.evaluate(x_test, y_test)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "CIFAR10.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}