ConvolutionalAutoEncoder.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "\n",
    "import numpy as np \n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "\n",
    "from keras.preprocessing import image\n",
    "from keras.models import Model\n",
    "from keras.optimizers import Adam, RMSprop\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.layers import Input, Dense, Activation, BatchNormalization, Flatten, Conv2D\n",
    "from keras.layers import Input,Conv2D,MaxPooling2D,UpSampling2D\n",
    "from keras import backend as K\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\" #model will be trained on GPU 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_image(path):\n",
    "    image_list = np.zeros((len(path), 28, 28, 1))\n",
    "    for i, fig in enumerate(path):\n",
    "        img = image.load_img(fig, color_mode='grayscale', target_size=(28, 28))\n",
    "        x = image.img_to_array(img).astype('float32')\n",
    "        x = x / 255.0\n",
    "        image_list[i] = x\n",
    "    \n",
    "    return image_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_img = glob.glob(\"/home/webvalley/RCNN-Try/train/*.png\")\n",
    "test_img = glob.glob(\"dataset/Patches/Plaque/*.png\")\n",
    "\n",
    "y_train = []\n",
    "for img in train_img:\n",
    "    if \"Calcific\" in img:\n",
    "        y_train.append(0)\n",
    "    elif \"Fibrous\" in img:\n",
    "        y_train.append(1)\n",
    "\n",
    "x_train = load_image(train_img)\n",
    "\n",
    "y_test = []\n",
    "\n",
    "for img in test_img:\n",
    "    if \"Calcific\" in img:\n",
    "        y_test.append(0)\n",
    "    elif \"Fibrous\" in img:\n",
    "        y_test.append(1)\n",
    "        \n",
    "\n",
    "x_test = load_image(test_img) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "x_train, x_val, y_train, y_val = train_test_split(x_train, x_train, test_size=0.2, random_state=13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "epochs = 50\n",
    "inChannel = 1\n",
    "x, y = 28, 28\n",
    "input_img = Input(shape = (x, y, inChannel))\n",
    "#K.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "conv1 = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img)\n",
    "pool1 = MaxPooling2D((2, 2), padding='same')(conv1)\n",
    "conv2 = Conv2D(8, (3, 3), activation='relu', padding='same')(pool1)\n",
    "pool2 = MaxPooling2D((2, 2), padding='same')(conv2)\n",
    "conv3 = Conv2D(8, (3, 3), activation='relu', padding='same')(pool2)\n",
    "encoded = MaxPooling2D((2, 2), padding='same')(conv3)\n",
    "\n",
    "\n",
    "conv4 = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded)\n",
    "up1 = UpSampling2D((2, 2))(conv4)\n",
    "conv5 = Conv2D(8, (3, 3), activation='relu', padding='same')(up1)\n",
    "up2 = UpSampling2D((2, 2))(conv5)\n",
    "conv6 = Conv2D(16, (3, 3), activation='relu')(up2)\n",
    "up3 = UpSampling2D((2, 2))(conv6)\n",
    "decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(up3)\n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    #encoder\n",
    "    #input = 28 x 28 x 1 (wide and thin)\n",
    "conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img) #28 x 28 x 32\n",
    "pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) #14 x 14 x 32\n",
    "conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1) #14 x 14 x 64\n",
    "pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) #7 x 7 x 64\n",
    "conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2) #7 x 7 x 128 (small and thick)\n",
    "encoded = MaxPooling2D((2, 2), padding='same')(conv3)\n",
    "\n",
    "#decoder\n",
    "conv4 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3) #7 x 7 x 128\n",
    "up1 = UpSampling2D((2,2))(conv4) # 14 x 14 x 128\n",
    "conv5 = Conv2D(64, (3, 3), activation='relu', padding='same')(up1) # 14 x 14 x 64\n",
    "up2 = UpSampling2D((2,2))(conv5) # 28 x 28 x 64\n",
    "decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(up2) # 28 x 28 x 1\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "autoencoder = Model(input_img, decoded) #autoencoder(input_img))\n",
    "\n",
    "autoencoder.compile(loss='mean_squared_error', optimizer = RMSprop())\n",
    "#autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "autoencoder.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "autoencoder_train = autoencoder.fit(x_train, x_train,\n",
    "                                    batch_size=batch_size,\n",
    "                                    epochs=epochs,\n",
    "                                    verbose=1,\n",
    "                                    validation_data=(x_val, x_val)\n",
    "                                   )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = autoencoder_train.history['loss']\n",
    "val_loss = autoencoder_train.history['val_loss']\n",
    "epochs = range(epochs)\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = autoencoder.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(pred[1, ..., 0], cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_conv = {\n",
    "    0: 'Calcific',\n",
    "    1: 'Fibrous'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20, 4))\n",
    "print(\"Test Images\")\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 10, i+1)\n",
    "    plt.imshow(x_test[i, ..., 0], cmap='gray')\n",
    "    curr_lbl = y_test[i]\n",
    "    plt.title(\"(Label: \" + label_conv[curr_lbl] + \")\")\n",
    "\n",
    "plt.show()    \n",
    "plt.figure(figsize=(20, 4))\n",
    "print(\"Reconstruction of Test Images\")\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 10, i+1)\n",
    "    plt.imshow(pred[i, ..., 0], cmap='gray')  \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess = K.get_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}