ResNet_image_classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "transfer learning ResNet 152.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "sQ1v1ic8HSOS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "import tensorflow as tf #tf 2.0.0\n",
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZGVvotAefZ4P",
        "colab_type": "text"
      },
      "source": [
        "### Image `Augmentation` for Increasing Dataset (Run Augmentation.py )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NdLPBerQdxJp",
        "colab_type": "text"
      },
      "source": [
        "### ImageDataGenerator (in-place augmentation)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xLOSwgWJIVTU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "\n",
        "train_data_gen = ImageDataGenerator(rotation_range=50,\n",
        "                                    width_shift_range=0.2,\n",
        "                                    height_shift_range=0.2,\n",
        "                                    zoom_range=0.3,\n",
        "                                    horizontal_flip=True,\n",
        "                                    vertical_flip=True,\n",
        "                                    fill_mode='constant',\n",
        "                                    cval=0,\n",
        "                                    rescale=1./255)\n",
        "valid_data_gen = ImageDataGenerator(rotation_range=45,\n",
        "                                    width_shift_range=0.2,\n",
        "                                    height_shift_range=0.2,\n",
        "                                    zoom_range=0.3,\n",
        "                                    horizontal_flip=True,\n",
        "                                    vertical_flip=True,\n",
        "                                    fill_mode='constant',\n",
        "                                    cval=0,\n",
        "                                    rescale=1./255)\n",
        "\n",
        "test_data_gen = ImageDataGenerator(rescale=1./255)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "frfsrzeyPOZk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataset_dir = os.path.join('/content/drive/My Drive/Colab Notebooks/myDataset', 'DT')\n",
        "\n",
        "Batch_size = 8\n",
        "img_h = 256\n",
        "img_w = 256\n",
        "num_classes=20\n",
        "\n",
        "classes = ['owl', # 0\n",
        "            'galaxy', # 1\n",
        "            'lightning', # 2\n",
        "            'wine-bottle', # 3\n",
        "            't-shirt', # 4\n",
        "            'waterfall',# 5\n",
        "            'sword', # 6\n",
        "            'school-bus',# 7           \n",
        "            'calculator', # 8\n",
        "            'sheet-music', #9            \n",
        "            'airplanes',#10      \n",
        "            'lightbulb', # 11\n",
        "            'skyscraper',#12    \n",
        "            'mountain-bike',#13          \n",
        "            'fireworks', #14        \n",
        "            'computer-monitor',#15              \n",
        "            'bear',# 16\n",
        "            'grand-piano', # 17\n",
        "            'kangaroo', # 18\n",
        "            'laptop', #19\n",
        "           ]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nQL0tEo2rgfY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Training\n",
        "SEED = 1234\n",
        "tf.random.set_seed(SEED) \n",
        "\n",
        "training_dir = os.path.join(dataset_dir, 'training')\n",
        "train_gen = train_data_gen.flow_from_directory(training_dir,\n",
        "                                               target_size=(256, 256),\n",
        "                                               batch_size=Batch_size,\n",
        "                                               classes=classes,\n",
        "                                               class_mode='categorical',\n",
        "                                               shuffle=True,\n",
        "                                               seed=SEED)  # targets are directly converted into one-hot vectors\n",
        "\n",
        "# Validation\n",
        "valid_dir = os.path.join(dataset_dir, 'valid')\n",
        "valid_gen = valid_data_gen.flow_from_directory(valid_dir,\n",
        "                                           target_size=(256, 256),\n",
        "                                           batch_size=Batch_size, \n",
        "                                           classes=classes,\n",
        "                                           class_mode='categorical',\n",
        "                                           shuffle=False,\n",
        "                                           seed=SEED)\n",
        "# Test\n",
        "test_dir = os.path.join(dataset_dir, 'testing')\n",
        "test_gen = test_data_gen.flow_from_directory(test_dir,\n",
        "                                             target_size=(256, 256),\n",
        "                                             batch_size=10, \n",
        "                                             shuffle=False,\n",
        "                                             seed=SEED,\n",
        "                                             class_mode=None,\n",
        "                                             )\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z10Dj9Hg6H93",
        "colab_type": "text"
      },
      "source": [
        "## Visualization data "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TvsQvaQz6HSc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "CLASS_NAMES = np.array(['owl','galaxy', 'lightning','wine-bottle','t-shirt','waterfall', 'sword', 'school-bus',\n",
        "                        'calculator','sheet-music','airplanes', 'lightbulb', 'skyscraper','mountain-bike','fireworks', \n",
        "                        'computer-monitor','bear','grand-piano','kangaroo','laptop',], dtype='<U10')\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def show_batch(image_batch, label_batch):\n",
        "  plt.figure(figsize=(25,20))\n",
        "  for n in range(8):\n",
        "      ax = plt.subplot(1,8,n+1)\n",
        "      plt.imshow(image_batch[n])\n",
        "      plt.title(CLASS_NAMES[label_batch[n]==1][0].title())\n",
        "      plt.axis('off')\n",
        "      \n",
        "image_batch, label_batch = next(train_gen)\n",
        "show_batch(image_batch, label_batch)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-qIUTxrjCBF",
        "colab_type": "text"
      },
      "source": [
        "### ResNet152V2 Model "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2dWmSSz6r3UP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ResNet_model = tf.keras.applications.ResNet152V2(weights='imagenet', include_top=False, input_shape=(img_h, img_w, 3))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mx6jXtK1r3Sd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras import Model \n",
        "from tensorflow.keras.layers import Conv2D, Dense, MaxPooling2D, Dropout, Flatten,GlobalAveragePooling2D\n",
        "from tensorflow.keras.models import Sequential\n",
        "\n",
        "# The last 15 layers fine tune\n",
        "for layer in ResNet_model.layers[:-15]:\n",
        "    layer.trainable = False\n",
        "\n",
        "x = ResNet_model.output\n",
        "x = GlobalAveragePooling2D()(x)\n",
        "x = Flatten()(x)\n",
        "x = Dense(units=512, activation='relu')(x)\n",
        "x = Dropout(0.3)(x)\n",
        "x = Dense(units=512, activation='relu')(x)\n",
        "x = Dropout(0.3)(x)\n",
        "output  = Dense(units=20, activation='softmax')(x)\n",
        "model = Model(ResNet_model.input, output)\n",
        "\n",
        "\n",
        "model.summary()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Na89F_Xvanl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "loss = tf.keras.losses.CategoricalCrossentropy()\n",
        "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
        "model.compile(optimizer=optimizer, loss=loss, metrics= ['accuracy'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9I0E2100vhYX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras.callbacks import ReduceLROnPlateau\n",
        "\n",
        "lrr = ReduceLROnPlateau(monitor='val_accuracy', \n",
        "                        patience=3, \n",
        "                        verbose=1, \n",
        "                        factor=0.4, \n",
        "                        min_lr=0.0001)\n",
        "\n",
        "\n",
        "callbacks = [lrr]\n",
        "\n",
        "STEP_SIZE_TRAIN=train_gen.n//train_gen.batch_size\n",
        "STEP_SIZE_VALID=valid_gen.n//valid_gen.batch_size\n",
        "transfer_learning_history = model.fit_generator(generator=train_gen,\n",
        "                   steps_per_epoch=STEP_SIZE_TRAIN,\n",
        "                   validation_data=valid_gen,\n",
        "                   validation_steps=STEP_SIZE_VALID,\n",
        "                   epochs=20,\n",
        "                  callbacks=callbacks,\n",
        "                  class_weight='auto',\n",
        "                  \n",
        "                    \n",
        ")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6O5DpIGe8mxW",
        "colab_type": "text"
      },
      "source": [
        "### Visualization accuracy and loss "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mqr1moI2QEZ3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "acc = transfer_learning_history.history['accuracy']\n",
        "val_acc = transfer_learning_history.history['val_accuracy']\n",
        "\n",
        "loss = transfer_learning_history.history['loss']\n",
        "val_loss = transfer_learning_history.history['val_loss']\n",
        "\n",
        "epochs_range = range(50)\n",
        "\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
        "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(epochs_range, loss, label='Training Loss')\n",
        "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eiV05iHq8Y0o",
        "colab_type": "text"
      },
      "source": [
        "### model evaluate with validation set"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5TOCZASRQOD8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.evaluate(valid_gen, steps=STEP_SIZE_VALID,verbose=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XAdaLrH98eDj",
        "colab_type": "text"
      },
      "source": [
        "## model prediction with test data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IOnoboeA7KHC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "STEP_SIZE_TEST=test_gen.n//test_gen.batch_size\n",
        "test_gen.reset()\n",
        "pred=model.predict(test_gen,\n",
        "steps=STEP_SIZE_TEST,\n",
        "verbose=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ef_zl6T-7OE_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "predicted_class_indices=np.argmax(pred,axis=1)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UWDeEbXO8trj",
        "colab_type": "text"
      },
      "source": [
        "### CSV file for kaggle submission"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mc5JMHkn7N-v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd\n",
        "labels = train_gen.class_indices\n",
        "labels = dict((v,k) for k,v in labels.items())\n",
        "predictions = [k for k in predicted_class_indices]\n",
        "\n",
        "filenames=test_gen.filenames\n",
        "FN=[]\n",
        "for i in filenames:\n",
        "  f = i[5:]\n",
        "  FN.append(f)\n",
        "  \n",
        "\n",
        "results=pd.DataFrame({\"Id\":FN,\n",
        "                      \"Category\":predictions})\n",
        "results.to_csv(\"submission.csv\",index=False)"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}