5. Convolutional Neural Network - basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convolutional Neural Network > Recurral Nerual Network in sequential types of data\n",
    "Convolutional Neural network accepts 2D input, 3D inputs\n",
    "convolution Kernal - windows\n",
    "first layer of convolution filters - tend to find things lik edges or curves \n",
    "    looking at combinations of pixels i.e. why it only finds corner or edge\n",
    "next layer - more complex features that edges and curves build \n",
    "    i.e. circle square\n",
    "next layer find combination of cirlces and squares (a bit more complicated)\n",
    "kernal slides window over the entire image and contensing the image\n",
    "after doing convolution - ne condensed version of image\n",
    "Pooling - pooling has a window like nernal\n",
    "Max pooling - inside the kernal takes the maximum value\n",
    "summary - convolutional network - drastically simplifying your image and looks for features of the image.\n",
    "Generally you will have 2-4 layers of the convolutional layers\n",
    "CNN - reducing your image to basic building blocks and then find patterns of those blocks given how many layers you have\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 127/12501 [00:00<00:09, 1268.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "directory:  kagglecatsanddogs_3367a/PetImages/Cat\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 12501/12501 [00:09<00:00, 1272.36it/s]\n",
      "  1%|          | 108/12501 [00:00<00:11, 1079.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "directory:  kagglecatsanddogs_3367a/PetImages/Dog\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 12501/12501 [00:10<00:00, 1181.88it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cats: 12476\n",
      "Dogs: 12470\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "#in your pre-processing dataset you dont want to build data everytime you run your code\n",
    "REBUILD_DATA = True\n",
    "\n",
    "class DogsVSCats():\n",
    "    #first, specify the size of the image i.e. 50 by 50\n",
    "    #input images vary in sizes and shape (some are portrait, some are landscape) - we need them to uniform on input\n",
    "    # normalised to the same size\n",
    "    # resizing the images or resize and pad (adding white / black pixels on smaller images with open cv)\n",
    "    #shift over and crop the image, rotate or flip them\n",
    "    IMG_SIZE = 50\n",
    "    CATS = \"kagglecatsanddogs_3367a/PetImages/Cat\"\n",
    "    DOGS = \"kagglecatsanddogs_3367a/PetImages/Dog\"\n",
    "    #Pre-labelled data\n",
    "    LABELS ={CATS: 0, DOGS: 1}\n",
    "    # massive list of images with their label\n",
    "    training_data = []\n",
    "    cat_count = 0\n",
    "    dog_count = 0\n",
    "        \n",
    "    def make_training_data(self):\n",
    "        for label in self.LABELS:\n",
    "            print(\"directory: \",label)\n",
    "            #looping all the images in the directory\n",
    "            for f in tqdm(os.listdir(label)):\n",
    "                try:\n",
    "                    path = os.path.join(label,f)\n",
    "                    #convert to grayscale - don't have to in CNN compared to FF NN\n",
    "                    #Dense layer or a linear layer / full connected layer will require you to pass flattened data\n",
    "                    # creating a 2D Convolution Neural Network\n",
    "                    # color doesn't add another dimention - color adds channels - added data we don't need\n",
    "                    # is color a relavant feature or defiant\n",
    "                    # things that are different between cat and dogs are patterns\n",
    "                    # always simplify nerual networks & smaller possible\n",
    "                    img = cv2.imread(path,cv2.IMREAD_GRAYSCALE)\n",
    "                    img = cv2.resize(img, (self.IMG_SIZE, self.IMG_SIZE))\n",
    "                    #labelled data to one hot vector from scaler\n",
    "                    self.training_data.append([np.array(img), np.eye(2)[self.LABELS[label]]])\n",
    "\n",
    "                    # Any one class should be relatively close to the other one in count\n",
    "                    # if one class dominates the data - nerual network is going to optimise that one class and get stuck\n",
    "                    if label == self.CATS:\n",
    "                        self.cat_count += 1\n",
    "                    elif label == self.DOGS:\n",
    "                        self.dog_count += 1\n",
    "                except Exception as e:\n",
    "                    pass\n",
    "                    #print(str(e))\n",
    "                    \n",
    "        np.random.shuffle(self.training_data)\n",
    "        np.save(\"training_data.npy\", self.training_data)\n",
    "        print(\"Cats:\", self.cat_count)\n",
    "        print(\"Dogs:\", self.dog_count)\n",
    "\n",
    "if REBUILD_DATA:\n",
    "    dogsvcats = DogsVSCats()\n",
    "    dogsvcats.make_training_data()\n",
    "            \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24946\n"
     ]
    }
   ],
   "source": [
    "training_data = np.load(\"training_data.npy\", allow_pickle=True)\n",
    "print(len(training_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[173, 174, 118, ...,  59,  86,  25],\n",
      "       [169,  49,  43, ...,  53,  85,  62],\n",
      "       [ 46,  44,  46, ...,  87, 133,  82],\n",
      "       ...,\n",
      "       [142, 144, 139, ..., 183, 175, 174],\n",
      "       [148, 152, 147, ..., 182, 176, 175],\n",
      "       [138, 140, 139, ..., 179, 182, 176]], dtype=uint8)\n",
      " array([0., 1.])]\n"
     ]
    }
   ],
   "source": [
    "print(training_data[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0.]\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "index = 6\n",
    "plt.imshow(training_data[index][0], cmap= \"gray\")\n",
    "plt.show()\n",
    "print(training_data[index][1])"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}