{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Intro #\nRefer to the famous Dogs and Cats classification problem. Goal is simple: we need to teach machine distinguish dogs from cats. In this notebook we will try to address it by using neural networks.\n\n**General plan**:  \n1.Explore dataset, make some preprocessing if need.   \n2.Choose two different neural network types, implement and train it on validation and train data.  \n3.Make predictions on test data.  \n4.Outline conclusions.\n\n**Why neural networks?**  \nThey have proven themselves in practice of real-word problem solving and competitions, in particular in\ncomputer vision problem. Thus, Сonvolution Neural Networks (CNN) perfectly proved themselves especially in matters of computer vision. Many CNN architectures were specially designed for that purpose. An overview of CNN concepts, their architectures and implementations is beyond the scope of this article. We will choose two of them, give short overview and describe in detail their implementation and training. The rationale for their choice is given in the Machining Learning section.\n\n**Some comments**  \nWe have reviewed many laptops on this topic, the authors of which have done a great job, for which many thanks can be given to them. But unfortunately, many authors paid little attention to the comments of their actions, and also did not highlight such subtleties as loading datasets, unzipping them, connecting external weights. In the process of this work, we were faced with many nuances and glitches in these \"auxiliary\", but inevitable issues. Therefore, we tried to comment on almost every action, in particular, on \"auxiliary\" issues. So some comments with direct links to Stack Overflow may be found in text.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"# Import libraries and tools #","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Import libraries and tools\n# Data preprocessing and linear algebra\nimport os, re, random\nimport pandas as pd\nimport numpy as np\nimport zipfile\nnp.random.seed(2)\n\n# Visualisation\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nimport seaborn as sns\n%matplotlib inline\n\n# Tools for cross-validation, error calculation\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import confusion_matrix\nimport itertools\nfrom keras.utils.np_utils import to_categorical\n\n# Machine Learning\nfrom keras.models import Sequential\nfrom keras import layers\nfrom keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D\nfrom keras.layers import MaxPooling2D, GlobalMaxPooling2D, Activation\nfrom keras.optimizers import RMSprop\nfrom keras.preprocessing.image import ImageDataGenerator, load_img\nfrom keras import optimizers\n# from keras.callbacks import ReduceLROnPlateau, EarlyStopping\nfrom tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\nfrom keras.models import Model\nfrom keras.applications import VGG16\nfrom keras.applications.resnet50 import ResNet50","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"First, lets outline our goal. \"Our goal is to correctly distinguish dogs from cats.\"","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"# Data load #","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Load and unzip data ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"Since we created notebook from \"Dogs vs Cats\" page, data will load automatically and may be found in /input directory after session starts.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save datasets path\nPATH = \"../input/dogs-vs-cats-redux-kernels-edition\"\nPATH_TRAIN = \"train_images/\"\nPATH_TEST = \"test_images/\"","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check datasets in file system\nos.listdir(PATH)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save archives paths and names\ntrain_image_path = os.path.join(PATH, \"train.zip\")\ntest_image_path = os.path.join(PATH, \"test.zip\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Create subfolder for train dataset\n# Disclaimer. It is need because ImageDataGenerator() which we will use later correctly reads images only from subfolders\nos.mkdir('/kaggle/working/train_images')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Create subfolder for test dataset\nos.mkdir('/kaggle/working/test_images')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Unzip train dataset\narchive = zipfile.ZipFile(train_image_path,\"r\")\nfor file in archive.namelist():\n        archive.extract(file, 'train_images/')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Unzip test dataset\narchive = zipfile.ZipFile(test_image_path,\"r\")\nfor file in archive.namelist():\n        archive.extract(file, 'test_images/')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check if our kittens and puppies are in right place\n# os.listdir('/kaggle/working/train_images/train')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# If you prefer work with file system, unzip can be done using bash commands.\n# Just leave this code here, it will give same result - unzipped images in two folders.\n# Unzip train dataset\n# !unzip ../input/dogs-vs-cats-redux-kernels-edition/train.zip\n# Check unzipped dataset in file system\n#! ls -l train/\n# Unzip test dataset\n# !unzip ../input/dogs-vs-cats-redux-kernels-edition/test.zip","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Data exploration #","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Save data to NumPy and Pandas arrays ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"We begin with some small preparations. We should extract our images filemames and labels. They will be used in model training.  \n**Note**. For now we will not work with test data in order to prevent mistakenly using it instead of validation.\nAs we know, test data must be shown to algorhytm only once - at final prediction. So, we will work on test subset at pre-final - prediction step.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save images names to variable\ntrain_images = os.listdir(f'{PATH_TRAIN}/train/')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Then extract images names and save them into Numpy array\nimagenames = np.array([f'{f}' for f in train_images])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check our image names array\nimagenames","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Assign labels to images according to competitions task (0-cat, 1-dog)\n# Implement array of image categories\ncategories = []\nfor imagename in imagenames:\n    # Loop through data and split our images names\n    split_category = imagename.split('.')[0]\n    # Assign labels\n    if split_category == 'cat':\n        categories.append(str(0))\n    else:\n        categories.append(str(1))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save our filenames \nanimals = pd.DataFrame({\n    'Image name': imagenames,\n    'Category': categories\n})\nanimals.head(5)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check total amount of 0 and 1 labels\nanimals['Category'].value_counts()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"As we see, our tasks initial 12500 images dataset is balanced: both 12500 dogs and cats. Good.  \nOk. Now we can take a look at one little cute kitten.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Draw a cat\n# Don't forget to install 'pillow' module (conda install pillow) to give a 'pyplot' ability of working with '.jpg'\nimg = plt.imread(f'{PATH_TRAIN}/train/{imagenames[1]}')\nplt.imshow(img);","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Isn't it pretty? Our efforts were not in vain. Move on.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Split data on train and validation subsets ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Split data on train and validation subsets\n# Using 10% or 20% from train data is classical approach\nX_train, X_val = train_test_split(animals, test_size=0.2,  random_state=2)\nX_train = X_train.reset_index()\nX_val = X_val.reset_index()\n\n# We may want use only 1800 images because of CPU computational reasons. If so, this code should be run\n# X_train = X_train.sample(n=1800).reset_index()\n# X_val = X_val.sample(n=100).reset_index()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Count amount of rows. Need for two reasons.  \nFirst: will be used in model fit process as parameter devided by batch size.  \nSecond: if we cut 1800-images subset for comp. reasons we should check if there are exact 1800\nimages present.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Count\ntotal_X_train = X_train.shape[0]\ntotal_X_val = X_val.shape[0]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"total_X_train","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"total_X_val","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Machine learning #","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"In the problems of image recognition, when we get to the part of machine learning itself, question No. 1 arises.  \n\n**Which neural network to choose?**  \nWell, we know from the literature that convolutional network architecture is suitable for this task. Already good. But which architecture to choose, because there are dozens of them? Or may be we need to build our own - of course, empirically?  \nTruth be sayed, if we study the comparison of models in terms of accuracy and consumed computing power, for example [3], then it becomes clear that the vast majority of architects at one time won various competitions for image recognition. Almost any of them will suit us.\n\nWe proceed as follows.  \nBased on a comparison of networks [3], lets choose two architectures: **VGG16** and **Resnet-50**.  \nWhy them?    \nBoth are famous enough, both have approximately the same accuracy. But they need different computing power: VGG16 requires significantly more.   \nWe will choose them for comparison.\n\nWe will use Transfer Learning (TL).  \nIt is a paradigm in machine learning that focuses on storing knowledge gained while solving one problem and applying it to a different but related problem. For example, knowledge gained while learning to recognize cars could apply when trying to recognize trucks.\nThe essence of the TL is that when we build a network, we import the weights of the same network trained on a very large dataset. thus, we save time and resources.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## Model 1. VGG16 ##","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Description ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"VGG16 [2] CNN architectire proposed in 2014 by K. Simonyan and A. Zisserman (University of Oxford) in their paper “Very Deep Convolutional Networks for Large-Scale Image Recognition” [5]. The model achieves 92.7% top-5 test accuracy in ImageNet - a dataset of over 14 million images belonging to 1000 classes.\nIts principal scheme [2] is shown below:\n\n![image.png](attachment:image.png)\n\nAs we can see, this network consists of 16 layers, which are:   \n- 13 stacked Convolutional layers;\n- 3 Dense layers.\n\nConvolution layers extract features from the image, fully connected layers classify the image using extracted features.  \nThe number of filters in the convolution layers follow an increasing pattern.  \nThe informative features are obtained by Maxpooling layers applied at different steps in the architecture.\nThe dense layers comprises of 4096, 4096, and 1000 nodes each.  \nModels full configuration table may be found in [2].\n\nThe choice of this model is made due to its provenness and ease of implementation. But, it should be noted that this model, as we have already said, consumes a lot of resources, in other words, it works very slowly. However, the Keras library has a **pre-trained** model that will allow us to save our time and resources. And, as we know, time is money.\n\nLets proceed with importing and implementation of our pre-trained model.","attachments":{"image.png":{"image/png":"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"}},"execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Implementation ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# By default, the VGG16 model expects images as input with the size 224 x 224 pixels with 3 channels (e.g. color).\nimage_size = 224\ninput_shape = (image_size, image_size, 3)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Define CNN model constants\nepochs = 5\nbatch_size = 16","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"A good VGG16 implementtaion (including pre-trained weights) is present in [4]. We can refer to it for example, or just import model from Keras libs (imported in notebooks libraries section).","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Define our pre-trained model\npre_trained_model = VGG16(input_shape=input_shape, include_top=False, weights=\"imagenet\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Print models summary table\n# Note that it expects input pictures in 224 size and 3 channels, as we mensioned before. So we didn't lie.\nprint(pre_trained_model.summary())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Use this if want to see a Big Bang. Downloads VGG16 with total defaults (Total params: 138,357,544).\n# Very huge.\n# model = VGG16()\n# print(model.summary())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Add some micro-tuning \n# Set above layers to be not traianble since using pre-trained model - they are already trained\nfor layer in pre_trained_model.layers[:15]:\n    layer.trainable = False\n\nfor layer in pre_trained_model.layers[15:]:\n    layer.trainable = True\n\n# Specify networks output    \nlast_layer = pre_trained_model.get_layer('block5_pool')\nlast_output = last_layer.output\n    \n# Flatten the output layer to one dimension\nx = GlobalMaxPooling2D()(last_output)\n\n# Add a fully connected layer with 512 hidden units and ReLU activation\nx = Dense(512, activation='relu')(x)\n\n# Add a dropout rate of 0.5\nx = Dropout(0.5)(x)\n\n# Add a final sigmoid layer for classification\nx = layers.Dense(1, activation='sigmoid')(x)\n\n# Form our model\nmodel_mod = Model(pre_trained_model.input, x)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Compile model\nmodel_mod.compile(loss='binary_crossentropy',\n                  optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),\n                  metrics=['accuracy']\n                 )","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Choosing models hyperparameters (as well as their tuning) is almost empyrical process. In addition, it should be noted that it is a kind of \"cherry on the cake\" ie performed at the very end of the construction, validation and use of the working model. Therefore, we will for now set the above parameters based on the fact that their combination is known and has proven itself well. After building the model and testing it, we can easily return to this point and tune them if necessary.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Training DataGenerator ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"Keras has very useful tools for images preprocessing (i.e. rotation, flip, crop, resize etc). Lets use one of them - **ImageDataGenerator** class and perform some actions which are actually almost standard.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Implement train ImageDataGenerator and specify some small preprocessing\ntrain_datagen = ImageDataGenerator(\n    rotation_range=15,\n    rescale=1./255,\n    shear_range=0.2,\n    zoom_range=0.2,\n    horizontal_flip=True,\n    fill_mode='nearest',\n    width_shift_range=0.1,\n    height_shift_range=0.1\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Upload images from file system using flow_from_dataframe() method and use our datagen\n# to make parallel preprocessing. We obtain uploaded and preprocessed images.\ntrain_generator = train_datagen.flow_from_dataframe(\n    X_train, \n    \"/kaggle/working/train_images/train\",\n    x_col='Image name',\n    y_col='Category',\n    class_mode='binary',\n    target_size=(image_size, image_size),\n    batch_size=batch_size,\n    #validate_filenames = False\n)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Validation DataGenerator ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Implement validation ImageDataGenerator\nvalidation_datagen = ImageDataGenerator(\n    rescale=1./255\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Upload and peprocess images\nvalidation_generator = validation_datagen.flow_from_dataframe(\n    X_val, \n    \"/kaggle/working/train_images/train\",\n    x_col='Image name',\n    y_col='Category',\n    class_mode='binary',\n    target_size=(image_size, image_size),\n    batch_size=batch_size,\n    #validate_filenames = False\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check one sample generated image\n# Create generator for test sample image\ngenerated_example_df = X_train.sample(n=1).reset_index(drop=True)\nexample_generator = train_datagen.flow_from_dataframe(\n    generated_example_df, \n    \"/kaggle/working/train_images/train\", \n    x_col='Image name',\n    y_col='Category',\n    class_mode='categorical',\n    #validate_filenames = False\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Plot sample\nplt.figure(figsize=(10, 10))\nfor i in range(0, 9):\n    plt.subplot(3, 3, i+1)\n    for X_batch, Y_batch in example_generator:\n        image = X_batch[0]\n        plt.imshow(image)\n        break\nplt.tight_layout()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Callbacks ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"Before we start teaching our model we should care about avoiding of model overfitting. In general, such techniques are known as **Callbacks**. There are two useful ones: **early stop** and **learning rate reduction**.  \nIf we cut from our 12500 dataset a small 1800 part, we probably will not fall in overfitting,\nbut for general purpose lets take care about it.  \n**Nota Bene**  \nIn Kaggle enviroment we should import EarlyStop and ReduceLROnPlateau from tensorflow.keras.callbacks, not from keras.callbacks, since the last doesn't accepted in model.fit(). What shold we do without StackOverflow?","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"#### Early Stop ####\nTo prevent overfitting lets stop model learning after 10 epochs when val_loss value not decreased. Lets use EarlyStopping() method, since it is simple and good working.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"earlystop = EarlyStopping(patience=10, \n                          verbose=1, \n                          mode='auto'\n                         )","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Learning Rate Reduction #### \nLets reduce the learning rate when accuracy, for example, not increase for two continuous steps. Use well-known ReduceLROnPlateau() method, whoes library was imported at the first stage. We can use its default parameters.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy', \n                                            patience=2, \n                                            verbose=1, \n                                            factor=0.5, \n                                            min_lr=0.00001\n                                           )","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save our callbacks\ncallbacks = [earlystop, learning_rate_reduction]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"callbacks","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Model fit ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"**Nota Bene**  \nLet us leave a few comments right here at the top of paragraph just before we start our model fit.  \nIf we obtain error like above when call fit_generator() method:\n\"ValueError: Error when checking target: expected block5_pool to have 4 dimensions, but got array with shape (16, 1)\"\nwe can change class_mode in generators implemented before from 'binary' to None.  \n\nAccording to the Keras docs, setting the class_mode to 'binary' will return a 1-D array.  \nBy changing the class_mode to None, no labels are returned and the generator will only yield batches of image data. This is what you are expecting with your model, and this works well with the fit_generator() method.  \nHowever, when using class_mode None, the data still needs to reside in a subdirectory of directory for it to work correctly.  \n\nIf we do make such change, we also should make second thing - define a fixed_generator method (code is in comments below). It fixes known generator issue.  \nBut actually we can avoid this steps if we little tune VGG16 models outputs, as we did before.\n\nGod bless Stackoverflow.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Just leave it here\n# def fixed_generator(generator):\n#     for batch in generator:\n#         yield (batch, batch)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"A few notes about fit_generator() parameters. We pass into it our train DataGenerator, number of epochs, validation DataGenerator and two interesting ones: validation_steps and steps_per_epoch. How to choose them?  \nThere is a traditional approach. Traditionally, the steps per epoch is calculated as train_length // batch_size and validation steps follow same logic for validation data.  \n\nRemember, that an epoch means one iteration over all of the training data. Thus, if we have 10,000 images and a batch size of 100 then the epoch should contain 10,000 / 100 = 100 steps.  \nA training step is one gradient update. In one step batch_size many examples are processed.  \n\nA good article about difference between batch, epoch and step can be found in [12].\n","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Fit the model\nhistory = model_mod.fit_generator(\n    train_generator, \n    epochs=epochs,\n    validation_data=validation_generator,\n    validation_steps=total_X_val//batch_size,\n    steps_per_epoch=total_X_train//batch_size,\n    callbacks=callbacks\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Epoch 1/5\n# 1250/1250 [==============================] - 404s 323ms/step - loss: 0.3144 - accuracy: 0.8517 - val_loss: 0.1308 - val_accuracy: 0.9451 - lr: 1.0000e-04\n# Epoch 2/5\n# 1250/1250 [==============================] - 385s 308ms/step - loss: 0.1555 - accuracy: 0.9362 - val_loss: 0.1066 - val_accuracy: 0.9527 - lr: 1.0000e-04\n# Epoch 3/5\n# 1250/1250 [==============================] - 382s 305ms/step - loss: 0.1305 - accuracy: 0.9467 - val_loss: 0.1012 - val_accuracy: 0.9599 - lr: 1.0000e-04\n# Epoch 4/5\n# 1250/1250 [==============================] - 381s 305ms/step - loss: 0.1125 - accuracy: 0.9553 - val_loss: 0.0866 - val_accuracy: 0.9619 - lr: 1.0000e-04\n# Epoch 5/5\n# 1250/1250 [==============================] - 381s 305ms/step - loss: 0.1051 - accuracy: 0.9577 - val_loss: 0.0886 - val_accuracy: 0.9649 - lr: 1.0000e-04","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save calculated weigthts (approx. 60 Mb)\nmodel_mod.save_weights('model_wieghts.h5')\nmodel_mod.save('model_keras.h5')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Visualize model accuracy and loss ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Plot accuracy and loss curves\nfig, (ax1, ax2) = plt.subplots(2, 1, figsize=(7, 7))\n\nax1.plot(history.history['loss'], color='r', label=\"Train loss\")\nax1.plot(history.history['val_loss'], color='b', label=\"Validation loss\")\nax1.set_xticks(np.arange(1, epochs, 1))\nlegend = ax1.legend(loc='best', shadow=True)\n\nax2.plot(history.history['accuracy'], color='r', label=\"Train accuracy\")\nax2.plot(history.history['val_accuracy'], color='b',label=\"Validation accuracy\")\nax2.set_xticks(np.arange(1, epochs, 1))\nlegend = ax2.legend(loc='best', shadow=True)\n\nplt.tight_layout()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Predict on validation data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Prepare Y_val\nY_val = X_val['Category']\n# Predict on validation data\nY_pred =  model_mod.predict_generator(validation_generator)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"In order to compare predicted and validation data we need to convert predictions (which are probabiliies of classifying an animal as dog or cat, i.e 0,05% prob) into actual class predictions (which are 0 and 1).  \nTo do it we should define a threshold. Let it be default 0.5.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Define treshold\nthreshold = 0.5\n# Convert\nY_pred_conv = np.where(Y_pred > threshold, 1,0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"Y_pred_conv[:,0]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Visualize prediction on validation data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Plot probability histogram\npd.Series(Y_pred_conv[:,0]).hist()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"In order to compute a Confusion matrix we should have our predicted and validation sets in same datatype.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check datatypes\nY_pred_conv.dtype","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"Y_val.dtype","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Convert to int\nY_val_str = Y_val.astype(int)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Compute and plot the Confusion matrix\nconfusion_mtx = confusion_matrix(Y_val_str, Y_pred_conv) \n\nf,ax = plt.subplots(figsize=(8, 8))\nsns.heatmap(confusion_mtx, annot=True)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"Validation (aka True) Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Upload test data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"test_images = os.listdir('/kaggle/working/test_images/test')\nX_test = pd.DataFrame({\n    'test_imagename': test_images\n})\nsamples = X_test.shape[0]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_test.count()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# If we use only 1800 images because of CPU computational reasons:\n# X_test_cpu = X_test.sample(n=1800).reset_index()\n# X_test_cpu.count()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Test DataGenerator ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"test_datagen = ImageDataGenerator(\n    rescale=1./255\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_generator = test_datagen.flow_from_dataframe(\n    X_test, \n    \"/kaggle/working/test_images/test\", \n    x_col='test_imagename',\n    y_col=None,\n    class_mode=None,\n    batch_size=batch_size,\n    target_size=(image_size, image_size),\n    shuffle=False\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_generator","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Predict on test data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"predict = model_mod.predict_generator(test_generator, steps=np.ceil(samples/batch_size))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"predict.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_test.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"threshold = 0.5\nX_test['Category'] = np.where(predict > threshold, 1,0)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Save submission results ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save results using competitions format\nsubmit = X_test.copy()\nsubmit['id'] = submit['test_imagename'].str.split('.').str[0]\nsubmit['label'] = submit['Category']\nsubmit.drop(['test_imagename', 'Category'], axis=1, inplace=True)\nsubmit.to_csv('submission_vgg16.csv', index=False)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check how our answer looks\nplt.figure(figsize=(10,5))\nsns.countplot(submit['label'])\nplt.title(\"(Final answer on test data (Model - VGG16))\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Model 2. ResNet-50 ##","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Description ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"ResNet (aka Residual Networks) is a classic neural network used for many computer vision real-world tasks. Was implemented by Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun [9]. This model won ImageNet challenge in 2015. Scheme of net [10]: ![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}},"execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Implementation ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"We will again use pre-trained network, staying at transfer learning paradigm.\nOur steps. Initialize the ResNet-50 model, add an additional last Dense-layer, with softmax activation function and set the first layer of the model to be not trainable, since our model is pre-trained.  \n\nLets denote a few things about model constants.  \nImage size is equal 224 as it was in VGG16 model, number of epochs due to computtional reasons let equal to 5; number of classes is equal to 2, it is self-descriptive; let batch size here be equal to 64.\n\nDownload pre-trained weights from Resnet-50 officical datasource on Kaggle [11]. Notice that there are two pre-trained weights files:  \na) ..._tf_kernels.h5;  \nb) ..._tf_kernels_NOTOP.h5.  \n\nWhat are they?   \nThe _tf_kernels.h5 weights is useful for 'pure' prediction of test image and this prediction will rely completely on ResNet-50 pre-trained weights, it does not expected any training from our side.  \n\nSince we use a Transfer Learning paradigm, we should use models pre-trained weights except its TOP layer, so we will use second (aka notop) weights as initial weight for training new layer using train images.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Define model constants\n# image_size = 224 like in previous model\nnum_classes = 2\nnum_epochs = 5\nnum_batch_size = 64\nWEIGHTS_PATH = \"../input/resnet-weights-uploaded/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Nota Bene**  \nPay attention on weights path. It is manually downloaded from ResNet's Keras Dataset [11] and then manually uploaded into /input directory. First we tryed the most logical way - to attach weights from [11] butdoing so will not work in model definition because of defect mensioned here: https://www.kaggle.com/learn-forum/124381 and https://stackoverflow.com/questions/60119041/failed-to-load-keras-resnet50-model-offline-using-weight-file. So there was nothing better for us than to save the files manually, taking into account the fact that they should be saved forever, since we will need many times (download every time from Imagenet external source seems traffic-wasting unefficiant way). Don't know why, but it worked for one time, so we will skip it and use weights from Imagenet like we did in first model.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Define model\nmodel_resnet = Sequential()\n# Add pre-trained weights\nmodel_resnet.add(ResNet50(include_top=False, pooling='max', weights='imagenet'))\n# The last dense layer must specify the number of labels (or classes) and activation f-n\nmodel_resnet.add(Dense(num_classes, activation='softmax'))\n# Since we load pre-trained model we must specify first layer as non-trainable\nmodel_resnet.layers[0].trainable = True","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Compile model\nmodel_resnet.compile(\n    optimizer='sgd', \n    loss='categorical_crossentropy', \n    metrics=['accuracy']\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Print models summary\nmodel_resnet.summary()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Train model ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Before we begin lets save our train and validation subsets into threir copies\nX_train_resnet = X_train\nX_val_resnet = X_val\nY_val_resnet = Y_val\nY_train_resnet = animals['Category']","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"total_X_train_resnet = X_train_resnet.shape[0]\ntotal_X_val_resnet = X_val_resnet.shape[0]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train_resnet.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"total_X_train_resnet","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train_resnet.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_val_resnet.shape","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Train DataGenereator (for ResNet) ###","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"For model building clarity, lets repeat the process with image generation instead of using from previous step. It is quick. Omit comments, since actions are identical to the previous paragraph.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_resnet_datagen = ImageDataGenerator(\n    rescale=1./255,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_resnet_generator = train_resnet_datagen.flow_from_dataframe(\n    X_train_resnet,\n    \"/kaggle/working/train_images/train\",\n    x_col='Image name',\n    y_col='Category',\n    class_mode='categorical',\n    target_size=(image_size, image_size),\n    batch_size=num_batch_size\n)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Validation DataGenereator (for ResNet) ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"validation_resnet_datagen = ImageDataGenerator(\n    rescale=1./255\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"validation_resnet_generator = validation_resnet_datagen.flow_from_dataframe(\n    X_val_resnet, \n    \"/kaggle/working/train_images/train\", \n    x_col='Image name',\n    y_col='Category',\n    class_mode='categorical',\n    target_size=(image_size, image_size),\n    batch_size=num_batch_size\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Fit the model\nhistory_resnet = model_resnet.fit_generator(\n        train_resnet_generator,\n        epochs = num_epochs,\n        validation_data = validation_resnet_generator,\n        validation_steps = total_X_val_resnet//num_batch_size,\n        steps_per_epoch = total_X_train_resnet//num_batch_size,\n        callbacks = callbacks\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Leave this output here to outline that we obtain low accuracy when train on 5 epochs and\n# first layer trainable = False param\n# Epoch 1/5\n# 312/312 [==============================] - 190s 611ms/step - loss: 5.4424 - accuracy: 0.5646 - val_loss: 3.1316 - val_accuracy: 0.6012 - lr: 0.0050\n# Epoch 2/5\n# 312/312 [==============================] - 195s 624ms/step - loss: 5.1490 - accuracy: 0.5693 - val_loss: 5.3533 - val_accuracy: 0.5655 - lr: 0.0050\n# Epoch 3/5\n# 312/312 [==============================] - ETA: 0s - loss: 5.5350 - accuracy: 0.5592\n# Epoch 00003: ReduceLROnPlateau reducing learning rate to 0.0024999999441206455.\n# 312/312 [==============================] - 194s 622ms/step - loss: 5.5350 - accuracy: 0.5592 - val_loss: 5.5042 - val_accuracy: 0.5615 - lr: 0.0050\n# Epoch 4/5\n# 312/312 [==============================] - 193s 617ms/step - loss: 1.8847 - accuracy: 0.6557 - val_loss: 1.7388 - val_accuracy: 0.6354 - lr: 0.0025\n# Epoch 5/5\n# 312/312 [==============================] - 192s 615ms/step - loss: 2.0500 - accuracy: 0.6221 - val_loss: 5.0342 - val_accuracy: 0.5294 - lr: 0.0025","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save calculated weigthts\nmodel_resnet.save_weights('model_resnet_wieghts.h5')\nmodel_resnet.save('model_resnet_keras.h5')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Visualize accuracy and loss curves ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Plot accuracy and loss curves\nfig, (ax3, ax4) = plt.subplots(2, 1, figsize=(7, 7))\nhistory_resnet = history\n\nax3.plot(history.history['loss'], color='r', label=\"Train loss\")\nax3.plot(history.history['val_loss'], color='b', label=\"Validation loss\")\nax3.set_xticks(np.arange(1, epochs, 1))\nlegend = ax3.legend(loc='best', shadow=True)\n\nax4.plot(history.history['accuracy'], color='r', label=\"Train accuracy\")\nax4.plot(history.history['val_accuracy'], color='b',label=\"Validation accuracy\")\nax4.set_xticks(np.arange(1, epochs, 1))\nlegend = ax4.legend(loc='best', shadow=True)\n\nplt.tight_layout()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":" ### Predict on validation data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Predict on validation X_val_resnet\nY_pred_resnet =  model_resnet.predict_generator(validation_resnet_generator)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Define treshold\nthreshold = 0.5\n# Convert\nY_pred_conv_res = np.where(Y_pred_resnet > threshold, 1,0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"Y_pred_conv_res[:,0]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Visualize prediction on validation data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Plot probability histogram\npd.Series(Y_pred_conv_res[:,0]).hist()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Prepare Y_val in str dtype\n# Convert to int\nY_val_resnet_str = Y_val_resnet.astype(int)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Compute and plot the Confusion matrix\nconfusion_mtx_resnet = confusion_matrix(Y_val_resnet_str, Y_pred_conv_res[:,0]) \n\nf,ax = plt.subplots(figsize=(8, 8))\nsns.heatmap(confusion_mtx_resnet, annot=True)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"Validation (aka True) Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Test DataGenerator (for ResNet) ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Add X_test_resnet\nX_test_resnet = X_test","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_resnet_datagen = ImageDataGenerator(\n    rescale=1./255\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_resnet_generator = test_resnet_datagen.flow_from_dataframe(\n    X_test_resnet, \n    \"/kaggle/working/test_images/test\", \n    x_col='test_imagename',\n    y_col=None,\n    class_mode=None,\n    batch_size=num_batch_size,\n    target_size=(image_size, image_size),\n    shuffle=False\n)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Predict on test data ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"predict_resnet = model_resnet.predict_generator(test_resnet_generator, steps=np.ceil(samples/num_batch_size))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Save submission results (Model - ResNet) ###","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Save predictions\nsubmit_resnet = X_test_resnet.copy()\nsubmit_resnet['id'] = submit_resnet['test_imagename'].str.split('.').str[0]\nsubmit_resnet['label'] = submit_resnet['Category']\nsubmit_resnet.drop(['test_imagename', 'Category'], axis=1, inplace=True)\nsubmit_resnet.to_csv('submission_resnet_50.csv', index=False)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Check answer\nplt.figure(figsize=(10,5))\nsns.countplot(submit_resnet['label'])\nplt.title(\"(Final answer on test data (Model - ResNet))\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Conclusion #\nEvery great road has great finish. We completed our task of teaching machine how to recognise cats and dogs on pretty photos. We did it twice: using VGG16 and ResNet-50 CNN models. This was in learning purpose. And to be continuous we choosed absolutely different models: one deep and huge in computing and second more complex in structure but less resource-taking.  \nSo what we obtain?  \n1. Model implementation process (as well as data preparation) is very close in both cases. (Remember, we used Transfer learning paradigm - pre-trained models, so we just connected models implementation from Keras library, downloaded pre-trained weights, and specified models few layers, in particular, outputs).\n2. Models gave approximately a similar level of accuracy (ResNet-50 gave better result).  \n3. CPU and memory usage is very sensitive on old-school PC's like ours (with Core i5 from 2010-s and 4 Gb RAM). Our goal was not trying to benchmark since our models are very famous and probably already have many benchmarks. Therefore, the goal was only to become familiar with the capabilities and implementation of models. And what we can denote? Taking into account paragraphs one and two we can conclude that in all else being equal case it is adecuately to use more quick and modern net at least in order to save our time for new discoveries. Its complicity is not big problem if we use transfer learning concept.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"# Literature #","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"[1] https://towardsdatascience.com/a-guide-to-an-efficient-way-to-build-neural-network-architectures-part-ii-hyper-parameter-42efca01e5d7  \n[2] https://neurohive.io/en/popular-networks/vgg16/  \n[3] https://medium.com/analytics-vidhya/cnns-architectures-lenet-alexnet-vgg-googlenet-resnet-and-more-666091488df5  \n[4] https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3  \n[5] https://arxiv.org/abs/1409.1556  \n[6] https://towardsdatascience.com/keras-data-generators-and-how-to-use-them-b69129ed779c  \n[7] https://keras.io/preprocessing/image/  \n[8] https://neurohive.io/en/popular-networks/resnet/  \n[9] https://arxiv.org/abs/1512.03385  \n[10] https://towardsdatascience.com/understanding-and-coding-a-resnet-in-keras-446d7ff84d33  \n[11] https://www.kaggle.com/keras/resnet50/  \n[12] https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"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}