{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Introduction\n\nNeural networks are a great mathematical tool for classification problems (available also for regression *i. e.* for getting a number/set of numbers as a function of some inputs). They are very hyped at the moment, because they can create very complex non-linear functions that are able to do incredible things like distinguishing cats and dogs using the colors of the pixels of a digital photograph.\n\nTheir drawback is that they have a LOT of internal parameters, that means that you need thousands (if not millions) of input data to build a realistic model.\n\nIf you are not so familiarized with neural networks, read this great introduction from Matthew Stewart: https://towardsdatascience.com/simple-introduction-to-neural-networks-ac1d7c3d7a2c\n\nActually, I advise you to read all the articles by [him](https://towardsdatascience.com/@matthew_stewart) in Towards Data Science.\n\nFor images, there is a particular type of neural network that is very suitable: the convolutional neural network (CNN). Again, Matthew Stewart has a great [introduction about them](https://towardsdatascience.com/simple-introduction-to-convolutional-neural-networks-cdf8d3077bac).\n\nWe will use all of this to try to predict the labels (a car, a cat, a frog...) of a list of images from the [CIFAR-10 dataset](https://en.wikipedia.org/wiki/CIFAR-10).\n\n\n# Preparation\n\nOK, let's prepare our Notebook for doing some neural network stuff. First, let's include the standard header of all Kaggle notebooks.","execution_count":null},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load in \n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the \"../input/\" directory.\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# Any results you write to the current directory are saved as output.","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Let's start importing some useful libraries","execution_count":null},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"code","source":"from os import listdir\nfrom PIL import Image\nimport matplotlib.pyplot as plt\nfrom sklearn.preprocessing import OneHotEncoder\nfrom sklearn.model_selection import train_test_split","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"And the TensorFlow and Keras libraries","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"import tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import Sequential\nfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, BatchNormalization, Concatenate, Dense\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.regularizers import l1, l2\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Now we have to unzip the images that we will use to train the neural network (inspired by https://www.kaggle.com/faizanurrahmann/cifar-10-object-classification-cnn-keras)","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"!pip install py7zr\n\nfrom py7zr import unpack_7zarchive\nimport shutil\nshutil.register_unpack_format('7zip', ['.7z'], unpack_7zarchive)\nshutil.unpack_archive('/kaggle/input/cifar-10/train.7z', '/kaggle/working')\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Reading training data\n\nWe finally have all the necessary libraries loaded and the training images in our working directory! We can start doing some neural network stuff.\n\nBut first we have to get the images in a format that a neural network can handle. How can we do that? With the PIL library that we have already loaded.\n\nImages in a computer are nothing but an $a \\times b$ matrix of pixels. Each pixel in the position $(x_a,y_b)$ has three values from 0 to 255 that specify what amount of [red, green and blue](https://simple.wikipedia.org/wiki/Primary_color) each pixel has. With that information, an image can reproduce up to 255$^\\text{3}$ = 16 million colors.\n\nLet's extract this color information and transform it into some mathematical structure that the neural network can handle: a numpy array! As previously mentioned, the PIL library is the way to go.\n\nAt the end we will get an array of the form $(n_{images},a,b,3)$ (3 because we have three color channels: red (R), green (G) and blue (B)).","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_path = '/kaggle/working/train/'\n\ntrain_list = listdir(train_path)\n\nX_list = [0] * len(train_list)\n\nfor i_image in train_list:\n    num_image = int(i_image[:-4]) -1\n    imagen = Image.open(train_path + i_image)\n    imagen_numpy = np.uint8(imagen)\n    X_list[num_image] = imagen_numpy\n\nX = np.array(X_list)\n\nprint(X.shape)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"OK, now we have the \"independent variables\" X; but we need y, *i. e*. what are the labels associated to each image. For that we will read the trainLabels.csv file. This file contains the labels as text, and this is not what we want. We want a vector whose size is equal to the number of different labels (10 in CIFAR-10): each element of the array correspond to a label, and it will be 1 if this is the actual label of the image and zero otherwise. For example: \"car\" = (1,0,0,...,0,0), \"bird\" = (0,1,0,...,0,0). Sklearn has a tool for doing exactly that: [OneHotEncoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html).","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_data = pd.read_csv('/kaggle/input/cifar-10/trainLabels.csv')\nonehot_encoder = OneHotEncoder()\ny = onehot_encoder.fit_transform(train_data[['label']])\ny = y.toarray()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Now we want to check if all labels are more or less equally probable. Why is this important? Because we can have a *class imbalance*, and that can distort our model. For example, imagine that we have a set of dogs and cats, and 90 % of the images are dogs. A neural network that consider that *every* picture is a dog will still have a 90 % of accuracy.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"labels_df = train_data.groupby(['label']).count()\nlabels_matrix = y.sum(axis=0)\nprint(labels_df)\nprint(labels_matrix)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Fortunately it is not our case, all our classes are balanced. Good! If not, don't worry, there are ways to deal with that.\n\nFinally, let's divide our labeled photographs in train and test sets. We won't use all the photographs for training, but instead only 60 % of it. The remaining will be used to test how the model performs in data that has not been used for training. We don't want a neural network that fits very good our training data, but it works horrible when we ask it to predict a photo that it hasn't seen before, i. e. we don't want [overfitting](https://en.wikipedia.org/wiki/Overfitting). For that, we will use the train set as a simple way of [cross validation](https://en.wikipedia.org/wiki/Cross-validation_(statistics%29 )","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.4)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Creation of a neural network\n\n## Quick and dirty neural network\n\nOK, I guess at this point you are kind of bored. When do we do some cool stuff? OK, I won't bore you anymore. Let's start now! The following code is quick and dirty, but it is very simple to understand.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train_normalized = X_train/255.0\nX_train_normalized = X_train_normalized.astype('float32')\n\nneural_network = keras.Sequential([\n    keras.layers.Conv2D(64,(3,3),activation='relu',input_shape=(32,32,3)),\n    keras.layers.Flatten(),\n    keras.layers.Dense(64,activation='relu'),\n    keras.layers.Dense(32,activation='relu'),\n    keras.layers.Dense(10,activation='softmax')\n])\n\nneural_network.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])\n\nneural_network.fit(X_train_normalized,y_train, epochs=50)\n\nnn_loss, nn_score = neural_network.evaluate(X_test,y_test,verbose=2)\n\nprint(\"The accuracy of the neural network on the test data is {0:4.3f}\".format(nn_score,))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"What have we done? The very first thing is to normalize the input: we want the data of the numpy array going from 0 to 1, instead of from 0 to 255, because neural networks work better with data between 0 and 1. The second line is more technical: we want to optimize the storage of the numpy array using single precision 32-bit float (`float32`) instead of the default `float64`, so the array size in memory is 50 % less.\n\nThen we started a neural network with `keras.Sequential()`, that has a [CNN](https://keras.io/layers/convolutional/#conv2d) with 64 $3 \\times 3$ matrix filters (see [this](https://towardsdatascience.com/simple-introduction-to-convolutional-neural-networks-cdf8d3077bac#e051) to understand what matrix filters are), then we [flatten](https://keras.io/layers/core/#flatten) it to have a \"classical\" one-dimensional neural network structure, and finally two layers of neurons (one with 64 and one with 32) and a last one, that will be the output layer, *i. e.* it will tell us how likely is that the image is a horse or a dog, or something else. Following the example in the previous section, an output like (0.8,0.2,0,...,0,0) means that the image has a 80 % probability of being a car and 20 % of being a bird.\n\n\nNow let's build something more sophisticated and generalizable. We will crate a function that generate a deeper neural network, whose architecture will depend on the input parameters.\n\n## Systematic search for the best neural network","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def create_neural_network(train_array_iterator,test_array_iterator,num_filters_input,num_neurons_input,num_conv_input,num_maxpool_input,overfitting,label=None,verbosity=0):\n\n    # Cleanup inputs\n\n    num_filters = round(num_filters_input)\n    num_neurons = round(num_neurons_input)\n    num_conv = round(num_conv_input)\n    num_maxpool = round(num_maxpool_input)\n    if overfitting == 'l1':\n        regularizer = l1(0.01)\n    elif overfitting == 'l2':\n        regularizer = l2(0.01)\n    else:\n        regularizer = None\n\n    # Build the neural network\n\n    neural_network = Sequential()\n    neural_network.add(Conv2D(num_filters,(3,3),activation='relu',input_shape=(32,32,3)))\n    for i_maxpool in range(num_maxpool):\n        try:\n            for i_conv in range(num_conv):\n                neural_network.add(Conv2D(num_filters, (3, 3), activation='relu', padding='same',\n                                          kernel_regularizer=regularizer, bias_regularizer=regularizer))\n            neural_network.add(MaxPooling2D(pool_size=(2,2)))\n            if overfitting == 'Dropout':\n                neural_network.add(Dropout(0.25))\n            elif overfitting == 'Batch_Normalization':\n                neural_network.add(BatchNormalization(momentum=0.99))\n        except:\n            break\n\n    neural_network.add(keras.layers.Flatten())\n    neural_network.add(keras.layers.Dense(num_neurons,activation='relu'))\n    neural_network.add(keras.layers.Dense(round(num_neurons/2),activation='relu'))\n    neural_network.add(keras.layers.Dense(10,activation='softmax'))\n    neural_network.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n    print('Created a neural network with the following structure:')\n    print(neural_network.summary())\n    \n    # Callbacks\n\n    rlr = keras.callbacks.ReduceLROnPlateau(patience=15, verbose=1)\n    es = keras.callbacks.EarlyStopping(patience=35, restore_best_weights=True, verbose=1)\n    print('Fitting the neural network')\n    historia = neural_network.fit_generator(train_array_iterator, validation_data=test_array_iterator, epochs=50, verbose=verbosity, callbacks=[rlr,es])\n    \n    # Plot\n    \n    #plt.figure(figsize=[15,15])\n    plt.figure()\n    if label is None:\n        plt.plot(historia.history['accuracy'], label='Train accuracy')\n        plt.plot(historia.history['val_accuracy'], label='Test accuracy')\n    else:\n        plt.plot(historia.history['accuracy'], label='Train accuracy ({0})'.format(label))\n        plt.plot(historia.history['val_accuracy'], label='Test accuracy ({0})'.format(label))\n    plt.legend()\n    \n    return neural_network\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"This is something definitely more complex than our previous neural network, so let me explain it what this function does in more detail.\n\n1) Cleanup inputs. Essentially it makes sure that num_filters and num_neurons are integer numbers, and are passed as such to Conv2D and Dense layers. It also creates a [regularizer object](https://keras.io/regularizers/) that may be l1 or l2. Regularizers prevent overfitting (see below); l1 and l2 do that by penalizing [large weights](https://www.machinecurve.com/index.php/2020/01/21/what-are-l1-l2-and-elastic-net-regularization-in-neural-networks/). See more details here for [l1](https://scikit-learn.org/stable/modules/linear_model.html#lasso) and here for [l2](https://scikit-learn.org/stable/modules/linear_model.html#ridge-regression-and-classification). If you are a Bayesian fan, as myself, a very intuitive and more mathematically complex way of introducing l2 regularization is explained in this [article](https://katbailey.github.io/post/from-both-sides-now-the-math-of-linear-regression/).\n\n2) Build the neural network. This essentially consist on a loop that create several multilayers consisting 2 CNN plus a [maxpooling](https://keras.io/layers/pooling/#maxpooling2d) for decreasing the complexity. If we are trying to prevent overfitting using [dropout](https://keras.io/layers/core/#dropout) or [batch normalization](https://keras.io/layers/normalization/#batchnormalization), we include the layers here. We finish it with a flatten layer to return to a 1D neural network, plus two layers, plus the output layer.\n\n3) Finally we add a couple of [callbacks](https://keras.io/callbacks/). The callbacks change the convergence process on the fly, either by [reducing the learning rate](https://keras.io/callbacks/#reducelronplateau) or by [stopping](https://keras.io/callbacks/#earlystopping) it when the accuracy is not increasing anymore (even decreasing).\n\nThen we fit the neural network with batches (see below) and we get a graph of how accuracy improves (for our training and our testing set) as a function of time.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"We are going to train our neural network with batches. That means that instead of loading all the 30000 images in memory and use all of them at the same time each epoch, we will load a batch of photos in memory, train the neural network for this batch of photos, load a new batch of photos and train it for this new batch, and so on, until all of the photos are used for training. This has advantages and disadvantages. A great advantage is that we don't need to keep in memory all our photos (imagine if we are training 2 million of 800x600 photos, these are several TB, and no computer will be able to handle so much RAM memory. A disadvantage is that we lose some of the performance of GPUs because communication between GPU and CPU. Another thing is that we may get quite different results if we train on batches ([and this is sometimes good](https://towardsdatascience.com/simple-introduction-to-neural-networks-ac1d7c3d7a2c#7b42)).\n\nMoreover, we can do more things while we create our batches. In this case we are normalizing the inputs (i. e. making sure that our inputs go from 0 to 1).","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_preprocessor = ImageDataGenerator(rescale=1.0/255.0)\ntest_preprocessor = ImageDataGenerator(rescale=1.0/255.0)\n\ntrain_iterator = train_preprocessor.flow(X_train,y_train,batch_size=256)\ntest_iterator = test_preprocessor.flow(X_test,y_test,batch_size=256)\n\nred_neuronal = create_neural_network(train_iterator,test_iterator,64,32,2,2,None)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Great! Another neural network trained. See that in this case, the accuracy for the test set is close to 70 %, instead of 30 % for the quick an dirty one. But we can definitely improve the accuracy.\n\nA way of doing that is using regularization. It is advised to do so in order to prevent two typical problems of neural networks: [overfitting](https://www.analyticsvidhya.com/blog/2018/11/neural-networks-hyperparameter-tuning-regularization-deeplearning/) and [exploding gradients](https://machinelearningmastery.com/exploding-gradients-in-neural-networks/).\n\nThere are several ways of doing normalization. We are going to use l1, l2, dropout and batch normalization.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_preprocessor = ImageDataGenerator(rescale=1.0/255.0)\ntest_preprocessor = ImageDataGenerator(rescale=1.0/255.0)\n\ntrain_iterator = train_preprocessor.flow(X_train,y_train,batch_size=256)\ntest_iterator = test_preprocessor.flow(X_test,y_test,batch_size=256)\n\nnormalization = {}\n\nfor i_normalizer in [None,'l1','l2','Dropout','Batch_normalization']:\n#    train_preprocessor = ImageDataGenerator(rescale=1.0 / 255.0)\n#    test_preprocessor = ImageDataGenerator(rescale=1.0 / 255.0)\n#    train_iterator = train_preprocessor.flow(X_train, y_train, batch_size=256)\n#    test_iterator = test_preprocessor.flow(X_test, y_test, batch_size=256)\n\n    this_neural_network = create_neural_network(train_iterator,test_iterator,64,32,2,2,i_normalizer,i_normalizer)\n\n#    test_preprocessor = ImageDataGenerator(rescale=1.0 / 255.0)\n#    test_iterator = test_preprocessor.flow(X_test, y_test, batch_size=256)\n    nn_loss, nn_score = this_neural_network.evaluate_generator(test_iterator,verbose=2)\n    normalization[i_normalizer] = nn_score\n\nprint(normalization)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"From the results, we see that Dropout gives the best accuracy in the test set. We are going to keep also no regularization, because it can actually be detrimental for simple models that are already biased (since it introduces another source of bias).\n\nNow let's do a systematic search for the best neural network architecture, trying out different number of CNN layers, MaxPool layers, and so on. For that it will be very useful the `create_neural_network` function that we have defined.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"test_nn = {}\ntest_score = {}\n\nfor i_normalizer in [None, 'Dropout']:\n    for i_convolution in range(1,4):\n        for i_maxpool in [1,2]:\n            for i_neurons in [8,32]:\n                for i_filters in [64,128]:\n                    indice = '{0}, {1}, {2}, {3}, {4}'.format(i_normalizer,i_convolution,i_maxpool,i_neurons,i_filters)\n                    texto = 'Creating the neural network for parameters: ' + indice\n                    print(texto)\n                    this_neural_network = create_neural_network(train_iterator, test_iterator, i_filters, i_neurons,\n                                                                i_convolution, i_maxpool, i_normalizer, indice)\n                    nn_loss, nn_score = this_neural_network.evaluate_generator(test_iterator, verbose=2)\n                    print('Test score: {0}'.format(nn_score))\n                    test_score[indice] = nn_score\n                    test_nn[indice] = this_neural_network\n\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Merged neural network with the best architectures","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"best_nn = sorted(test_score.items(), key=lambda x : x[1], reverse=True)\n\nprint(best_nn)\n\nbest_nn_indices = [ x[0] for x in best_nn ]\n\nbest_5_nn_indices = best_nn_indices[0:5]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We see that the test accuracy ranges from 0.78 to 0.10. In particular the best five range from 0.78 to 0.74... is it possible to somehow use the results from the five best neural networks to obtain a better result?\n\nIndeed! We could do something as simple as take the average of the output layers of the 5 neural networks. This way errors from each neural network (hopefully) will compensate, and we will get an slightly more accurate neural network. But we can do it better. We can create a neural network!\n\nThis is what we are going to do to further improve the accuracy. Let's add another layer that connects the best 5 neural networks and train it! (see image below).\n\n![Neural_network_draw_low_res.png](attachment:Neural_network_draw_low_res.png)","attachments":{"Neural_network_draw_low_res.png":{"image/png":"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"}},"execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"the_input = keras.Input(shape=(32,32,3))\n\nnn_legs = []\nfor i_key in best_5_nn_indices:\n    output_i = test_nn[i_key](the_input)\n    nn_legs.append(output_i)\n\nx = Concatenate()(nn_legs)\nx = Dense(1024,activation='relu')(x)\nthe_output = Dense(10,activation='softmax')(x)\n\nmerged_model = Model(inputs=the_input,outputs=the_output)\nmerged_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n\nrlr = keras.callbacks.ReduceLROnPlateau(patience=15, verbose=1)\nes = keras.callbacks.EarlyStopping(patience=35, restore_best_weights=True, verbose=1)\nmerged_model.fit_generator(train_iterator, validation_data=test_iterator, epochs=50, callbacks=[rlr,es])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Great! We have improved it by almost 3 %!","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"Now let's use it to predict the test data! For doing that we are going to try a new tool. Instead of manually creating a numpy array and transform it into an iterator, we are going to use flow_from_directory, that will create the iterator directly for us. It will be quite handy, because now we have 300000 images. If we create a numpy array, it will be 10 times larger and we may have memory problems.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"shutil.unpack_archive('/kaggle/input/cifar-10/test.7z', '/tmp/testfiles')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"! ls /tmp/testfiles/test | wc -l","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"predict_preprocessing = ImageDataGenerator(rescale=1.0 / 255.0)\npredict_iterator = predict_preprocessing.flow_from_directory(directory='/tmp/testfiles',target_size=(32,32),color_mode='rgb',class_mode=None,batch_size=256,shuffle=False)\n\nprediccion = merged_model.predict_generator(predict_iterator)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The prediction array has now a numpy array shape. We have to invert the one hot encoder to get back which class the neural network is predicting","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"label_prediction = onehot_encoder.inverse_transform(prediccion)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"And finally we generate the prediction csv file in order to submit the results.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"prediction_df = pd.DataFrame(label_prediction)\n\n# In order to get the indices right, we must take into account that flow_from_directory reads files on a alphabetical order. This means that after '1' comes '10' and not two.\n# For that reason we need to play around a little bit with the indices, to sort them alphabetically.\nlabels_text_sorted = sorted([ str(x) for x in range(1, prediction_df.shape[0] + 1)])\nlabels_as_integers = [int(x) for x in labels_text_sorted]\nprediction_df.insert(0,'Indice',labels_as_integers)\nprediction_df = prediction_df.sort_values(by=['Indice'])\n\nprediction_df.to_csv('/kaggle/working/prediction.csv',\n                     header=['id','label'],index=False)","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}