exp4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6s6qOp3gHRcI"
   },
   "source": [
    "<h1><center>EXPERIMENT 4</center></h1>\n",
    "<h3>AIM :</h3> To design a convnet for classifying dog and cat images\n",
    "<br>\n",
    "<h3>Thoery:</h3>\n",
    "To design a convolutional neural network (convnet) for classifying dog and cat images, the following steps can be followed:\n",
    "\n",
    "Load the dataset: The dog and cat image dataset can be downloaded from various sources, such as Kaggle, and stored in a directory structure where each class has its own folder. The tensorflow.keras.preprocessing.image module provides a function ImageDataGenerator that can be used to load and preprocess the images.\n",
    "\n",
    "Preprocess the data: Before training the convnet, the data should be preprocessed. This includes resizing the images to a standard size (e.g., 150x150 pixels), normalizing the pixel values to a range of 0 to 1, and splitting the data into training and validation sets.\n",
    "\n",
    "Design the model: The convnet can be designed using the tensorflow.keras API. The model should start with a convolutional layer with a small kernel size (e.g., 3x3) and a small number of filters (e.g., 32). This should be followed by a max pooling layer to reduce the spatial dimensions of the feature maps. This process of convolution and pooling can be repeated multiple times, with increasing number of filters in each layer. The final output of the convolutional layers can be flattened and fed into a fully connected (dense) layer, followed by a final output layer with 2 neurons (one for each class).\n",
    "\n",
    "Compile the model: After designing the model, it needs to be compiled with an appropriate loss function, optimizer, and evaluation metric. Since this is a binary classification problem, binary cross-entropy can be used as the loss function, and the Adam optimizer can be used for training. The accuracy metric can be used to evaluate the performance of the model.\n",
    "\n",
    "Train the model: The compiled model can be trained on the preprocessed training data using the model.fit() method. The number of epochs and batch size can be adjusted to optimize the performance of the model.\n",
    "\n",
    "Evaluate the model: After training the model, its performance can be evaluated on the preprocessed validation data using the model.evaluate() method. This will provide the accuracy of the model on the validation data.\n",
    "\n",
    "Make predictions: Finally, the trained model can be used to make predictions on new, unseen data using the model.predict() method. The predicted class can be the one with the highest probability.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "40t7RDjx6BQo",
    "outputId": "71665bba-9fb6-4458-b4e8-d849f3f8fc28"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2023-04-14 13:49:34--  https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip\n",
      "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.98.128, 142.251.107.128, 74.125.196.128, ...\n",
      "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.98.128|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 68606236 (65M) [application/zip]\n",
      "Saving to: ‘/tmp/cats_and_dogs_filtered.zip’\n",
      "\n",
      "/tmp/cats_and_dogs_ 100%[===================>]  65.43M   188MB/s    in 0.3s    \n",
      "\n",
      "2023-04-14 13:49:35 (188 MB/s) - ‘/tmp/cats_and_dogs_filtered.zip’ saved [68606236/68606236]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget --no-check-certificate \\\n",
    "  https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip \\\n",
    "  -O /tmp/cats_and_dogs_filtered.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bWaioXTd6pG5",
    "outputId": "92ff1661-d3a9-41ad-8231-023dfe0bb809"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['pyright-732-aQJulZJouSRb',\n",
       " 'cats_and_dogs_filtered.zip',\n",
       " 'dap_multiplexer.ff827b0d1590.root.log.INFO.20230414-131418.106',\n",
       " 'python-languageserver-cancellation',\n",
       " 'dap_multiplexer.INFO',\n",
       " 'debugger_1m37wi21wi',\n",
       " 'initgoogle_syslog_dir.0',\n",
       " 'pyright-732-a6U43jHmasbP',\n",
       " 'cats_and_dogs_filtered']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import zipfile\n",
    "\n",
    "local_zip='/tmp/cats_and_dogs_filtered.zip'\n",
    "zip_ref=zipfile.ZipFile(local_zip,'r')\n",
    "zip_ref.extractall('/tmp')\n",
    "zip_ref.close()\n",
    "os.listdir('/tmp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v61JSA_Q61vy"
   },
   "outputs": [],
   "source": [
    "base_dir='/tmp/cats_and_dogs_filtered'\n",
    "\n",
    "#training and validation directory\n",
    "train_dir=os.path.join(base_dir,'train')\n",
    "validation_dir=os.path.join(base_dir,'validation')\n",
    "\n",
    "#training directory\n",
    "train_cats_dir=os.path.join(train_dir,'cats')\n",
    "train_dogs_dir=os.path.join(train_dir,'dogs')\n",
    "\n",
    "#validation directory\n",
    "validation_cats_dir = os.path.join(validation_dir, 'cats')\n",
    "validation_dogs_dir = os.path.join(validation_dir, 'dogs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KzYihsdS66v3",
    "outputId": "f19be6a5-360b-4730-f213-1496cd2575e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cat.546.jpg', 'cat.134.jpg', 'cat.435.jpg', 'cat.816.jpg', 'cat.383.jpg', 'cat.204.jpg', 'cat.465.jpg', 'cat.64.jpg', 'cat.513.jpg', 'cat.783.jpg']\n",
      "['dog.939.jpg', 'dog.218.jpg', 'dog.192.jpg', 'dog.43.jpg', 'dog.791.jpg', 'dog.467.jpg', 'dog.408.jpg', 'dog.602.jpg', 'dog.14.jpg', 'dog.624.jpg']\n",
      "Total training cat images.    1000\n",
      "Total training dog images.    1000\n",
      "Total Validation cat images.    500\n",
      "Total Validation dog images.    500\n"
     ]
    }
   ],
   "source": [
    "train_cat_fnames=os.listdir(train_cats_dir)\n",
    "train_dog_fnames=os.listdir(train_dogs_dir)\n",
    "\n",
    "print(train_cat_fnames[:10])\n",
    "print(train_dog_fnames[:10])\n",
    "\n",
    "\n",
    "print('Total training cat images.   ',len(os.listdir(train_cats_dir)))\n",
    "print('Total training dog images.   ',len(os.listdir(train_dogs_dir)))\n",
    "\n",
    "print('Total Validation cat images.   ',len(os.listdir(validation_cats_dir)))\n",
    "print('Total Validation dog images.   ',len(os.listdir(validation_dogs_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YGXgaXza7EQ8"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "model = tf.keras.models.Sequential([\n",
    "    # Note the input shape is the desired size of the image 150x150 with 3 bytes color\n",
    "    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(150, 150, 3)),\n",
    "    tf.keras.layers.MaxPooling2D(2,2),\n",
    "    tf.keras.layers.Conv2D(32, (3,3), activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2,2), \n",
    "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'), \n",
    "    tf.keras.layers.MaxPooling2D(2,2),\n",
    "    # Flatten the results to feed into a DNN\n",
    "    tf.keras.layers.Flatten(), \n",
    "    # 512 neuron hidden layer\n",
    "    tf.keras.layers.Dense(512, activation='relu'), \n",
    "    # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('cats') and 1 for the other ('dogs')\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')  \n",
    "])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cWt6yIC77Gg6",
    "outputId": "ff04a19a-5134-4a4f-88d3-582daad8c41d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 148, 148, 16)      448       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 74, 74, 16)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 72, 72, 32)        4640      \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 36, 36, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 34, 34, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 17, 17, 64)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 18496)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               9470464   \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 1)                 513       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 9,494,561\n",
      "Trainable params: 9,494,561\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qz5NoyX375XV",
    "outputId": "ec0544ff-2f19-4640-b1eb-2309965e33d7"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:`lr` is deprecated in Keras optimizer, please use `learning_rate` or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.RMSprop.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.optimizers import RMSprop\n",
    "\n",
    "model.compile(optimizer=RMSprop(lr=0.001),\n",
    "              loss='binary_crossentropy',\n",
    "              metrics = ['acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0KasxuklFQN1",
    "outputId": "590308d2-4994-4606-f121-bcf44dab3560"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2000 images belonging to 2 classes.\n",
      "Found 1000 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "# All images will be rescaled here\n",
    "train_datagen = ImageDataGenerator( rescale = 1.0/255. )\n",
    "test_datagen  = ImageDataGenerator( rescale = 1.0/255. )\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(train_dir,\n",
    "                                                    batch_size=20,\n",
    "                                                    class_mode='binary',\n",
    "                                                    target_size=(150, 150))     \n",
    "\n",
    "validation_generator =  test_datagen.flow_from_directory(validation_dir,\n",
    "                                                         batch_size=20,\n",
    "                                                         class_mode  = 'binary',\n",
    "                                                         target_size = (150, 150))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lTNkjUmJFTGX",
    "outputId": "a005e3bd-7524-427d-e5c4-9c5121da4daa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-26-73665b94786d>:1: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
      "  history = model.fit_generator(train_generator,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10/10 - 3s - loss: 0.6946 - acc: 0.5150 - val_loss: 0.6922 - val_acc: 0.5000 - 3s/epoch - 345ms/step\n",
      "Epoch 2/10\n",
      "10/10 - 4s - loss: 0.7237 - acc: 0.5400 - val_loss: 0.6933 - val_acc: 0.5110 - 4s/epoch - 448ms/step\n",
      "Epoch 3/10\n",
      "10/10 - 3s - loss: 0.6966 - acc: 0.5500 - val_loss: 0.6935 - val_acc: 0.5000 - 3s/epoch - 345ms/step\n",
      "Epoch 4/10\n",
      "10/10 - 3s - loss: 0.6861 - acc: 0.5700 - val_loss: 0.6930 - val_acc: 0.5000 - 3s/epoch - 346ms/step\n",
      "Epoch 5/10\n",
      "10/10 - 4s - loss: 0.6967 - acc: 0.5250 - val_loss: 0.6863 - val_acc: 0.5880 - 4s/epoch - 440ms/step\n",
      "Epoch 6/10\n",
      "10/10 - 3s - loss: 0.6871 - acc: 0.5750 - val_loss: 0.6836 - val_acc: 0.5910 - 3s/epoch - 349ms/step\n",
      "Epoch 7/10\n",
      "10/10 - 3s - loss: 0.6894 - acc: 0.5550 - val_loss: 0.6790 - val_acc: 0.5950 - 3s/epoch - 342ms/step\n",
      "Epoch 8/10\n",
      "10/10 - 4s - loss: 0.6712 - acc: 0.5750 - val_loss: 0.6783 - val_acc: 0.6160 - 4s/epoch - 399ms/step\n",
      "Epoch 9/10\n",
      "10/10 - 3s - loss: 0.7452 - acc: 0.6250 - val_loss: 0.6810 - val_acc: 0.5560 - 3s/epoch - 344ms/step\n",
      "Epoch 10/10\n",
      "10/10 - 4s - loss: 0.7155 - acc: 0.6150 - val_loss: 0.6726 - val_acc: 0.6400 - 4s/epoch - 351ms/step\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(train_generator,\n",
    "                              validation_data=validation_generator,\n",
    "                              steps_per_epoch=10,\n",
    "                              epochs=10,\n",
    "                              validation_steps=50,\n",
    "                              verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2hI1aVNKGnWC"
   },
   "outputs": [],
   "source": [
    "#-----------------------------------------------------------\n",
    "# Retrieve a list of list results on training and test data\n",
    "# sets for each training epoch\n",
    "#-----------------------------------------------------------\n",
    "acc      = history.history[     'acc' ]\n",
    "val_acc  = history.history[ 'val_acc' ]\n",
    "loss     = history.history[    'loss' ]\n",
    "val_loss = history.history['val_loss' ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 904
    },
    "id": "O84xj-ssG_CL",
    "outputId": "0d08210b-45db-4a67-db40-a8421e319c2f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Training and validation loss')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Plot training and validation accuracy per epoch\n",
    "plt.plot  ( epochs,     acc )\n",
    "plt.plot  ( epochs, val_acc )\n",
    "plt.title ('Training and validation accuracy')\n",
    "plt.figure()\n",
    "\n",
    "# Plot training and validation loss per epoch\n",
    "plt.plot  ( epochs,     loss )\n",
    "plt.plot  ( epochs, val_loss )\n",
    "plt.title ('Training and validation loss'   )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yz83GvuGG0OD"
   },
   "source": [
    "<h3>Conclusion:</h3>\n",
    "A convnet for classifying dog and cat images is successfully implemented."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "gpuClass": "standard",
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}