{"cells":[{"metadata":{},"cell_type":"markdown","source":"# How to build models with limited amount of data"},{"metadata":{},"cell_type":"markdown","source":"In this kernel we will see how we can get the best results by using only a part of the given data for training.\n\nThis dataset contains 25,000 images of dogs and cats (12,500 from each class)\n\nWe will pick only 4000 images from this dataset and build our model over it."},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# import libraries\nimport pandas as pd\nimport numpy as np\n\nfrom zipfile import ZipFile \n\nfrom sklearn.metrics import precision_score, recall_score, accuracy_score\n\nimport os,shutil\n\nimport keras\nimport tensorflow as tf\nfrom keras.models import Sequential\nfrom keras.layers import Conv2D, Dense, MaxPooling2D,Flatten,Dropout\nfrom keras import optimizers\nfrom keras.preprocessing.image import ImageDataGenerator\n\n\nimport matplotlib.pyplot as plt","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"code","source":"# unzip given input files\nimport zipfile\n\nwith zipfile.ZipFile('../input/dogs-vs-cats-redux-kernels-edition/train.zip') as z:\n    z.extractall()\n    \nwith zipfile.ZipFile('../input/dogs-vs-cats-redux-kernels-edition/test.zip') as z:\n    z.extractall()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# load sample submission file\nsub = pd.read_csv(\"../input/dogs-vs-cats-redux-kernels-edition/sample_submission.csv\")\nsub.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub.head()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 1) Make Directories"},{"metadata":{},"cell_type":"markdown","source":"We will create a new dataset containing three subsets: \n\n* A training set with 1,000 samples of each class(CAT & DOG)\n \n* A validation set with 500 samples of each class"},{"metadata":{"trusted":true},"cell_type":"code","source":"# creating base directory directories\nbase_dir = './cats_and_dogs_small'\nos.mkdir(base_dir)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# creat sub directories(train,validation and test) under base directory\ntrain_dir = os.path.join(base_dir, 'train')\nos.mkdir(train_dir)\n\nvalidation_dir = os.path.join(base_dir, 'validation')\nos.mkdir(validation_dir)\n\ntest_dir = os.path.join(base_dir, 'test')\nos.mkdir(test_dir)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# create sub-directories(cats and dogs) under each sub directories(train,validation and test) created above\ntrain_cats_dir = os.path.join(train_dir, 'cats')\nos.mkdir(train_cats_dir)\n\ntrain_dogs_dir = os.path.join(train_dir, 'dogs')\nos.mkdir(train_dogs_dir)\n\nvalidation_cats_dir = os.path.join(validation_dir, 'cats')\nos.mkdir(validation_cats_dir)\n\nvalidation_dogs_dir = os.path.join(validation_dir, 'dogs')\nos.mkdir(validation_dogs_dir)\n\ntest_cats_dir = os.path.join(test_dir, 'cats')\nos.mkdir(test_cats_dir)\n\ntest_dogs_dir = os.path.join(test_dir, 'dogs')\nos.mkdir(test_dogs_dir)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# save the path of train and test directories where we saved cats and dogs images after unzipping the input files\noriginal_dataset_train_dir = './train'\noriginal_dataset_test_dir = './test'","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# copy 1000 cats images to \"./cats_and_dogs_small/train/cats\" sub directory we created above, these images will be used for training the model\nfnames = ['cat.{}.jpg'.format(i) for i in range(1000)]\nfor fname in fnames:\n    src = os.path.join(original_dataset_train_dir, fname) # source folder \n    dst = os.path.join(train_cats_dir, fname) # destination folder\n    shutil.copyfile(src, dst) # copying cats images from source to destination folders","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# copy 500 cats images to \"./cats_and_dogs_small/validation/cats\" sub directory we created above, these images will be used for validing the model\nfnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)]\nfor fname in fnames:\n    src = os.path.join(original_dataset_train_dir, fname)\n    dst = os.path.join(validation_cats_dir, fname)\n    shutil.copyfile(src, dst)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# copy 500 cats images to \"./cats_and_dogs_small/test/cats\" sub directory we created above, these images will be used for testing the model\nfnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)]\nfor fname in fnames:\n    src = os.path.join(original_dataset_train_dir, fname)\n    dst = os.path.join(test_cats_dir, fname)\n    shutil.copyfile(src, dst)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# copy 1000 dogs images to \"./cats_and_dogs_small/train/dogs\" sub directory we created above, these images will be used for training the model\nfnames = ['dog.{}.jpg'.format(i) for i in range(1000)]\nfor fname in fnames:\n    src = os.path.join(original_dataset_train_dir, fname)\n    dst = os.path.join(train_dogs_dir, fname)\n    shutil.copyfile(src, dst)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# copy 500 dogs images to \"./cats_and_dogs_small/validation/dogs\" sub directory we created above, these images will be used for validating the model\nfnames = ['dog.{}.jpg'.format(i) for i in range(1000,1500)]\nfor fname in fnames:\n    src = os.path.join(original_dataset_train_dir, fname)\n    dst = os.path.join(validation_dogs_dir, fname)\n    shutil.copyfile(src, dst)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# copy 500 dogs images to \"./cats_and_dogs_small/test/dogs\" sub directory we created above, these images will be used for testing the model\nfnames = ['dog.{}.jpg'.format(i) for i in range(1500,2000)]\nfor fname in fnames:\n    src = os.path.join(original_dataset_train_dir, fname)\n    dst = os.path.join(test_dogs_dir, fname)\n    shutil.copyfile(src, dst)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# sanity check - lets check the folder where we copied the data has the data as expected\nprint(\"train_cats_dir:\",len(os.listdir(train_cats_dir)))\nprint(\"validation_cats_dir:\",len(os.listdir(validation_cats_dir)))\nprint(\"test_cats_dir:\",len(os.listdir(test_cats_dir)))\n\nprint(\"train_dogs_dir:\",len(os.listdir(train_dogs_dir)))\nprint(\"validation_dogs_dir:\",len(os.listdir(validation_dogs_dir)))\nprint(\"test_dogs_dir:\",len(os.listdir(test_dogs_dir)))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"So we indeed have 2,000 training images, 1,000 validation images. \n\nEach split contains the same number of samples from each class: this is a balanced binary-classification problem, which means classification accuracy will be an appropriate measure of success. "},{"metadata":{},"cell_type":"markdown","source":"## 2) Data preprocessing\n\nTo feed the data into a Neural Networks, it should be formatted into appropriately preprocessed floating point tensors.\nCurrently, our data is in JPEG format, so the steps for getting it into the network are roughly as follows:\n\n* Read the picture files.\n\n* Decode the JPEG content to RGB grids of pixels.\n\n* Convert these into floating-point tensors.\n\n* Rescale the pixel values between 0 and 1 (as you know,neural networks prefer to deal with small input values).\n\nIt may seem a bit daunting, but fortunately Keras has utilities to take care of these steps automatically.\n\nKeras has a module with image-processing helper tools, located at `keras.preprocessing.image`. \n\nIn particular, it contains the class `ImageDataGenerator`, which lets you quickly set up Python generators that can automatically turn image files on disk into batches of preprocessed tensors. This is what we’ll use here."},{"metadata":{"trusted":true},"cell_type":"code","source":"# import ImageDataGenerator for pre pro-processing JPEG images as explained above\nfrom keras.preprocessing.image import ImageDataGenerator\n\n# scale pixes between 0 and 1 by dividing the pixes by 255\ntrain_datagen = ImageDataGenerator(rescale=1./255)\ntest_datagen = ImageDataGenerator(rescale=1./255)\n\ntrain_generator = train_datagen.flow_from_directory(train_dir,target_size=(150, 150),batch_size=20,class_mode='binary')\n\nvalidation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=20,class_mode='binary')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Let’s look at the output of one of these generators:**\n\nIt yields batches of 150 × 150 RGB images (shape (20, 150, 150, 3)) and binary labels (shape (20,)). \n\nThere are 20 samples in each batch (the batch size). \n\nNote that the generator yields these batches indefinitely: it loops endlessly over the images in the target folder.\nFor this reason, you need to break the iteration loop at some point:"},{"metadata":{"trusted":true},"cell_type":"code","source":"# since image generators yields bathches indefinitely, we need to break the loop\nfor 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","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Before we fit the model to the data using the generator, lets discuss few important points.**\n\nWe will use `fit_generator` method to fit the data using generators. \n\nIt expects as its `first argument` a `Python generator` that will yield batches of inputs and targets indefinitely(as discussed above). \n\n**Because the data is being generated endlessly, the Keras model needs to know how many samples to draw from the generator before declaring an epoch over. This is the role of the `steps_per_epoch` argument** \n\nIn this case, batches are 20 samples, so it will take 100 batches until you see your target of 2,000 samples.\n \nWhen using fit_generator, you can pass a validation_data argument, much as with the fit method. It’s important to note that this argument is allowed to be a data generator, but it could also be a tuple of Numpy arrays. \n \nIf you pass a generator as validation_data, then this generator is expected to yield batches of validation data endlessly; thus you should also specify the validation_steps argument, which tells the process how many batches to draw from the validation generator for evaluation, let build the model now."},{"metadata":{},"cell_type":"markdown","source":"## 3) Model Building"},{"metadata":{},"cell_type":"markdown","source":"### 3.1) Basic CNN Model"},{"metadata":{"trusted":true},"cell_type":"code","source":"EPOCH_1 = 1\nEPOCH_100 = 100\nEPOCH_30 = 30","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**You must be already familiar with the following CNN archietechture, if not, you can go through [This Kernel](https://www.kaggle.com/jagdmir/all-you-need-to-know-about-cnns)**."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Basic CNN archietechture without Regularization\ninput_shape = [150,150,3]\n\nmodel = Sequential()\n\nmodel.add(Conv2D(32, kernel_size=(3, 3), activation='relu', \n                 input_shape=input_shape))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Flatten())\nmodel.add(Dense(512, activation='relu'))\nmodel.add(Dense(512, activation='relu'))\nmodel.add(Dense(1, activation='sigmoid'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# compile the model\nmodel.compile(loss='binary_crossentropy',\n              optimizer=optimizers.RMSprop(lr=1e-4),\n              metrics=['accuracy'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# fitting the model as discussed above\nhistory = model.fit_generator(\n            train_generator,\n            steps_per_epoch=100,\n            epochs=EPOCH_30,\n            validation_data=validation_generator,\n            validation_steps=50)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Let’s plot the loss and accuracy of the model over the training and validation data during training\nacc = history.history['accuracy']\nval_acc = history.history['val_accuracy']\n\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs = range(1, len(acc) + 1)\nplt.plot(epochs, acc, 'bo', label='Training acc')\nplt.plot(epochs, val_acc, 'b', label='Validation acc')\n\nplt.title('Training and validation accuracy')\nplt.legend()\n\nplt.figure()\nplt.plot(epochs, loss, 'bo', label='Training loss')\nplt.plot(epochs, val_loss, 'b', label='Validation loss')\nplt.title('Training and validation loss')\nplt.legend()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"These plots are characteristic of overfitting. The training accuracy increases linearly over time, until it reaches nearly 100%, whereas the validation accuracy stalls at 70–72%.\n\nThe validation loss reaches its minimum after only five epochs and then stalls, whereas the training loss keeps decreasing linearly until it reaches nearly 0.\n\nBecause we have relatively few training samples (2,000), overfitting will be our number-one concern. \nWe already know about a number of techniques that can help mitigate overfitting, such as dropout and weight decay (L2 regularization). \n\nWe’re now going to work with a new one, specific to computer vision and used almost universally when processing images with deep-learning models: `data augmentation`"},{"metadata":{},"cell_type":"markdown","source":"### 3.2) Model with data augmentation(to overcome overfitting)\n\nOverfitting is caused by having too few samples to learn from, rendering you unable to train a model that can generalize to new data. \n\nGiven infinite data, your model Training a convnet from scratch on a small dataset would be exposed to every possible aspect of the data distribution at hand: you would never overfit. \n\nData augmentation takes the approach of generating more training data from existing training samples, by augmenting the samples via a number of random transformations that yield believable-looking images.\n\nThe goal is that at training time, your model will never see the exact same picture twice. This helps expose the model\nto more aspects of the data and generalize better.\n\nIn Keras, this can be done by configuring a number of random transformations to be performed on the images read by the ImageDataGenerator instance. Let’s get started with an example."},{"metadata":{"trusted":true},"cell_type":"code","source":"datagen = ImageDataGenerator(\n            rotation_range=40,\n            width_shift_range=0.2,\n            height_shift_range=0.2,\n            shear_range=0.2,\n            zoom_range=0.2,\n            horizontal_flip=True,\n            fill_mode='nearest')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"These are just a few of the options available (for more, see the Keras documentation).\n\n**Lets quickly go over this code:** \n\n* `rotation_range` is a value in degrees (0–180), a range within which to randomly rotate pictures.\n* `width_shift` and `height_shift` are ranges (as a fraction of total width or height) within which to randomly translate pictures vertically or horizontally.\n* `shear_range` is for randomly applying shearing transformations.\n* `zoom_range` is for randomly zooming inside pictures.\n* `horizontal_flip` is for randomly flipping half the images horizontally—relevant when there are no assumptions of horizontal asymmetry (for example,real-world pictures).\n* `fill_mode` is the strategy used for filling in newly created pixels, which can appear after a rotation or a width/height shift."},{"metadata":{},"cell_type":"markdown","source":"Let's check augmented images!"},{"metadata":{"trusted":true},"cell_type":"code","source":"from keras.preprocessing import image\n\nfnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]\n\nimg_path = fnames[3]\nimg = image.load_img(img_path, target_size=(150, 150))\n\nx = image.img_to_array(img)\nx = x.reshape((1,) + x.shape)\nplt.figure(figsize = (12,8))\n\ni=0\n\nfor batch in datagen.flow(x, batch_size=1):\n    plt.subplot(2,2,i+1)\n    imgplot = plt.imshow(image.array_to_img(batch[0]))\n    i += 1\n    if i % 4 == 0:\n        break\n\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"If you train a new network using this data-augmentation configuration, the network will never see the same input twice. \n\nBut the inputs it sees are still heavily intercorrelated, because they come from a small number of original images—you can’t produce new information, you can only remix existing information. \n\nAs such, this may not be enough to completely get rid of overfitting. To further fight overfitting, you’ll also add a Dropout layer to your model, right before the densely connected classifier."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Basic CNN archietechture with Regularization\ninput_shape = [150,150,3]\n\nmodel_1 = Sequential()\n\nmodel_1.add(Conv2D(32, kernel_size=(3, 3), activation='relu', \n                 input_shape=input_shape))\nmodel_1.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel_1.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\nmodel_1.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel_1.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\nmodel_1.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel_1.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\nmodel_1.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel_1.add(Flatten())\nmodel_1.add(Dense(512, activation='relu'))\nmodel_1.add(Dropout(0.3)) # to overcome overfitting\nmodel_1.add(Dense(512, activation='relu'))\nmodel_1.add(Dropout(0.3)) # to overcome overfitting\nmodel_1.add(Dense(1, activation='sigmoid'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_datagen = ImageDataGenerator(\n                rescale=1./255,\n                rotation_range=40,\n                width_shift_range=0.2,\n                height_shift_range=0.2,\n                shear_range=0.2,\n                zoom_range=0.2,\n                horizontal_flip=True,)\n\n# note, we are not applying these augmentations to the test data\ntest_datagen = ImageDataGenerator(rescale=1./255)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_generator = train_datagen.flow_from_directory(train_dir,target_size=(150, 150),batch_size=32,class_mode='binary')\n\nvalidation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=32,class_mode='binary')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# compile the model\nmodel_1.compile(loss='binary_crossentropy',\n              optimizer=optimizers.RMSprop(lr=1e-4),\n              metrics=['accuracy'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"history = model_1.fit_generator(\n            train_generator,\n            steps_per_epoch=63,            \n            epochs = EPOCH_100,\n            validation_data=validation_generator,\n            validation_steps=32)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Let’s plot the loss and accuracy of the model over the training and validation data during training\nacc = history.history['accuracy']\nval_acc = history.history['val_accuracy']\n\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs = range(1, len(acc) + 1)\nplt.plot(epochs, acc, 'bo', label='Training acc')\nplt.plot(epochs, val_acc, 'b', label='Validation acc')\n\nplt.title('Training and validation accuracy')\nplt.legend()\n\nplt.figure()\nplt.plot(epochs, loss, 'bo', label='Training loss')\nplt.plot(epochs, val_loss, 'b', label='Validation loss')\nplt.title('Training and validation loss')\nplt.legend()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"By using regularization techniques even further, and by tuning the network’s parameters (such as the number of filters per convolution layer, or the number of layers in the network), we may be able to get an even better accuracy, likely up to 86% or 87%.\n\nBut it would prove difficult to go any higher just by training your own convnet from scratch, because we have so little data to work with. As a next step to improve your accuracy on this problem, we will use a pretrained model."},{"metadata":{},"cell_type":"markdown","source":"### 3.3) Model Using a pretrained convnet(VGG16)\nA common and highly effective approach to deep learning on small image datasets is to use a `pretrained network`. \n\nA pretrained network is a saved network that was previously trained on a large dataset, typically on a large-scale image\nclassification task. \n\nIf this original dataset is large enough and general enough, then the spatial hierarchy of features learned by the pretrained network can effectively act as a generic model of the visual world, and hence its features can prove useful for many different computervision problems, even though these new problems may involve completely different classes than those of the original task. \n\nFor instance, you might train a network on ImageNet (where classes are mostly animals and everyday objects) and then repurpose this trained network for something as remote as identifying furniture items in images. \n\nSuch portability of learned features across different problems is a key advantage of deep learning compared to many older, shallow-learning approaches, and it makes deep learning very effective for small-data problems.\n \nIn this case, let’s consider a large convnet trained on the ImageNet dataset (1.4 million labeled images and 1,000 different classes). ImageNet contains many animal classes, including different species of cats and dogs, and you can thus expect to\nperform well on the dogs-versus-cats classification problem.\n\nWe’ll use the VGG16 architecture, developed by Karen Simonyan and Andrew Zisserman in 2014; it’s a simple and widely used convnet architecture for ImageNet.\n\nThere are two ways to use a pretrained network: feature extraction and fine-tuning. We’ll cover both of them in this notebook. \n\nLet’s start with feature extraction."},{"metadata":{},"cell_type":"markdown","source":"#### 3.3.1) Feature extraction \n\nFeature extraction consists of using the representations learned by a previous network to extract interesting features from new samples. These features are then run through a new classifier, which is trained from scratch.\n\nAs you saw previously, convnets used for image classification comprise two parts:\n\n**Part-1:** They start with a series of pooling and convolution layers.This part is called the convolutional base of the model.\n\n**Part-2:** They end with a densely connected classifier.  \n\nIn the case of convnets, feature extraction consists of taking the convolutional base of apreviously trained network, running the new data through it, and training a new classifier on top of the output(see figure below)\n\n![image.png](attachment:image.png)\n\nWhy only reuse the convolutional base? Could you reuse the densely connected classifier as well? \n\nIn general, doing so should be avoided. The reason is that the representations learned by the convolutional base are likely to be more generic and therefore more reusable whereas the representations learned by the classifier will necessarily be specific to the\nset of classes on which the model was trained.  \n\nNote that the level of generality (and therefore reusability) of the representations extracted by specific convolution layers depends on the depth of the layer in the model. \n\nLayers that come earlier in the model extract local, highly generic feature maps (such as visual edges, colors, and textures), whereas layers that are higher up extract more-abstract concepts (such as “cat ear” or “dog eye”). \n\nSo if your new dataset differs a lot from the dataset on which the original model was trained, you may be better off using only the first few layers of the model to do feature extraction, rather than using the entire convolutional base.\n\nIn this case, because the ImageNet class set contains multiple dog and cat classes, it’s likely to be beneficial to reuse the information contained in the densely connected layers of the original model. \n\nBut we’ll choose not to, in order to cover the more general case where the class set of the new problem doesn’t overlap the class set of the original model. \n\nLet’s put this in practice by using the convolutional base of the VGG16 network, trained on ImageNet, to extract interesting features from cat and dog images, and then train a dogs-versus-cats classifier on top of these features.\n\nThe VGG16 model, among others, comes prepackaged with Keras. You can import it from the keras.applications module. Here’s the list of image-classification models (all pretrained on the ImageNet dataset) that are available as part of keras.applications:\n\n* Xception\n* Inception V3\n* ResNet50\n* VGG16\n* VGG19\n* MobileNet\n* \nLet’s instantiate the VGG16 model.","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"# lets import VGG16 pre-trained model\nfrom keras.applications import VGG16\n\nconv_base = VGG16(weights='imagenet',include_top=False,input_shape=(150, 150, 3))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We passed three arguments to the constructor:\n\n1) `weights` specifies the weight checkpoint from which to initialize the model.\n\n2) `include_top` refers to including (or not) the densely connected classifier on top of the network. By default, this densely connected classifier corresponds to the 1,000 classes from ImageNet. Because we intend to use our own densely connected classifier (with only two classes: cat and dog), we don’t need to include it.\n\n3) `input_shape` is the shape of the image tensors that you’ll feed to the network. This argument is purely optional: if we don’t pass it, the network will be able to process inputs of any size.\n\nHere’s the detail of the architecture of the VGG16 convolutional base. It’s similar to the simple convnets you’re already familiar with:"},{"metadata":{"trusted":true},"cell_type":"code","source":"conv_base.summary()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The final feature map has shape (4, 4, 512). That’s the feature on top of which you’ll stick a densely connected classifier.\n\nAt this point, there are two ways we could proceed:\n\n1) Running the convolutional base over our dataset, recording its output to a Numpy array on disk, and then using this data as input to a standalone, densely connected classifier, This solution is fast and cheap to run, because it only requires running the convolutional base once for every input image, and the convolutional base is by far the most expensive part of the pipeline. But for the same reason, this technique won’t allow you to use data augmentation.\n\n2) Extending the model we have (conv_base) by adding Dense layers on top, and running the whole thing end to end on the input data. This will allow you to use data augmentation, because every input image goes through the convolutional base every time it’s seen by the model. But for the same reason, this technique is far more expensive than the first\n\nWe’ll discuss both the techniques here!"},{"metadata":{},"cell_type":"markdown","source":"#### 3.3.2) FAST FEATURE EXTRACTION WITHOUT DATA AUGMENTATION\n\nWe’ll start by running instances of the previously introduced ImageDataGenerator to extract images as Numpy arrays as well as their labels. We’ll extract features from these images by calling the predict method of the conv_base model."},{"metadata":{"trusted":true},"cell_type":"code","source":"#base_dir = '/Users/fchollet/Downloads/cats_and_dogs_small'\n#train_dir = os.path.join(base_dir, 'train')\n#validation_dir = os.path.join(base_dir, 'validation')\n#test_dir = os.path.join(base_dir, 'test')\n\ndatagen = ImageDataGenerator(rescale=1./255)\nbatch_size = 20\n\ndef extract_features(directory, sample_count):\n    features = np.zeros(shape=(sample_count, 4, 4, 512))\n    labels = np.zeros(shape=(sample_count))\n    generator = datagen.flow_from_directory(directory,target_size=(150, 150),batch_size=batch_size,class_mode='binary')\n    \n    i=0\n    for inputs_batch, labels_batch in generator:\n        features_batch = conv_base.predict(inputs_batch)\n        features[i * batch_size : (i + 1) * batch_size] = features_batch\n        labels[i * batch_size : (i + 1) * batch_size] = labels_batch\n        i += 1\n        if i * batch_size >= sample_count:\n            break\n    return features, labels","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_features, train_labels = extract_features(train_dir, 2000)\nvalidation_features, validation_labels = extract_features(validation_dir, 1000)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The extracted features are currently of shape (samples, 4, 4, 512). You’ll feed them to a densely connected classifier, so first you must flatten them to (samples, 8192):"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_features = np.reshape(train_features, (2000, 4*4* 512))\nvalidation_features = np.reshape(validation_features, (1000, 4*4* 512))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"At this point, we can define our densely connected classifier (note the use of dropout for regularization) and train it on the data and labels that we just recorded."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Densly Connected Classifier\nmodel = keras.models.Sequential()\nmodel.add(keras.layers.Dense(256, activation='relu', input_dim=4 * 4 * 512))\nmodel.add(keras.layers.Dropout(0.5))\nmodel.add(keras.layers.Dense(1, activation='sigmoid'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# compile the model\nmodel.compile(optimizer=optimizers.RMSprop(lr=2e-5),\nloss='binary_crossentropy',\nmetrics=['acc'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# fit the model on the features extracted\nhistory = model.fit(train_features, train_labels,epochs=EPOCH_30,batch_size=20,validation_data=(validation_features, validation_labels))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Training is very fast, because we only have to deal with two Dense layers"},{"metadata":{"trusted":true},"cell_type":"code","source":"# plotting the results\nacc = history.history['acc']\nval_acc = history.history['val_acc']\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs = range(1, len(acc) + 1)\n\nplt.plot(epochs, acc, 'bo', label='Training acc')\nplt.plot(epochs, val_acc, 'b', label='Validation acc')\nplt.title('Training and validation accuracy')\nplt.legend()\n\nplt.figure()\nplt.plot(epochs, loss, 'bo', label='Training loss')\nplt.plot(epochs, val_loss, 'b', label='Validation loss')\nplt.title('Training and validation loss')\nplt.legend()\n\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We reached a validation accuracy of about 90%—much better than we achieved earlier with the small model trained from scratch. \n\nBut the plots also indicate that we’re overfitting almost from the start—despite using dropout with a fairly large\nrate\n\nThat’s because this technique doesn’t use data augmentation, which is essential for preventing overfitting with small image datasets. "},{"metadata":{},"cell_type":"markdown","source":"#### 3.3.2) FEATURE EXTRACTION WITH DATA AUGMENTATION\n\nNow, let’s review the second technique we mentioned for doing feature extraction,which is much slower and more expensive, but which allows us to use data augmentation during training: extending the conv_base model and running it end to end on the inputs.\n\nBecause models behave just like layers, you can add a model (like conv_base) to a Sequential model just like you would add a layer."},{"metadata":{"trusted":true},"cell_type":"code","source":"#  Adding a densely connected classifier on top of the convolutional base\nmodel = keras.models.Sequential()\nmodel.add(conv_base) # adding pre-trained conv base model\nmodel.add(keras.layers.Flatten())\nmodel.add(keras.layers.Dense(256, activation='relu'))\nmodel.add(keras.layers.Dense(1, activation='sigmoid'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.summary()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"As we can see, the convolutional base of VGG16 has 14,714,688 parameters, which is very large. The classifier we’re adding on top has 2 million parameters.\n\nBefore we compile and train the model, it’s very important to freeze the convolutional base. Freezing a layer or set of layers means preventing their weights from being updated during training. \n\nIf we don’t do this, then the representations that were previously learned by the convolutional base will be modified during training,because the Dense layers on top are randomly initialized, very large weight updates would be propagated through the network, effectively destroying the representations previously learned.\n\nIn Keras, we can freeze a network by setting its trainable attribute to False. Let's check how to do it!"},{"metadata":{"trusted":true},"cell_type":"code","source":" print('This is the number of trainable weights before freezing the conv base:', len(model.trainable_weights))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# freezing the layers of pre-trained model\nconv_base.trainable = False","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('This is the number of trainable weights after freezing the conv base:', len(model.trainable_weights))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"With this setup, only the weights from the two Dense layers that we added will be trained. That’s a total of four weight tensors: two per layer (the main weight matrix and the bias vector). \n\nNote that in order for these changes to take effect, we must first compile the model. \n\nIf we ever modify weight trainability after compilation, we should then recompile the model, or these changes will be ignored.\n \nNow you can start training your model, with the same data-augmentation configuration that we used in the previous example."},{"metadata":{"trusted":true},"cell_type":"code","source":"#  Training the model end to end with a frozen convolutional base\ntrain_datagen = ImageDataGenerator(\n                rescale=1./255,\n                rotation_range=40,\n                width_shift_range=0.2,\n                height_shift_range=0.2,\n                shear_range=0.2,\n                zoom_range=0.2,\n                horizontal_flip=True,\n                fill_mode='nearest')\n\ntest_datagen = ImageDataGenerator(rescale=1./255)\n\ntrain_generator = train_datagen.flow_from_directory(\n                    train_dir,\n                    target_size=(150, 150),\n                    batch_size=20,\n                    class_mode='binary')\n\nvalidation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=20,class_mode='binary')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.compile(loss='binary_crossentropy',optimizer=optimizers.RMSprop(lr=2e-5),metrics=['acc'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"history = model.fit_generator(\n            train_generator,\n            steps_per_epoch=100,\n            epochs=EPOCH_30,\n            validation_data=validation_generator,\n            validation_steps=50)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Let’s plot the results again. \n\nGreat, we reached a validation accuracy of about 90%. This is much better than we achieved with the small convnet trained from scratch."},{"metadata":{"trusted":true},"cell_type":"code","source":"# plotting the results\nacc = history.history['acc']\nval_acc = history.history['val_acc']\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs = range(1, len(acc) + 1)\n\nplt.plot(epochs, acc, 'bo', label='Training acc')\nplt.plot(epochs, val_acc, 'b', label='Validation acc')\nplt.title('Training and validation accuracy')\nplt.legend()\n\nplt.figure()\nplt.plot(epochs, loss, 'bo', label='Training loss')\nplt.plot(epochs, val_loss, 'b', label='Validation loss')\nplt.title('Training and validation loss')\nplt.legend()\n\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### 3.3.2) Fine Tuning\n\nAnother widely used technique for model reuse, complementary to feature extraction, is fine-tuning (see figure below). \n\n![image.png](attachment:image.png)\n\nFine-tuning consists of unfreezing a few of the top layers of a frozen model base used for feature extraction, and jointly training\nboth the newly added part of the model (in this case, the fully connected classifier) and these top layers. \n\nThis is called fine-tuning because it slightly adjusts the more abstract representations of the model being reused, in order to make them more relevant for the problem at hand.\n\nAs stated earlier that it’s necessary to freeze the convolution base of VGG16 in order to be able to train a randomly initialized classifier on top. \n\nFor the same reason, it’s only possible to fine-tune the top layers of the convolutional base once the classifier on top\nhas already been trained. If the classifier isn’t already trained, then the error signal propagating through the network during training will be too large, and the representations previously learned by the layers being fine-tuned will be destroyed. \n\nThus the steps for fine-tuning a network are as follow:\n\n* Add custom network on top of an already-trained base network.\n* Freeze the base network.\n* Train the part you added.\n* Unfreeze some layers in the base network.\n* Jointly train both these layers and the part you added.\n\nWe already completed the first three steps when doing feature extraction. \n\nLet’s proceed with step 4: unfreeze conv_base and then freeze individual layers inside it.\n\n\nWe’ll fine-tune the last three convolutional layers, which means all layers up to block4_pool should be frozen, and the layers \nblock5_conv1, block5_conv2, and block5_conv3 should be trainable.\n \n**Why not fine-tune more layers? Why not fine-tune the entire convolutional base?**\n\nWe could. But we need to consider the following:\n\nEarlier layers in the convolutional base encode more-generic, reusable features,whereas layers higher up encode more-specialized features. \n\nIt’s more useful to fine-tune the more specialized features, because these are the ones that need to be repurposed on your new problem. There would be fast-decreasing returns in fine-tuning lower layers.\n\nThe more parameters we’re training, the more we’re at risk of overfitting.\n\nThe convolutional base has 15 million parameters, so it would be risky to attempt to train it on our small dataset.\n\nThus, in this situation, it’s a good strategy to fine-tune only the top two or three layers in the convolutional base. \n\nLet’s set this up, starting from where we left off in the previous example.","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"conv_base.trainable = True\nset_trainable = False\n\nfor layer in conv_base.layers:\n    if layer.name == 'block5_conv1':\n        set_trainable = True\n    \n    if set_trainable:\n        layer.trainable = True\n    else:\n        layer.trainable = False","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Now we can begin fine-tuning the network. \n\nWe’ll do this with the RMSProp optimizer, using a very low learning rate. The reason for using a low learning rate is that\nwe want to limit the magnitude of the modifications we make to the representations of the three layers we’re fine-tuning. \n\nUpdates that are too large may harm these representations."},{"metadata":{"trusted":true},"cell_type":"code","source":"model.compile(loss='binary_crossentropy',optimizer=optimizers.RMSprop(lr=1e-5),metrics=['acc'])\n\nhistory = model.fit_generator(train_generator,steps_per_epoch=100,epochs=EPOCH_100,validation_data=validation_generator,validation_steps=50)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# plotting the results\nacc = history.history['acc']\nval_acc = history.history['val_acc']\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs = range(1, len(acc) + 1)\n\nplt.plot(epochs, acc, 'bo', label='Training acc')\nplt.plot(epochs, val_acc, 'b', label='Validation acc')\nplt.title('Training and validation accuracy')\nplt.legend()\n\nplt.figure()\nplt.plot(epochs, loss, 'bo', label='Training loss')\nplt.plot(epochs, val_loss, 'b', label='Validation loss')\nplt.title('Training and validation loss')\nplt.legend()\n\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We have 93% accuracy now, which is way better than the model that we build from scratch.\n\nIn the next version of this notebook, we will make predictions on the test dataset!"}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}