Resnet50_autoencoder_on RAVDESS dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: opencv-python in c:\\users\\shireen\\lib\\site-packages (4.4.0.40)\n",
      "Requirement already satisfied: numpy>=1.17.3 in c:\\users\\shireen\\lib\\site-packages (from opencv-python) (1.18.5)\n"
     ]
    }
   ],
   "source": [
    "!pip install opencv-python\n",
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of images loaded =  1440 \n",
      "No. of labels loaded =  1440\n",
      "<class 'list'> <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "categories = os.listdir(\"C:/Users/Shireen/A FINAL SER ATTEMPT/data/spectograms/images/\")\n",
    "def load_images_and_labels(categories):\n",
    "    img_lst=[]\n",
    "    labels=[]\n",
    "    for index, category in enumerate(categories):\n",
    "        for image_name in os.listdir(fpath+\"/\"+category):\n",
    "            img = cv2.imread(fpath+\"/\"+category+\"/\"+image_name)\n",
    "            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "            \n",
    "            img_array = Image.fromarray(img, 'RGB')\n",
    "            \n",
    "            #resize image to 227 x 227 because the input image resolution for AlexNet is 227 x 227\n",
    "            resized_img = img_array.resize((224, 224))\n",
    "            \n",
    "            img_lst.append(np.array(resized_img))\n",
    "            \n",
    "            labels.append(index)\n",
    "    return img_lst, labels\n",
    "\n",
    "fpath = \"C:/Users/Shireen/A FINAL SER ATTEMPT/data/spectograms/images/\"\n",
    "images, labels = load_images_and_labels(categories)\n",
    "print(\"No. of images loaded = \",len(images),\"\\nNo. of labels loaded = \",len(labels))\n",
    "print(type(images),type(labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Images shape =  (1440, 224, 224, 3) \n",
      "Labels shape =  (1440,)\n",
      "<class 'numpy.ndarray'> <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "images = np.array(images)\n",
    "labels = np.array(labels)\n",
    "\n",
    "print(\"Images shape = \",images.shape,\"\\nLabels shape = \",labels.shape)\n",
    "print(type(images),type(labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'n' values before shuffling =  [   0    1    2 ... 1437 1438 1439]\n",
      "\n",
      "'n' values after shuffling =  [ 168  605  548 ... 1294  860 1126]\n"
     ]
    }
   ],
   "source": [
    "#1-step in data shuffling\n",
    "random_seed=42\n",
    "#get equally spaced numbers in a given range\n",
    "n = np.arange(images.shape[0])\n",
    "print(\"'n' values before shuffling = \",n)\n",
    "\n",
    "#shuffle all the equally spaced values in list 'n'\n",
    "np.random.seed(random_seed)\n",
    "np.random.shuffle(n)\n",
    "print(\"\\n'n' values after shuffling = \",n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Images shape after shuffling =  (1440, 224, 224, 3) \n",
      "Labels shape after shuffling =  (1440,)\n"
     ]
    }
   ],
   "source": [
    "#2-step in data shuffling\n",
    "\n",
    "#shuffle images and corresponding labels data in both the lists\n",
    "images = images[n]\n",
    "labels = labels[n]\n",
    "\n",
    "print(\"Images shape after shuffling = \",images.shape,\"\\nLabels shape after shuffling = \",labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Images shape after normalization =  (1440, 224, 224, 3)\n"
     ]
    }
   ],
   "source": [
    "images = images.astype(np.float32)\n",
    "labels = labels.astype(np.int32)\n",
    "images = images/255\n",
    "print(\"Images shape after normalization = \",images.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import Dense, Flatten, Reshape, Input, InputLayer\n",
    "from keras.models import Sequential, Model\n",
    "\n",
    "def build_autoencoder(img_shape, code_size):\n",
    "    # The encoder\n",
    "    encoder = Sequential()\n",
    "    encoder.add(InputLayer(img_shape))\n",
    "    encoder.add(Flatten())\n",
    "    encoder.add(Dense(code_size))\n",
    "\n",
    "    # The decoder\n",
    "    decoder = Sequential()\n",
    "    decoder.add(InputLayer((code_size,)))\n",
    "    decoder.add(Dense(np.prod(img_shape))) # np.prod(img_shape) is the same as 32*32*3, it's more generic than saying 3072\n",
    "    decoder.add(Reshape(img_shape))\n",
    "\n",
    "    return encoder, decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"functional_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_3 (InputLayer)         [(None, 224, 224, 3)]     0         \n",
      "_________________________________________________________________\n",
      "sequential (Sequential)      (None, 32)                4816928   \n",
      "_________________________________________________________________\n",
      "sequential_1 (Sequential)    (None, 224, 224, 3)       4967424   \n",
      "=================================================================\n",
      "Total params: 9,784,352\n",
      "Trainable params: 9,784,352\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "IMG_SHAPE = images.shape[1:]\n",
    "encoder, decoder = build_autoencoder(IMG_SHAPE, 32)\n",
    "\n",
    "inp = Input(IMG_SHAPE)\n",
    "code = encoder(inp)\n",
    "reconstruction = decoder(code)\n",
    "\n",
    "autoencoder = Model(inp,reconstruction)\n",
    "autoencoder.compile(optimizer='adamax', loss='mse')\n",
    "\n",
    "print(autoencoder.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "45/45 [==============================] - 6s 133ms/step - loss: 0.0593 - val_loss: 0.0000e+00\n",
      "Epoch 2/20\n",
      "45/45 [==============================] - 6s 139ms/step - loss: 0.0173 - val_loss: 0.0000e+00\n",
      "Epoch 3/20\n",
      "45/45 [==============================] - 6s 138ms/step - loss: 0.0169 - val_loss: 0.0000e+00\n",
      "Epoch 4/20\n",
      "45/45 [==============================] - 6s 130ms/step - loss: 0.0165 - val_loss: 0.0000e+00\n",
      "Epoch 5/20\n",
      "45/45 [==============================] - 6s 129ms/step - loss: 0.0160 - val_loss: 0.0000e+00\n",
      "Epoch 6/20\n",
      "45/45 [==============================] - 6s 131ms/step - loss: 0.0155 - val_loss: 0.0000e+00\n",
      "Epoch 7/20\n",
      "45/45 [==============================] - 6s 131ms/step - loss: 0.0152 - val_loss: 0.0000e+00\n",
      "Epoch 8/20\n",
      "45/45 [==============================] - 6s 132ms/step - loss: 0.0149 - val_loss: 0.0000e+00\n",
      "Epoch 9/20\n",
      "45/45 [==============================] - 6s 132ms/step - loss: 0.0146 - val_loss: 0.0000e+00\n",
      "Epoch 10/20\n",
      "45/45 [==============================] - 6s 135ms/step - loss: 0.0144 - val_loss: 0.0000e+00\n",
      "Epoch 11/20\n",
      "45/45 [==============================] - 6s 132ms/step - loss: 0.0141 - val_loss: 0.0000e+00\n",
      "Epoch 12/20\n",
      "45/45 [==============================] - 6s 132ms/step - loss: 0.0139 - val_loss: 0.0000e+00\n",
      "Epoch 13/20\n",
      "45/45 [==============================] - 6s 134ms/step - loss: 0.0136 - val_loss: 0.0000e+00\n",
      "Epoch 14/20\n",
      "45/45 [==============================] - 6s 133ms/step - loss: 0.0134 - val_loss: 0.0000e+00\n",
      "Epoch 15/20\n",
      "45/45 [==============================] - 6s 133ms/step - loss: 0.0133 - val_loss: 0.0000e+00\n",
      "Epoch 16/20\n",
      "45/45 [==============================] - 6s 133ms/step - loss: 0.0131 - val_loss: 0.0000e+00\n",
      "Epoch 17/20\n",
      "45/45 [==============================] - 6s 133ms/step - loss: 0.0130 - val_loss: 0.0000e+00\n",
      "Epoch 18/20\n",
      "45/45 [==============================] - 6s 134ms/step - loss: 0.0128 - val_loss: 0.0000e+00\n",
      "Epoch 19/20\n",
      "45/45 [==============================] - 6s 133ms/step - loss: 0.0127 - val_loss: 0.0000e+00\n",
      "Epoch 20/20\n",
      "45/45 [==============================] - 6s 134ms/step - loss: 0.0126 - val_loss: 0.0000e+00\n"
     ]
    }
   ],
   "source": [
    "history = autoencoder.fit(x=images, y=images, epochs=20,\n",
    "                validation_data=[images, images])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy= 0.9293321743607521 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "decoded_imgs = autoencoder.predict(images)\n",
    "\n",
    "n = 1\n",
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    # display original\n",
    "    ax = plt.subplot(2, n, i+1)\n",
    "    plt.imshow(images[i].reshape(224, 224,3))\n",
    "    plt.gray()\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "\n",
    "    # display reconstruction\n",
    "    ax = plt.subplot(2, n, i + n+1)\n",
    "    plt.imshow(decoded_imgs[i].reshape(224, 224,3))\n",
    "    plt.gray()\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show()\n",
    "\n",
    "print(\"Accuracy=\",1-np.mean(abs(images-decoded_imgs)),'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape =  (1152, 224, 224, 3)\n",
      "y_train shape =  (1152,)\n",
      "\n",
      "x_test shape =  (288, 224, 224, 3)\n",
      "y_test shape =  (288,)\n"
     ]
    }
   ],
   "source": [
    "x_train, x_test, y_train, y_test = train_test_split(decoded_imgs, labels, test_size = 0.2, random_state = 42)\n",
    "\n",
    "print(\"x_train shape = \",x_train.shape)\n",
    "print(\"y_train shape = \",y_train.shape)\n",
    "print(\"\\nx_test shape = \",x_test.shape)\n",
    "print(\"y_test shape = \",y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Conv2D,MaxPooling2D,Dense,Flatten,Dropout\n",
    "from keras.layers.normalization import BatchNormalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "from urllib.request import urlopen,urlretrieve\n",
    "from PIL import Image\n",
    "from tqdm import tqdm_notebook\n",
    "%matplotlib inline\n",
    "from sklearn.utils import shuffle\n",
    "import cv2\n",
    "from keras.applications.resnet50 import ResNet50\n",
    "#from resnets_utils import *\n",
    "\n",
    "from keras.models import load_model\n",
    "from sklearn.datasets import load_files   \n",
    "from keras.utils import np_utils\n",
    "from glob import glob\n",
    "from keras import applications\n",
    "from keras.preprocessing.image import ImageDataGenerator \n",
    "from keras import optimizers\n",
    "from keras.models import Sequential,Model,load_model\n",
    "from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D,GlobalAveragePooling2D\n",
    "from keras.callbacks import TensorBoard,ReduceLROnPlateau,ModelCheckpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1152\n",
      "number of test examples = 288\n",
      "X_train shape: (1152, 224, 224, 3)\n",
      "Y_train shape: (1152, 8)\n",
      "X_test shape: (288, 224, 224, 3)\n",
      "Y_test shape: (288, 8)\n"
     ]
    }
   ],
   "source": [
    "X_train = x_train/255.\n",
    "X_test = x_test/255.\n",
    "\n",
    "# Convert training and test labels to one hot matrices\n",
    "Y_train = np_utils.to_categorical(y_train, 8)\n",
    "Y_test = np_utils.to_categorical(y_test, 8)\n",
    "\n",
    "print (\"number of training examples = \" + str(X_train.shape[0]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[0]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_height,img_width = 224,224 \n",
    "num_classes = 8\n",
    "#If imagenet weights are being loaded, \n",
    "#input must have a static square shape (one of (128, 128), (160, 160), (192, 192), or (224, 224))\n",
    "base_model = applications.resnet50.ResNet50(weights= 'imagenet', include_top=False, input_shape= (img_height,img_width,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = base_model.output\n",
    "x = GlobalAveragePooling2D()(x)\n",
    "x = Dropout(0.7)(x)\n",
    "predictions = Dense(num_classes, activation= 'softmax')(x)\n",
    "model = Model(inputs = base_model.input, outputs = predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.optimizers import SGD, Adam\n",
    "# sgd = SGD(lr=lrate, momentum=0.9, decay=decay, nesterov=False)\n",
    "adam = Adam(lr=0.00001)\n",
    "model.compile(optimizer= adam, loss='categorical_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "18/18 [==============================] - 827s 46s/step - loss: 2.4554 - accuracy: 0.2057\n",
      "Epoch 2/20\n",
      "18/18 [==============================] - 826s 46s/step - loss: 1.8317 - accuracy: 0.3377\n",
      "Epoch 3/20\n",
      "18/18 [==============================] - 843s 47s/step - loss: 1.5628 - accuracy: 0.4444\n",
      "Epoch 4/20\n",
      "18/18 [==============================] - 844s 47s/step - loss: 1.2683 - accuracy: 0.5434\n",
      "Epoch 5/20\n",
      "18/18 [==============================] - 836s 46s/step - loss: 1.0446 - accuracy: 0.6250\n",
      "Epoch 6/20\n",
      "18/18 [==============================] - 827s 46s/step - loss: 0.7891 - accuracy: 0.7240\n",
      "Epoch 7/20\n",
      "18/18 [==============================] - 819s 46s/step - loss: 0.5919 - accuracy: 0.8003\n",
      "Epoch 8/20\n",
      "18/18 [==============================] - 883s 49s/step - loss: 0.4552 - accuracy: 0.8490\n",
      "Epoch 9/20\n",
      "18/18 [==============================] - 921s 51s/step - loss: 0.3178 - accuracy: 0.9062\n",
      "Epoch 10/20\n",
      "18/18 [==============================] - 940s 52s/step - loss: 0.2877 - accuracy: 0.9123\n",
      "Epoch 11/20\n",
      "18/18 [==============================] - 896s 50s/step - loss: 0.2226 - accuracy: 0.9349\n",
      "Epoch 12/20\n",
      "18/18 [==============================] - 871s 48s/step - loss: 0.1680 - accuracy: 0.9514\n",
      "Epoch 13/20\n",
      "18/18 [==============================] - 837s 47s/step - loss: 0.1304 - accuracy: 0.9627\n",
      "Epoch 14/20\n",
      "18/18 [==============================] - 832s 46s/step - loss: 0.0898 - accuracy: 0.9757\n",
      "Epoch 15/20\n",
      "18/18 [==============================] - 817s 45s/step - loss: 0.0970 - accuracy: 0.9766\n",
      "Epoch 16/20\n",
      "18/18 [==============================] - 811s 45s/step - loss: 0.1014 - accuracy: 0.9757\n",
      "Epoch 17/20\n",
      "18/18 [==============================] - 811s 45s/step - loss: 0.0988 - accuracy: 0.9748\n",
      "Epoch 18/20\n",
      "18/18 [==============================] - 816s 45s/step - loss: 0.0793 - accuracy: 0.9774\n",
      "Epoch 19/20\n",
      "18/18 [==============================] - 818s 45s/step - loss: 0.0708 - accuracy: 0.9809\n",
      "Epoch 20/20\n",
      "18/18 [==============================] - 848s 47s/step - loss: 0.0500 - accuracy: 0.9878\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x2561813c0a0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train, Y_train, epochs = 20, batch_size=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 8.918905258178711\n",
      "Test accuracy: 0.1284722238779068\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(X_test, Y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}