{"cells":[{"metadata":{},"cell_type":"markdown","source":"# CIFAR-10 - Object Recognition in Images- for beginners (score: ~90%)"},{"metadata":{},"cell_type":"markdown","source":"This notebook refers to Kaggle competition \"CIFAR-10 - Object Recognition in Images\",\nwhich can be found here: https://www.kaggle.com/c/cifar-10 .
\nIt is written for begginers as we were at when we joined the competition.
\nThe notebook was checked on a clean environment and it installs everything needed.
\nWe hope it will help you to get started. Feel free to contact us with any question or comment.
\nMaor Vaknin - vaknin.mj@gmail.com
\nItay Cohen - itaycohen89@gmail.com
"},{"metadata":{},"cell_type":"markdown","source":"## 1. Data"},{"metadata":{},"cell_type":"markdown","source":"### This section downloads and builds the data from Kaggle and installs the needed packages.\n### You only need to run it once. If It's not your first run, you can jump to section 2."},{"metadata":{},"cell_type":"markdown","source":"We found two versions of the data-
\n> 1. from Kaggle
\n> 2. from Kers datasets
\n\nThe colors in the Kaggle dataset are different from those in the Keras dataset.
\nHowever, we found that the Keras dataset is easier to work with,
\nand you can find some commented lines regarding the keras dataset.
\nThis notebook uses the Kaggle dataset in order to make submission to Kaggle easier.
"},{"metadata":{},"cell_type":"markdown","source":"### Install Kaggle API and download the data"},{"metadata":{"trusted":true},"cell_type":"code","source":"!pip install py7zr","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!python -m py7zr x ../input/cifar-10/train.7z /kaggle/working/","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!python -m py7zr x ../input/cifar-10/test.7z /kaggle/working/","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!ls ../working","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_images_path = \"/kaggle/working/train\"\ntest_images_path = \"/kaggle/working/test\"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Prepare the data"},{"metadata":{},"cell_type":"markdown","source":"### prerequisites"},{"metadata":{"scrolled":false,"trusted":true},"cell_type":"code","source":"# !conda install --yes -c anaconda tensorflow\n\n# !conda install --yes -c conda-forge glob2\n# !conda install --yes -c conda-forge opencv\n\n# !conda install --yes -c anaconda numpy\n# !conda install --yes -c anaconda pandas\n\n# !conda install --yes -c conda-forge scikit-learn \n# !conda install --yes -c anaconda pydot\n# !conda install --yes -c conda-forge matplotlib","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# !conda update conda","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!pip install tensorflow-gpu\n\n!pip install glob2\n!pip install opencv\n\n!pip install numpy\n!pip install pandas\n\n!pip install scikit-learn \n!pip install pydot\n!pip install matplotlib","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The data contains two folders and two files:
\n> train - a folder with 50,000 train images, which are labeled in trainLabels.csv
\n> test - a folder with 300,000 test Images with no labels
\n> trainLabels.csv - contains the labels of the train images
\n> sampleSubmission.csv - an example of the submission file expected by Kaggle"},{"metadata":{"trusted":true},"cell_type":"code","source":"!ls /kaggle/working","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import glob\nimport os\nimport cv2\nimport numpy as np \n \n# Since the folders only contain Images, the size of the datasets is the number of files in it's folder\nnum_of_train_images = len(glob.glob(train_images_path+\"/*\"))\nnum_of_test_images = len(glob.glob(test_images_path+\"/*\"))\n\n# Let's create a dataset from the images\ntrain_images = [[]]*num_of_train_images\nfor dir_name, _, filenames in os.walk('/kaggle/working/train'):\n for filename in filenames:\n image_index = int(filename.split(\".\")[0])-1\n img = cv2.imread(os.path.join(dir_name,filename))\n # Add the image to the dataset\n train_images[image_index] = img\n \ntest_images = [[]]*num_of_test_images\nfor dir_name, _, filenames in os.walk('/kaggle/working/test'):\n for filename in filenames:\n image_index = int(filename.split(\".\")[0])-1\n img = cv2.imread(os.path.join(dir_name,filename))\n # Add the image to the dataset\n test_images[image_index] = img\n \n \n# The RGB values are between 0 and 255, let's divide them so the values will be between 0 and 1\ntrain_images = np.asarray(train_images, dtype=float)/255\ntest_images = np.asarray(test_images, dtype=float)/255\n\n\n\n# # If you want, you can save the dataset and load it, instead of running this block each time\n# np.save(\"../working/train_images.npy\", train_images)\n# np.save(\"../working/test_images.npy\", test_images)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_images.shape","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 2. data exploration"},{"metadata":{"trusted":true},"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# for Keras dataset only\n# Loading the dataset from Keras. Note: here we are also given the test labels.\n\n# import pandas as pd\n# import tensorflow as tf\n# from tensorflow import keras\n# data = keras.datasets.cifar10\n# (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.cifar10.load_data()\n# train_labels = pd.read_csv('../input/cifar-10/trainLabels.csv')\n# keras.utils.to_categorical(train_labels).astype('uint8')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# train_images = np.load(\"../working/train_images.npy\")\n# test_images = np.load(\"../working/test_images.npy\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_images.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_images.shape","execution_count":null,"outputs":[]},{"metadata":{"scrolled":true,"trusted":true},"cell_type":"code","source":"train_labels = pd.read_csv('/kaggle/input/cifar-10/trainLabels.csv')\n\nprint(\"Number of train images: \", train_images.shape[0])\nprint(\"Number of test images: \", test_images.shape[0])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The images come in RBG format, 32X32 pixels. Therefore (32,32,3).
\nThere are 50,000 train images and 300,000 test images (in the Kaggle dataset)
\nLet's plot some train images with their true labels:"},{"metadata":{"trusted":true},"cell_type":"code","source":"fig=plt.figure(figsize=(8, 8))\ncolumns = 4\nrows = 2\nfor i in range(1, columns*rows +1):\n img = train_images[i]\n fig.add_subplot(rows, columns, i, title=[train_labels.label[i]])\n plt.imshow(img)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 3. Build the Model"},{"metadata":{"trusted":true},"cell_type":"code","source":"import numpy as np \nimport pandas as pd \nfrom tensorflow import keras\n\n# Model architecture\nfrom sklearn.model_selection import train_test_split\nfrom tensorflow.keras import Sequential, datasets,models,layers\nfrom tensorflow.keras.callbacks import ModelCheckpoint\nfrom tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D\nfrom tensorflow.keras.layers import MaxPooling2D, DepthwiseConv2D, BatchNormalization\nfrom tensorflow.keras.models import load_model\n\n# Data processing\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.utils import to_categorical","execution_count":null,"outputs":[]},{"metadata":{"scrolled":true,"trusted":true},"cell_type":"code","source":"from tensorflow.python.client import device_lib\nprint(device_lib.list_local_devices())\n# Make sure you are running on a GPU!","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels.head(5)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"classes = list(set(list(train_labels.label)))\nclasses","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"num_classes=len(classes)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"labels_dict = {0:'airplane', 1:'automobile', 2:'bird', 3:'cat', 4:'deer', 5:'dog', 6:'frog', 7:'horse', 8:'ship', 9:'truck'}\nlabels_dict_reversed = {'airplane':0, 'automobile':1, 'bird':2, 'cat':3, 'deer':4, 'dog':5, 'frog':6, 'horse':7, 'ship':8, 'truck':9}","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels['Category'] = train_labels.label.map(labels_dict_reversed)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The categories are represented by numbers from 0 to 9.\n# Our network needs another representation- a vector of 0's and 1's.\n# This function converts the categories to a One-hot vector.\n# For example, if the label is 3, then the function will return [0,0,0,1,0,0,0,0,0,0]\ntrain_labels_categories = keras.utils.to_categorical(train_labels.Category, num_classes)#.astype('uint8')\n\n# Splitting the training data into train set and validation set\nx_train, x_val, y_train, y_val = train_test_split(train_images, train_labels_categories, random_state=0, test_size=0.05)\n\n# for Keras dataset only\n# x_test = test_images.astype('float32')/255\n# y_test = keras.utils.to_categorical(test_labels, num_classes).astype('uint8')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels_categories","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"x_train.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"x_val.shape","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"In order to avoid Overfitting, it is recommended to use augmentation.
\nFor example, we can rotate the image, change the zoom and the centeralization."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Data augumetation\ndatagen = ImageDataGenerator(\n rotation_range=0.3, \n zoom_range = 0.1, \n width_shift_range=0.1, \n height_shift_range=0.1,\n horizontal_flip=True)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model_layers = [\n Conv2D(32, (3, 3), activation='relu', strides=(1,1), padding='same', input_shape=(32, 32, 3)),\n BatchNormalization(),\n DepthwiseConv2D(kernel_size=(3,3), strides=(1, 1), padding='same', activation=keras.activations.relu, depth_multiplier=3),\n# MaxPooling2D(2, 2),\n Dropout(rate =0.1),\n \n \n Conv2D(64, (3, 3), activation='relu', strides=(2, 2), padding='same'),\n BatchNormalization(),\n DepthwiseConv2D(kernel_size=(3,3), strides=(1, 1), padding='same', activation=keras.activations.relu),\n# MaxPooling2D(2, 2),\n Dropout(rate = 0.1),\n \n Conv2D(128, (3, 3), activation='relu', strides=(1, 1), padding='same'),\n BatchNormalization(),\n DepthwiseConv2D(kernel_size=(3,3), strides=(1, 1), padding='same', activation=keras.activations.relu),\n# MaxPooling2D(2, 2),\n Dropout(rate = 0.4),\n \n Conv2D(128, (3, 3), activation='relu', strides=(1, 1), padding='same'),\n BatchNormalization(),\n DepthwiseConv2D(kernel_size=(1,1), strides=(1, 1), padding='same', activation=keras.activations.relu),\n \n \n Conv2D(256, (3, 3), activation='relu', strides=(2, 2), padding='same'),\n BatchNormalization(),\n DepthwiseConv2D(kernel_size=(3,3), strides=(1, 1), padding='same', activation=keras.activations.relu),\n \n \n \n Conv2D(512, (1, 1), activation='relu', strides=(2, 2), padding='same'),\n BatchNormalization(),\n DepthwiseConv2D(kernel_size=(1,1), strides=(1, 1), padding='same', activation=keras.activations.relu),\n \n# MaxPooling2D(2, 2),\n Dropout(rate = 0.4),\n \n Flatten(),\n Dropout(rate = 0.3),\n Dense(2048, activation='relu'),\n Dropout(rate = 0.3),\n Dense(512, activation='relu'),\n Dropout(rate = 0.4),\n Dense(10, activation='softmax')\n] \nmodel = Sequential(model_layers)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# A summary of the model. \n# We can see how many parameters are in each layer and the total number of parameters.\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Visualization of the model\nkeras.utils.plot_model(model)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The last epoch does not necessarily produces the best model. \n# We want to choose our model wisely,\n# so we will save the model that achieved the highest accuracy on the validation set\nmcp_save = ModelCheckpoint('../working/best_model', save_best_only=True, monitor='val_accuracy', mode='max')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 4. Train the model"},{"metadata":{"scrolled":false,"trusted":true},"cell_type":"code","source":"# Training the model on the augmented train set\n# We reached a score of ~90% after 100 epochs. 5 epochs won't get a score near that, but on Kaggle each epcoh takes a long time.\n# Choose the number of epochs that fits your machine. Same for batch_size, which we set to 512 on my machine.\nnum_of_epochs = 5\nbatch_size = 64 \n# The number of iteration in one epoch is ceil((size of training data)/(batch size)). ceil(47,500/64)=ceil(742.1875)=743\nmodel.fit(datagen.flow(x_train, y_train, batch_size=batch_size), validation_data=(x_val, y_val), callbacks=[mcp_save], epochs=num_of_epochs)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We can see that the train accuracy keeps improving but the validation accuracy is not, Which means we are Overfitting the model to the data."},{"metadata":{"trusted":true},"cell_type":"code","source":"# for Keras dataset only\n# model.evaluate(x_test, y_test)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 5. Predict and create Submission file for Kaggle"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Take the best model under the criterion chosen.\n# Here we took the model that achieved the highest accuracy on the validation set.\nmodel_ = load_model('../working/best_model', compile=False)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Now let's use our model to predict the classes of each image in the test set\ntest_predictions = model.predict_classes(test_images)\ntest_predictions","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_predictions_df = pd.DataFrame(test_predictions)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# It's easy to use the sample submission file to create our own submission file\nsamples = pd.read_csv(\"../working/cifar-10/sampleSubmission.csv\", index_col=False)\n\n# Replace the sample labels with those our model predicted\nsamples.label= test_predictions\n\n# Our model predicts the number of the classes of each image.\n# Kaggle is expecting a string, for example, if our model predicted \"2\" we need to translate it to \"bird\"\nsamples.replace({\"label\":labels_dict}, inplace=True)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Let's see how our model predicted some images\nfig=plt.figure(figsize=(8, 8))\ncolumns = 4\nrows = 2\nfor i in range(1, columns*rows +1):\n img = test_images[i]\n fig.add_subplot(rows, columns, i, title=samples.label[i])\n plt.imshow(img)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"samples.to_csv(\"../working/submission.csv\", index=False)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!kaggle competitions submit -c cifar-10 -f ../working/submission.csv -m \"Submitted using the notebook\"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{},"cell_type":"markdown","source":"","attachments":{"image.png":{"image/png":"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"}}}],"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}