classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6b57a909",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Conv2D\n",
    "from tensorflow.keras.layers import MaxPool2D\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from tensorflow.keras.models import load_model\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0690c68f",
   "metadata": {},
   "outputs": [],
   "source": [
    "datagen = ImageDataGenerator(rescale=1/225.0, validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0f69ce23",
   "metadata": {},
   "outputs": [],
   "source": [
    "img_width=64\n",
    "img_height=64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0c686d48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 22048 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "train_ds = datagen.flow_from_directory(directory=r'/home/harshit/Downloads/cell_images/cell_images',target_size=(64, 64), class_mode='binary', batch_size=16, subset='training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "890a4ea4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 5510 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "valid_ds = datagen.flow_from_directory(directory=r'/home/harshit/Downloads/cell_images/cell_images',target_size=(64, 64), class_mode='binary', batch_size=16, subset='validation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "696ca72d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-01-12 21:36:29.316573: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.347325: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.347596: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.348236: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-01-12 21:36:29.348779: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.349017: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.349160: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.803108: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.803330: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.803494: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-12 21:36:29.803647: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 2587 MB memory:  -> device: 0, name: NVIDIA GeForce GTX 1650 Ti, pci bus id: 0000:01:00.0, compute capability: 7.5\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d2a8a018",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(Conv2D(16,(3,3), input_shape=(img_width, img_height, 3), activation='relu'))\n",
    "model.add(MaxPool2D(2,2))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Conv2D(32,(3,3), activation='relu'))\n",
    "model.add(MaxPool2D(2,2))\n",
    "model.add(Dropout(0.3))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(64, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5196297c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 62, 62, 16)        448       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 31, 31, 16)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 31, 31, 16)        0         \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 29, 29, 32)        4640      \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 14, 14, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 14, 14, 32)        0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 6272)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 64)                401472    \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 64)                0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 1)                 65        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 406,625\n",
      "Trainable params: 406,625\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3fa46430",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "13bc7856",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-01-12 21:36:30.975638: I tensorflow/stream_executor/cuda/cuda_dnn.cc:366] Loaded cuDNN version 8300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1378/1378 [==============================] - 22s 15ms/step - loss: 0.4569 - accuracy: 0.7808 - val_loss: 0.2200 - val_accuracy: 0.9299\n",
      "Epoch 2/5\n",
      "1378/1378 [==============================] - 20s 14ms/step - loss: 0.2249 - accuracy: 0.9258 - val_loss: 0.1873 - val_accuracy: 0.9338\n",
      "Epoch 3/5\n",
      "1378/1378 [==============================] - 20s 14ms/step - loss: 0.2023 - accuracy: 0.9335 - val_loss: 0.1815 - val_accuracy: 0.9332\n",
      "Epoch 4/5\n",
      "1378/1378 [==============================] - 20s 14ms/step - loss: 0.1864 - accuracy: 0.9341 - val_loss: 0.1756 - val_accuracy: 0.9336\n",
      "Epoch 5/5\n",
      "1378/1378 [==============================] - 20s 14ms/step - loss: 0.1794 - accuracy: 0.9352 - val_loss: 0.2161 - val_accuracy: 0.9298\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_ds,\n",
    "                    steps_per_epoch = len(train_ds),\n",
    "                    epochs = 5,\n",
    "                    validation_data = valid_ds,\n",
    "                    validation_steps = len(valid_ds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3d6a2881",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0f7dd454",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "345/345 [==============================] - 4s 12ms/step - loss: 0.2161 - accuracy: 0.9298\n"
     ]
    }
   ],
   "source": [
    "result = model.evaluate(valid_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "99c84b2d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "pd.DataFrame(history.history).plot(figsize=(10, 7));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d81a3f4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "792e59ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from tensorflow.keras.preprocessing import image\n",
    "# # img = image.load_img(r'/home/harshit/Downloads/cell_images/cell_images/Uninfected/C208ThinF_IMG_20151029_155436_cell_127.png', target_size=(124,img_height))\n",
    "# #img = image.load_img('/home/harshit/Downloads/cell_images/cell_images/Uninfected/C208ThinF_IMG_20151029_155436_cell_127.png', target_size=(64,64))\n",
    "\n",
    "\n",
    "# import cv2\n",
    "# img = cv2.imread('/home/harshit/Downloads/cell_images/cell_images/Uninfected/C208ThinF_IMG_20151029_155436_cell_127.png')\n",
    "# # img = cv2.imread('/home/harshit/Downloads/cell_images/cell_images/Uninfected/C99P60ThinF_IMG_20150918_142128_cell_45.png')\n",
    "# img = cv2.resize(img,(64,64))\n",
    "# img = img.reshape(64,64,3) \n",
    "\n",
    "\n",
    "# x = image.img_to_array(img)\n",
    "# x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c22689fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a = model.predict(x)\n",
    "# print(a)\n",
    "# if(a == 1):\n",
    "#     print(\"uninfected\")\n",
    "# else:\n",
    "#     print(\"infected\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "059de30f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d14b7e5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "591dcd5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# img = cv2.imread('/home/harshit/Downloads/cell_images/cell_images/Parasitized/C182P143NThinF_IMG_20151201_172607_cell_43.png')\n",
    "# #img = img.reshape(64, 64, 3)\n",
    "# # img = cv2.resize(img,(64,64,3))\n",
    "# img = cv2.resize(img,(64,64))\n",
    "# img = img.reshape(64,64,3)\n",
    "\n",
    "# x = image.img_to_array(img)\n",
    "\n",
    "# a = model.predict(x)\n",
    "# print(a)\n",
    "# if(a == 0):\n",
    "#     print(\"uninfected\")\n",
    "# else:\n",
    "#     print(\"infected\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbb2998e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "c9d24a96",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = load_model('model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "95ceeeeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "\n",
    "def predict(img):\n",
    "    x = image.img_to_array(img)\n",
    "    x = x/255.0\n",
    "    x = np.expand_dims(x,axis=0)\n",
    "    proba = model.predict(x)[0][0]\n",
    "    print(proba)\n",
    "    y = \"Uninfected\" if proba > 0.9 else \"Parasitized\"\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c998d9d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.03415975\n",
      "Parasitized\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing import image\n",
    "\n",
    "path = '/home/harshit/Downloads/cell_images/cell_images/Parasitized/C182P143NThinF_IMG_20151201_172607_cell_43.png'\n",
    "\n",
    "img = image.load_img(path,target_size=(64, 64))\n",
    "\n",
    "pred = predict(img)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8dea420a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9110031\n",
      "Uninfected\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing import image\n",
    "\n",
    "path = '/home/harshit/Downloads/cell_images/cell_images/Uninfected/C99P60ThinF_IMG_20150918_142128_cell_14.png'\n",
    "\n",
    "img = image.load_img(path,target_size=(64, 64))\n",
    "\n",
    "pred = predict(img)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2ad5c67e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prediction [[1.]]\n",
      "prediction: Uninfected\n"
     ]
    }
   ],
   "source": [
    "img = image.load_img(path, target_size=(64,64))\n",
    "x = image.img_to_array(img)\n",
    "x = np.expand_dims(x, axis=0)\n",
    "pred = model.predict(x)\n",
    "print(\"prediction\", pred)\n",
    "if(pred == 1):\n",
    "    result = \"Uninfected\"\n",
    "else:\n",
    "    result = \"Infected\"\n",
    "\n",
    "print(\"prediction:\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f11428d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}