07_CNN-cat_Vs_dog.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><div style=\"direction:rtl;font-family:B Lotus, B Nazanin, Tahoma\">به نام خدا</div></center>\n",
    "<h1><center><div style=\"direction:rtl;font-family:B Lotus, B Nazanin, Tahoma\">آموزش یک شبکه عصبی کانولوشنالی از ابتدا</div></center></h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import keras\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\">آموزش یک شبکه عصبی کانولوشنالی از ابتدا</div>\n",
    "\n",
    "<div style=\"direction:rtl;text-align:right;font-family:Tahoma\">\n",
    "کدها  برگرفته از فصل دو کتاب\n",
    "</div>\n",
    "\n",
    "[Deep Learning with Python](https://www.manning.com/books/deep-learning-with-python?a_aid=keras&a_bid=76564dff)\n",
    "<div style=\"direction:rtl;text-align:right;font-family:Tahoma\">\n",
    "و گیت هاب نویسنده کتاب و توسعه دهنده کراس \n",
    "</div>\n",
    "\n",
    "[François Chollet](http://nbviewer.jupyter.org/github/fchollet/deep-learning-with-python-notebooks/blob/master/5.2-using-convnets-with-small-datasets.ipynb)\n",
    "<div style=\"direction:rtl;text-align:right;font-family:Tahoma\">\n",
    "است.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\">مجموعه داده</div>\n",
    "\n",
    "<div style=\"direction:rtl;text-align:right;font-family:Tahoma\">\n",
    "مجموعه داده گربه در مقابل سگ برای این مثال استفاده شده است. این مجموعه داده در چالش بینایی کامپیوتر اواخر سال ۲۰۱۳ توسط سایت Kaggle.com در دسترس عموم قرار گرفت.\n",
    "<br>\n",
    "از قبل از سال ۲۰۱۳ استفاده از شبکه های کانولوشنالی خیلی رایج نبود.\n",
    "مجموعه داده در آدرس زیر قابل دانلود است.\n",
    "</div>\n",
    "\n",
    "`https://www.kaggle.com/c/dogs-vs-cats/data`\n",
    "\n",
    "\n",
    "\n",
    "![cats_vs_dogs_samples](https://s3.amazonaws.com/book.keras.io/img/ch5/cats_vs_dogs_samples.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unsurprisingly, the cats vs. dogs Kaggle competition in 2013 was won by entrants who used convnets. The best entries could achieve up to \n",
    "95% accuracy. In our own example, we will get fairly close to this accuracy (in the next section), even though we will be training our \n",
    "models on less than 10% of the data that was available to the competitors.\n",
    "This original dataset contains 25,000 images of dogs and cats (12,500 from each class) and is 543MB large (compressed). After downloading \n",
    "and uncompressing it, we will create a new dataset containing three subsets: a training set with 1000 samples of each class, a validation \n",
    "set with 500 samples of each class, and finally a test set with 500 samples of each class.\n",
    "\n",
    "Here are a few lines of code to do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, shutil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The path to the directory where the original\n",
    "# dataset was uncompressed\n",
    "original_dataset_dir = 'D:/dataset/catDog/train'\n",
    "\n",
    "# The directory where we will\n",
    "# store our smaller dataset\n",
    "base_dir = 'D:/dataset/catDog/catVsdog'\n",
    "os.mkdir(base_dir)\n",
    "\n",
    "# Directories for our training,\n",
    "# validation and test splits\n",
    "train_dir = os.path.join(base_dir, 'train')\n",
    "os.mkdir(train_dir)\n",
    "validation_dir = os.path.join(base_dir, 'validation')\n",
    "os.mkdir(validation_dir)\n",
    "test_dir = os.path.join(base_dir, 'test')\n",
    "os.mkdir(test_dir)\n",
    "\n",
    "# Directory with our training cat pictures\n",
    "train_cats_dir = os.path.join(train_dir, 'cats')\n",
    "os.mkdir(train_cats_dir)\n",
    "\n",
    "# Directory with our training dog pictures\n",
    "train_dogs_dir = os.path.join(train_dir, 'dogs')\n",
    "os.mkdir(train_dogs_dir)\n",
    "\n",
    "# Directory with our validation cat pictures\n",
    "validation_cats_dir = os.path.join(validation_dir, 'cats')\n",
    "os.mkdir(validation_cats_dir)\n",
    "\n",
    "# Directory with our validation dog pictures\n",
    "validation_dogs_dir = os.path.join(validation_dir, 'dogs')\n",
    "os.mkdir(validation_dogs_dir)\n",
    "\n",
    "# Directory with our validation cat pictures\n",
    "test_cats_dir = os.path.join(test_dir, 'cats')\n",
    "os.mkdir(test_cats_dir)\n",
    "\n",
    "# Directory with our validation dog pictures\n",
    "test_dogs_dir = os.path.join(test_dir, 'dogs')\n",
    "os.mkdir(test_dogs_dir)\n",
    "\n",
    "# Copy first 1000 cat images to train_cats_dir\n",
    "fnames = ['cat.{}.jpg'.format(i) for i in range(1000)]\n",
    "for fname in fnames:\n",
    "    src = os.path.join(original_dataset_dir, fname)\n",
    "    dst = os.path.join(train_cats_dir, fname)\n",
    "    shutil.copyfile(src, dst)\n",
    "\n",
    "# Copy next 500 cat images to validation_cats_dir\n",
    "fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)]\n",
    "for fname in fnames:\n",
    "    src = os.path.join(original_dataset_dir, fname)\n",
    "    dst = os.path.join(validation_cats_dir, fname)\n",
    "    shutil.copyfile(src, dst)\n",
    "    \n",
    "# Copy next 500 cat images to test_cats_dir\n",
    "fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)]\n",
    "for fname in fnames:\n",
    "    src = os.path.join(original_dataset_dir, fname)\n",
    "    dst = os.path.join(test_cats_dir, fname)\n",
    "    shutil.copyfile(src, dst)\n",
    "    \n",
    "# Copy first 1000 dog images to train_dogs_dir\n",
    "fnames = ['dog.{}.jpg'.format(i) for i in range(1000)]\n",
    "for fname in fnames:\n",
    "    src = os.path.join(original_dataset_dir, fname)\n",
    "    dst = os.path.join(train_dogs_dir, fname)\n",
    "    shutil.copyfile(src, dst)\n",
    "    \n",
    "# Copy next 500 dog images to validation_dogs_dir\n",
    "fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)]\n",
    "for fname in fnames:\n",
    "    src = os.path.join(original_dataset_dir, fname)\n",
    "    dst = os.path.join(validation_dogs_dir, fname)\n",
    "    shutil.copyfile(src, dst)\n",
    "    \n",
    "# Copy next 500 dog images to test_dogs_dir\n",
    "fnames = ['dog.{}.jpg'.format(i) for i in range(1500, 2000)]\n",
    "for fname in fnames:\n",
    "    src = os.path.join(original_dataset_dir, fname)\n",
    "    dst = os.path.join(test_dogs_dir, fname)\n",
    "    shutil.copyfile(src, dst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\"> برای بررسی صحت انجام کار تعداد تصاویرآموزشی/آزمون/توسعه را بررسی میکنیم.</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'D:/dataset/catDog/catVsdog\\\\train\\\\cats'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_cats_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total training cat images: 1000\n"
     ]
    }
   ],
   "source": [
    "print('total training cat images:', len(os.listdir(train_cats_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total training dog images: 1000\n"
     ]
    }
   ],
   "source": [
    "print('total training dog images:', len(os.listdir(train_dogs_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total validation cat images: 500\n"
     ]
    }
   ],
   "source": [
    "print('total validation cat images:', len(os.listdir(validation_cats_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total validation dog images: 500\n"
     ]
    }
   ],
   "source": [
    "print('total validation dog images:', len(os.listdir(validation_dogs_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total test cat images: 500\n"
     ]
    }
   ],
   "source": [
    "print('total test cat images:', len(os.listdir(test_cats_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total test dog images: 500\n"
     ]
    }
   ],
   "source": [
    "print('total test dog images:', len(os.listdir(test_dogs_dir)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;text-align:right;font-family:Tahoma\">\n",
    "با توجه به اینکه تعداد تصاویر یکسانی از سگ و گربه برداشته ایم معیار Accuracy معیارمناسبی برای ارزیابی خواهد بود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\">تعریف معماری مدل (model architecture)</div>\n",
    "\n",
    "Since we are attacking a binary classification problem, we are ending the network with a single unit (a `Dense` layer of size 1) and a \n",
    "`sigmoid` activation. This unit will encode the probability that the network is looking at one class or the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import layers\n",
    "from keras import models\n",
    "\n",
    "model = models.Sequential()\n",
    "model.add(layers.Conv2D(32, (3, 3), activation='relu',\n",
    "                        input_shape=(150, 150, 3)))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(512, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at how the dimensions of the feature maps change with every successive layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_5 (Conv2D)            (None, 148, 148, 32)      896       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_5 (MaxPooling2 (None, 74, 74, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_6 (Conv2D)            (None, 72, 72, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_6 (MaxPooling2 (None, 36, 36, 64)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_7 (Conv2D)            (None, 34, 34, 128)       73856     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_7 (MaxPooling2 (None, 17, 17, 128)       0         \n",
      "_________________________________________________________________\n",
      "conv2d_8 (Conv2D)            (None, 15, 15, 128)       147584    \n",
      "_________________________________________________________________\n",
      "max_pooling2d_8 (MaxPooling2 (None, 7, 7, 128)         0         \n",
      "_________________________________________________________________\n",
      "flatten_2 (Flatten)          (None, 6272)              0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 512)               3211776   \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 1)                 513       \n",
      "=================================================================\n",
      "Total params: 3,453,121\n",
      "Trainable params: 3,453,121\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For our compilation step, we'll go with the `RMSprop` optimizer as usual. Since we ended our network with a single sigmoid unit, we will \n",
    "use binary crossentropy as our loss (as a reminder, check out the table in Chapter 4, section 5 for a cheatsheet on what loss function to \n",
    "use in various situations)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import optimizers\n",
    "\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer=optimizers.RMSprop(lr=1e-4),\n",
    "              metrics=['acc'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\">  پیش پردازش داده (Data preprocessing)</div>\n",
    "\n",
    "* Read the picture files.\n",
    "* Decode the JPEG content to RGB grids of pixels.\n",
    "* Convert these into floating point tensors.\n",
    "* Rescale the pixel values (between 0 and 255) to the [0, 1] interval (as you know, neural networks prefer to deal with small input values).\n",
    "\n",
    "It may seem a bit daunting, but thankfully Keras has utilities to take care of these steps automatically. Keras has a module with image \n",
    "processing helper tools, located at `keras.preprocessing.image`. In particular, it contains the class `ImageDataGenerator` which allows to \n",
    "quickly set up Python generators that can automatically turn image files on disk into batches of pre-processed tensors. This is what we \n",
    "will use here.\n",
    "\n",
    "<div style=\"direction:rtl;text-align:right;font-family:Tahoma\">\n",
    "    اطلاعات بیشتر در مستندات Keras :\n",
    "</div>\n",
    "\n",
    "`https://keras.io/preprocessing/image/`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "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 keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "# All images will be rescaled by 1./255\n",
    "train_datagen = ImageDataGenerator(rescale=1./255)\n",
    "test_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "        # This is the target directory\n",
    "        train_dir,\n",
    "        # All images will be resized to 150x150\n",
    "        target_size=(150, 150),\n",
    "        batch_size=20,\n",
    "        # Since we use binary_crossentropy loss, we need binary labels\n",
    "        class_mode='binary')\n",
    "\n",
    "validation_generator = test_datagen.flow_from_directory(\n",
    "        validation_dir,\n",
    "        target_size=(150, 150),\n",
    "        batch_size=20,\n",
    "        class_mode='binary')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the output of one of these generators: it yields batches of 150x150 RGB images (shape `(20, 150, 150, 3)`) and binary \n",
    "labels (shape `(20,)`). 20 is the number of samples in each batch (the batch size). Note that the generator yields these batches \n",
    "indefinitely: it just loops endlessly over the images present in the target folder. For this reason, we need to `break` the iteration loop \n",
    "at some point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data batch shape: (20, 150, 150, 3)\n",
      "labels batch shape: (20,)\n"
     ]
    }
   ],
   "source": [
    "for data_batch, labels_batch in train_generator:\n",
    "    print('data batch shape:', data_batch.shape)\n",
    "    print('labels batch shape:', labels_batch.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's fit our model to the data using the generator. We do it using the `fit_generator` method, the equivalent of `fit` for data generators \n",
    "like ours. It expects as first argument a Python generator that will yield batches of inputs and targets indefinitely, like ours does. \n",
    "Because the data is being generated endlessly, the generator needs to know example how many samples to draw from the generator before \n",
    "declaring an epoch over. This is the role of the `steps_per_epoch` argument: after having drawn `steps_per_epoch` batches from the \n",
    "generator, i.e. after having run for `steps_per_epoch` gradient descent steps, the fitting process will go to the next epoch. In our case, \n",
    "batches are 20-sample large, so it will take 100 batches until we see our target of 2000 samples.\n",
    "\n",
    "When using `fit_generator`, one may pass a `validation_data` argument, much like with the `fit` method. Importantly, this argument is \n",
    "allowed to be a data generator itself, but it could be a tuple of Numpy arrays as well. If you pass a generator as `validation_data`, then \n",
    "this generator is expected to yield batches of validation data endlessly, and thus you should also specify the `validation_steps` argument, \n",
    "which tells the process how many batches to draw from the validation generator for evaluation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n",
      "100/100 [==============================] - 16s 163ms/step - loss: 0.6893 - acc: 0.5310 - val_loss: 0.6687 - val_acc: 0.6220\n",
      "Epoch 2/30\n",
      "100/100 [==============================] - 12s 121ms/step - loss: 0.6580 - acc: 0.6045 - val_loss: 0.6300 - val_acc: 0.6510\n",
      "Epoch 3/30\n",
      "100/100 [==============================] - 12s 121ms/step - loss: 0.6024 - acc: 0.6740 - val_loss: 0.5989 - val_acc: 0.6770\n",
      "Epoch 4/30\n",
      "100/100 [==============================] - 12s 121ms/step - loss: 0.5647 - acc: 0.7050 - val_loss: 0.5879 - val_acc: 0.6730\n",
      "Epoch 5/30\n",
      "100/100 [==============================] - 12s 121ms/step - loss: 0.5325 - acc: 0.7360 - val_loss: 0.5854 - val_acc: 0.6780\n",
      "Epoch 6/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.5045 - acc: 0.7460 - val_loss: 0.5794 - val_acc: 0.6830\n",
      "Epoch 7/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.4919 - acc: 0.7620 - val_loss: 0.5656 - val_acc: 0.6930\n",
      "Epoch 8/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.4612 - acc: 0.7830 - val_loss: 0.5447 - val_acc: 0.7210\n",
      "Epoch 9/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.4417 - acc: 0.7935 - val_loss: 0.5384 - val_acc: 0.7240\n",
      "Epoch 10/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.4128 - acc: 0.8190 - val_loss: 0.6742 - val_acc: 0.6750\n",
      "Epoch 11/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.3798 - acc: 0.8330 - val_loss: 0.6281 - val_acc: 0.7030\n",
      "Epoch 12/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.3571 - acc: 0.8435 - val_loss: 0.5573 - val_acc: 0.7280\n",
      "Epoch 13/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.3478 - acc: 0.8495 - val_loss: 0.5481 - val_acc: 0.7340\n",
      "Epoch 14/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.3196 - acc: 0.8620 - val_loss: 0.5440 - val_acc: 0.7340\n",
      "Epoch 15/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.2937 - acc: 0.8900 - val_loss: 0.5569 - val_acc: 0.7390\n",
      "Epoch 16/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.2660 - acc: 0.8980 - val_loss: 0.5677 - val_acc: 0.7400\n",
      "Epoch 17/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.2532 - acc: 0.9005 - val_loss: 0.5804 - val_acc: 0.7300\n",
      "Epoch 18/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.2281 - acc: 0.9145 - val_loss: 0.5744 - val_acc: 0.7420\n",
      "Epoch 19/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.2196 - acc: 0.9170 - val_loss: 0.6044 - val_acc: 0.7380\n",
      "Epoch 20/30\n",
      "100/100 [==============================] - 12s 125ms/step - loss: 0.1897 - acc: 0.9335 - val_loss: 0.6577 - val_acc: 0.7400\n",
      "Epoch 21/30\n",
      "100/100 [==============================] - 13s 126ms/step - loss: 0.1760 - acc: 0.9380 - val_loss: 0.7579 - val_acc: 0.7240\n",
      "Epoch 22/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1486 - acc: 0.9475 - val_loss: 0.6777 - val_acc: 0.7420\n",
      "Epoch 23/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1415 - acc: 0.9515 - val_loss: 0.6760 - val_acc: 0.7460\n",
      "Epoch 24/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.1238 - acc: 0.9635 - val_loss: 0.7288 - val_acc: 0.7410\n",
      "Epoch 25/30\n",
      "100/100 [==============================] - 12s 122ms/step - loss: 0.1112 - acc: 0.9605 - val_loss: 0.7423 - val_acc: 0.7410\n",
      "Epoch 26/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0929 - acc: 0.9700 - val_loss: 0.8013 - val_acc: 0.7300\n",
      "Epoch 27/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0821 - acc: 0.9725 - val_loss: 0.8659 - val_acc: 0.7390\n",
      "Epoch 28/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0737 - acc: 0.9735 - val_loss: 0.9034 - val_acc: 0.7170\n",
      "Epoch 29/30\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0614 - acc: 0.9800 - val_loss: 0.8236 - val_acc: 0.7450\n",
      "Epoch 30/30\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0528 - acc: 0.9855 - val_loss: 0.8810 - val_acc: 0.7350\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(\n",
    "      train_generator,\n",
    "      steps_per_epoch=100,\n",
    "      epochs=30,\n",
    "      validation_data=validation_generator,\n",
    "      validation_steps=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the loss and accuracy of the model over the training and validation data during training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\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",
    "\n",
    "epochs = range(len(acc))\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "\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",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These plots are characteristic of overfitting. Our training accuracy increases linearly over time, until it reaches nearly 100%, while our \n",
    "validation accuracy stalls at 70-72%. Our validation loss reaches its minimum after only five epochs then stalls, while the training loss \n",
    "keeps decreasing linearly until it reaches nearly 0.\n",
    "\n",
    "Because we only have relatively few training samples (2000), overfitting is going to be our number one concern.\n",
    "Let's train our network using data augmentation and dropout:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\">شبکه با Dropout</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "100/100 [==============================] - 14s 140ms/step - loss: 0.6915 - acc: 0.5220 - val_loss: 0.6812 - val_acc: 0.5070\n",
      "Epoch 2/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.6726 - acc: 0.5910 - val_loss: 0.6958 - val_acc: 0.5490\n",
      "Epoch 3/100\n",
      "100/100 [==============================] - 13s 127ms/step - loss: 0.6395 - acc: 0.6325 - val_loss: 0.6757 - val_acc: 0.5740\n",
      "Epoch 4/100\n",
      "100/100 [==============================] - 13s 127ms/step - loss: 0.5973 - acc: 0.6840 - val_loss: 0.6083 - val_acc: 0.6690\n",
      "Epoch 5/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.5563 - acc: 0.7150 - val_loss: 0.5897 - val_acc: 0.6700\n",
      "Epoch 6/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.5454 - acc: 0.7250 - val_loss: 0.5867 - val_acc: 0.6700\n",
      "Epoch 7/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.5314 - acc: 0.7325 - val_loss: 0.6768 - val_acc: 0.6480\n",
      "Epoch 8/100\n",
      "100/100 [==============================] - 13s 127ms/step - loss: 0.5143 - acc: 0.7495 - val_loss: 0.5965 - val_acc: 0.6820\n",
      "Epoch 9/100\n",
      "100/100 [==============================] - 13s 127ms/step - loss: 0.4845 - acc: 0.7765 - val_loss: 0.5718 - val_acc: 0.7030\n",
      "Epoch 10/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.4751 - acc: 0.7720 - val_loss: 0.5514 - val_acc: 0.7080\n",
      "Epoch 11/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.4528 - acc: 0.7975 - val_loss: 0.5415 - val_acc: 0.7240\n",
      "Epoch 12/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.4319 - acc: 0.7960 - val_loss: 0.5437 - val_acc: 0.7220\n",
      "Epoch 13/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.4330 - acc: 0.7970 - val_loss: 0.5356 - val_acc: 0.7340\n",
      "Epoch 14/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.3992 - acc: 0.8175 - val_loss: 0.5457 - val_acc: 0.7360\n",
      "Epoch 15/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.3902 - acc: 0.8305 - val_loss: 0.5515 - val_acc: 0.7310\n",
      "Epoch 16/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.3651 - acc: 0.8380 - val_loss: 0.5452 - val_acc: 0.7410\n",
      "Epoch 17/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.3582 - acc: 0.8460 - val_loss: 0.5420 - val_acc: 0.7300\n",
      "Epoch 18/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.3387 - acc: 0.8555 - val_loss: 0.5957 - val_acc: 0.7400\n",
      "Epoch 19/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.3258 - acc: 0.8545 - val_loss: 0.5654 - val_acc: 0.7470\n",
      "Epoch 20/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.3055 - acc: 0.8710 - val_loss: 0.5745 - val_acc: 0.7320\n",
      "Epoch 21/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.2874 - acc: 0.8740 - val_loss: 0.5539 - val_acc: 0.7510\n",
      "Epoch 22/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.2944 - acc: 0.8805 - val_loss: 0.5795 - val_acc: 0.7450\n",
      "Epoch 23/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.2769 - acc: 0.8795 - val_loss: 0.5777 - val_acc: 0.7570\n",
      "Epoch 24/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.2563 - acc: 0.8940 - val_loss: 0.5677 - val_acc: 0.7550\n",
      "Epoch 25/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.2575 - acc: 0.8925 - val_loss: 0.5461 - val_acc: 0.7570\n",
      "Epoch 26/100\n",
      "100/100 [==============================] - 13s 130ms/step - loss: 0.2396 - acc: 0.9025 - val_loss: 0.5600 - val_acc: 0.7600\n",
      "Epoch 27/100\n",
      "100/100 [==============================] - 13s 128ms/step - loss: 0.2237 - acc: 0.9160 - val_loss: 0.5735 - val_acc: 0.7600\n",
      "Epoch 28/100\n",
      "100/100 [==============================] - 13s 129ms/step - loss: 0.2203 - acc: 0.9110 - val_loss: 0.5838 - val_acc: 0.7440\n",
      "Epoch 29/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1963 - acc: 0.9320 - val_loss: 0.5757 - val_acc: 0.7620\n",
      "Epoch 30/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1909 - acc: 0.9235 - val_loss: 0.6068 - val_acc: 0.7540\n",
      "Epoch 31/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1840 - acc: 0.9280 - val_loss: 0.5872 - val_acc: 0.7670\n",
      "Epoch 32/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.1834 - acc: 0.9295 - val_loss: 0.6143 - val_acc: 0.7610\n",
      "Epoch 33/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1588 - acc: 0.9475 - val_loss: 0.6235 - val_acc: 0.7620\n",
      "Epoch 34/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1596 - acc: 0.9375 - val_loss: 0.6614 - val_acc: 0.7650\n",
      "Epoch 35/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1581 - acc: 0.9390 - val_loss: 0.6994 - val_acc: 0.7410\n",
      "Epoch 36/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.1465 - acc: 0.9410 - val_loss: 0.6495 - val_acc: 0.7550\n",
      "Epoch 37/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1356 - acc: 0.9520 - val_loss: 0.6432 - val_acc: 0.7630\n",
      "Epoch 38/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1271 - acc: 0.9550 - val_loss: 0.6282 - val_acc: 0.7700\n",
      "Epoch 39/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1192 - acc: 0.9605 - val_loss: 0.6786 - val_acc: 0.7630\n",
      "Epoch 40/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1239 - acc: 0.9535 - val_loss: 0.6814 - val_acc: 0.7570\n",
      "Epoch 41/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.1155 - acc: 0.9585 - val_loss: 0.6910 - val_acc: 0.7550\n",
      "Epoch 42/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0936 - acc: 0.9690 - val_loss: 0.7495 - val_acc: 0.7700\n",
      "Epoch 43/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.1073 - acc: 0.9565 - val_loss: 0.6949 - val_acc: 0.7680\n",
      "Epoch 44/100\n",
      "100/100 [==============================] - 12s 125ms/step - loss: 0.0899 - acc: 0.9690 - val_loss: 0.7179 - val_acc: 0.7560\n",
      "Epoch 45/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0886 - acc: 0.9665 - val_loss: 0.6943 - val_acc: 0.7820\n",
      "Epoch 46/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0752 - acc: 0.9750 - val_loss: 0.7567 - val_acc: 0.7740\n",
      "Epoch 47/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0755 - acc: 0.9750 - val_loss: 0.9447 - val_acc: 0.7350\n",
      "Epoch 48/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0764 - acc: 0.9720 - val_loss: 0.8899 - val_acc: 0.7590\n",
      "Epoch 49/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0741 - acc: 0.9775 - val_loss: 0.8029 - val_acc: 0.7630\n",
      "Epoch 50/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0656 - acc: 0.9750 - val_loss: 0.8256 - val_acc: 0.7530\n",
      "Epoch 51/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0579 - acc: 0.9840 - val_loss: 0.8192 - val_acc: 0.7690\n",
      "Epoch 52/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0608 - acc: 0.9790 - val_loss: 0.8388 - val_acc: 0.7800\n",
      "Epoch 53/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0651 - acc: 0.9805 - val_loss: 0.8266 - val_acc: 0.7680\n",
      "Epoch 54/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0627 - acc: 0.9785 - val_loss: 0.9087 - val_acc: 0.7540\n",
      "Epoch 55/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0570 - acc: 0.9820 - val_loss: 0.8696 - val_acc: 0.7640\n",
      "Epoch 56/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0560 - acc: 0.9830 - val_loss: 0.9158 - val_acc: 0.7780\n",
      "Epoch 57/100\n",
      "100/100 [==============================] - 13s 125ms/step - loss: 0.0511 - acc: 0.9830 - val_loss: 0.9401 - val_acc: 0.7790\n",
      "Epoch 58/100\n",
      "100/100 [==============================] - 12s 125ms/step - loss: 0.0456 - acc: 0.9850 - val_loss: 0.9241 - val_acc: 0.7710\n",
      "Epoch 59/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0503 - acc: 0.9815 - val_loss: 0.8782 - val_acc: 0.7730\n",
      "Epoch 60/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0463 - acc: 0.9845 - val_loss: 0.9701 - val_acc: 0.7620\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 61/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0446 - acc: 0.9855 - val_loss: 0.9633 - val_acc: 0.7660\n",
      "Epoch 62/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0351 - acc: 0.9905 - val_loss: 1.0186 - val_acc: 0.7610\n",
      "Epoch 63/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0574 - acc: 0.9775 - val_loss: 0.9036 - val_acc: 0.7680\n",
      "Epoch 64/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0357 - acc: 0.9875 - val_loss: 1.0182 - val_acc: 0.7650\n",
      "Epoch 65/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0403 - acc: 0.9865 - val_loss: 1.1160 - val_acc: 0.7610\n",
      "Epoch 66/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0414 - acc: 0.9865 - val_loss: 1.0252 - val_acc: 0.7580\n",
      "Epoch 67/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0317 - acc: 0.9890 - val_loss: 1.0357 - val_acc: 0.7750\n",
      "Epoch 68/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0348 - acc: 0.9885 - val_loss: 0.9770 - val_acc: 0.7580\n",
      "Epoch 69/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0361 - acc: 0.9890 - val_loss: 1.0370 - val_acc: 0.7640\n",
      "Epoch 70/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0330 - acc: 0.9905 - val_loss: 1.0350 - val_acc: 0.7700\n",
      "Epoch 71/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0394 - acc: 0.9850 - val_loss: 1.0132 - val_acc: 0.7710\n",
      "Epoch 72/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0312 - acc: 0.9910 - val_loss: 1.0268 - val_acc: 0.7750\n",
      "Epoch 73/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0265 - acc: 0.9900 - val_loss: 1.0852 - val_acc: 0.7690\n",
      "Epoch 74/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0327 - acc: 0.9905 - val_loss: 1.1617 - val_acc: 0.7590\n",
      "Epoch 75/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0360 - acc: 0.9875 - val_loss: 1.0486 - val_acc: 0.7710\n",
      "Epoch 76/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0244 - acc: 0.9915 - val_loss: 1.1726 - val_acc: 0.7530\n",
      "Epoch 77/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0326 - acc: 0.9875 - val_loss: 1.0927 - val_acc: 0.7650\n",
      "Epoch 78/100\n",
      "100/100 [==============================] - 12s 125ms/step - loss: 0.0404 - acc: 0.9865 - val_loss: 1.1501 - val_acc: 0.7710\n",
      "Epoch 79/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0225 - acc: 0.9935 - val_loss: 1.1750 - val_acc: 0.7550\n",
      "Epoch 80/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0261 - acc: 0.9935 - val_loss: 1.1779 - val_acc: 0.7660\n",
      "Epoch 81/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0240 - acc: 0.9910 - val_loss: 1.0923 - val_acc: 0.7710\n",
      "Epoch 82/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0274 - acc: 0.9885 - val_loss: 1.2626 - val_acc: 0.7550\n",
      "Epoch 83/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0255 - acc: 0.9920 - val_loss: 1.1342 - val_acc: 0.7650\n",
      "Epoch 84/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0257 - acc: 0.9905 - val_loss: 1.0933 - val_acc: 0.7660\n",
      "Epoch 85/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0218 - acc: 0.9910 - val_loss: 1.1167 - val_acc: 0.7690\n",
      "Epoch 86/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0230 - acc: 0.9920 - val_loss: 1.2408 - val_acc: 0.7670\n",
      "Epoch 87/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0200 - acc: 0.9935 - val_loss: 1.2296 - val_acc: 0.7600\n",
      "Epoch 88/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0158 - acc: 0.9950 - val_loss: 1.2875 - val_acc: 0.7630\n",
      "Epoch 89/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0219 - acc: 0.9920 - val_loss: 1.2603 - val_acc: 0.7540\n",
      "Epoch 90/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0222 - acc: 0.9920 - val_loss: 1.1655 - val_acc: 0.7610\n",
      "Epoch 91/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0230 - acc: 0.9935 - val_loss: 1.1637 - val_acc: 0.7640\n",
      "Epoch 92/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0246 - acc: 0.9925 - val_loss: 1.1986 - val_acc: 0.7780\n",
      "Epoch 93/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0251 - acc: 0.9910 - val_loss: 1.1537 - val_acc: 0.7700\n",
      "Epoch 94/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0204 - acc: 0.9915 - val_loss: 1.2301 - val_acc: 0.7670\n",
      "Epoch 95/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0255 - acc: 0.9910 - val_loss: 1.3497 - val_acc: 0.7650\n",
      "Epoch 96/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0242 - acc: 0.9915 - val_loss: 1.2397 - val_acc: 0.7640\n",
      "Epoch 97/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0292 - acc: 0.9910 - val_loss: 1.1892 - val_acc: 0.7750\n",
      "Epoch 98/100\n",
      "100/100 [==============================] - 12s 123ms/step - loss: 0.0242 - acc: 0.9930 - val_loss: 1.2302 - val_acc: 0.7660\n",
      "Epoch 99/100\n",
      "100/100 [==============================] - 12s 124ms/step - loss: 0.0229 - acc: 0.9915 - val_loss: 1.3007 - val_acc: 0.7590\n",
      "Epoch 100/100\n",
      "100/100 [==============================] - 13s 125ms/step - loss: 0.0197 - acc: 0.9920 - val_loss: 1.2037 - val_acc: 0.7760\n"
     ]
    }
   ],
   "source": [
    "model = models.Sequential()\n",
    "model.add(layers.Conv2D(32, (3, 3), activation='relu',\n",
    "                        input_shape=(150, 150, 3)))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dropout(0.5))\n",
    "model.add(layers.Dense(512, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))\n",
    "\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer=optimizers.RMSprop(lr=1e-4),\n",
    "              metrics=['acc'])\n",
    "\n",
    "history = model.fit_generator(\n",
    "      train_generator,\n",
    "      steps_per_epoch=100,\n",
    "      epochs=100,\n",
    "      validation_data=validation_generator,\n",
    "      validation_steps=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot our results again:"
   ]
  },
  {
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs = range(len(acc))\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "\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",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\">ذخیره کردن مدل</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('cats_and_dogs_small_1.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\"> دوره مقدماتی یادگیری عمیق<br>علیرضا اخوان پور<br>پنج شنبه، ۲۵ بهمن ۱۳۹۷<br>\n",
    "</div>\n",
    "<a href=\"http://class.vision\">Class.Vision</a> - <a href=\"http://AkhavanPour.ir\">AkhavanPour.ir</a> - <a href=\"https://github.com/Alireza-Akhavan/\">GitHub</a>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "tensorflow",
   "language": "python",
   "name": "tensorflow"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}