ResNet-Transfer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from data import Images_load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data has apparently already been downloaded and unpacked.\n",
      "Data has apparently already been downloaded and unpacked.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4006/4006 [00:09<00:00, 442.29it/s]\n",
      "100%|██████████| 4192/4192 [00:10<00:00, 386.32it/s]\n"
     ]
    }
   ],
   "source": [
    "train, validation, test = Images_load.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4611, 224, 224, 3)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.features.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ResNet 50 transfer learning: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Flatten\n",
    "from keras.applications.resnet50 import ResNet50, decode_predictions, preprocess_input\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _prepare_data(train, validation, test):\n",
    "    \"\"\"\n",
    "    Prepare datasets of images for CNN\n",
    "    :param train:\n",
    "    :param validation:\n",
    "    :param test:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    features, y_train = train.features, train.labels\n",
    "    featuresV, y_val = validation.features, validation.labels\n",
    "    featuresT, y_test = test.features, test.labels\n",
    "    x_train = np.stack(features)\n",
    "    x_val = np.stack(featuresV)\n",
    "    x_test = np.stack(featuresT)\n",
    "    x_train = x_train.astype('float32')\n",
    "    x_test = x_test.astype('float32')\n",
    "    x_val = x_val.astype('float32')\n",
    "    x_val /= 255\n",
    "    x_train /= 255\n",
    "    x_test /= 255\n",
    "\n",
    "    return x_train, y_train, x_test, y_test, x_val, y_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "x_train, y_train, x_test, y_test, x_val, y_val=_prepare_data(train,validation,test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/conda/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n",
      "WARNING:tensorflow:From /opt/conda/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:4070: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
      "\n",
      "Downloading data from https://github.com/fchollet/deep-learning-models/releases/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5\n",
      "102858752/102853048 [==============================] - 9s 0us/step\n"
     ]
    }
   ],
   "source": [
    "# Load ResNet50 Trained on imagenet\n",
    "resnet_model = ResNet50(weights=\"imagenet\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We should preprocess the images the same way resnet images were preprocessed\n",
    "x_train_preprocessed = preprocess_input(x_train)\n",
    "x_test_preprocessed = preprocess_input(x_test)\n",
    "x_val_preprocess = preprocess_input(x_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a new model that is ResNet50 minus the very last layer\n",
    "last_layer = resnet_model.get_layer(\"avg_pool\")\n",
    "\n",
    "resnet_layers = keras.Model(inputs=resnet_model.inputs, outputs=last_layer.output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_4\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "model_2 (Model)              (None, 2048)              23587712  \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 2)                 4098      \n",
      "=================================================================\n",
      "Total params: 23,591,810\n",
      "Trainable params: 4,098\n",
      "Non-trainable params: 23,587,712\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# We can directly stich the models together\n",
    "\n",
    "ResNet_adapt=Sequential()\n",
    "ResNet_adapt.add(resnet_layers)\n",
    "ResNet_adapt.add(Dense(2, activation=\"sigmoid\"))\n",
    "\n",
    "ResNet_adapt.layers[0].trainable=False # we are just going to tune the last layer weight the other weights inside of the resnet model will remain the same \n",
    "\n",
    "ResNet_adapt.compile(loss=\"binary_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
    "\n",
    "ResNet_adapt.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.callbacks import EarlyStopping, ModelCheckpoint\n",
    "from keras.callbacks import TensorBoard\n",
    "my_callbacks = [\n",
    "        EarlyStopping(monitor='val_loss', patience=10, verbose=1, mode='auto', restore_best_weights=True),\n",
    "        ModelCheckpoint(filepath='Resnet_transfer.{epoch:02d}-{val_loss:.2f}.h5',\n",
    "                        monitor='val_accuracy', verbose=1,\n",
    "                        save_best_only=True, mode='max'),\n",
    "        TensorBoard(log_dir=\"logs\", histogram_freq=0, write_graph=True, write_images=True)\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 4611 samples, validate on 1538 samples\n",
      "Epoch 1/50\n",
      "4611/4611 [==============================] - 751s 163ms/step - loss: 0.5920 - accuracy: 0.6852 - val_loss: 1.1036 - val_accuracy: 0.4844\n",
      "\n",
      "Epoch 00001: val_accuracy improved from -inf to 0.48440, saving model to Resnet_transfer.01-1.10.h5\n",
      "Epoch 2/50\n",
      "4611/4611 [==============================] - 733s 159ms/step - loss: 0.5507 - accuracy: 0.7224 - val_loss: 1.1658 - val_accuracy: 0.4844\n",
      "\n",
      "Epoch 00002: val_accuracy did not improve from 0.48440\n",
      "Epoch 3/50\n",
      "4611/4611 [==============================] - 754s 164ms/step - loss: 0.5292 - accuracy: 0.7427 - val_loss: 1.2232 - val_accuracy: 0.4844\n",
      "Restoring model weights from the end of the best epoch\n",
      "\n",
      "Epoch 00003: val_accuracy did not improve from 0.48440\n",
      "Epoch 00003: early stopping\n",
      "CPU times: user 3h 11min 16s, sys: 1h 45min 28s, total: 4h 56min 45s\n",
      "Wall time: 37min 30s\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "history=ResNet_adapt.fit(x_train_preprocessed, y_train, epochs=50, validation_data=(x_val_preprocess, y_val), callbacks=my_callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot\n",
    "# plot train and validation loss\n",
    "pyplot.plot(history.history['loss'])\n",
    "pyplot.plot(history.history['val_loss'])\n",
    "pyplot.title('model train vs validation loss')\n",
    "pyplot.ylabel('loss')\n",
    "pyplot.xlabel('epoch')\n",
    "pyplot.legend(['train', 'validation'], loc='upper right')\n",
    "pyplot.show() # overfittinnng gued rassi "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train accuracy: 0.4903491735458374\n"
     ]
    }
   ],
   "source": [
    "score = ResNet_adapt.evaluate(x_train_preprocessed, y_train, verbose=2)\n",
    "print('Train accuracy:', score[ 1 ])\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}