{"cells":[{"metadata":{},"cell_type":"markdown","source":"v1: last activation changed to softmax"},{"metadata":{},"cell_type":"markdown","source":"The EDA is done in a [separate Kernel](https://www.kaggle.com/maxlenormand/first-eda-to-get-started)\n\nThis is the first iterations I am doing, simply to have a relevant predicted output. Future work will consist of improving this along multiple aspects."},{"metadata":{},"cell_type":"markdown","source":"Updates to do to improve performances:\n- take into account different image sizes\n- perform data augmentation (but not all images can be augmented the same way. Ex: portrait cannot  be flipped vertically. Some abstract objects / representations could)."},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import numpy as np \nimport pandas as pd\n\nimport random\nimport datetime\nimport seaborn as sns\n\nfrom keras.models import Sequential\nimport tensorflow as tf\nfrom keras import backend as K\nfrom keras.models import Model\nfrom keras_preprocessing.image import ImageDataGenerator\nfrom keras.layers import Input, Dense,Concatenate, GlobalMaxPooling2D, GlobalAveragePooling2D, Activation, Flatten\nfrom keras.layers import Conv2D, MaxPooling2D, Dropout, BatchNormalization\nfrom keras.losses import binary_crossentropy\nfrom keras import regularizers, optimizers\nfrom keras.optimizers import Adam\n\nfrom keras.applications import ResNet50\n#from keras.applications.resnet_v2 import ResNet50V2\nfrom keras.applications.vgg19 import VGG19\nfrom keras.applications.mobilenet import MobileNet\nfrom keras.applications.inception_v3 import InceptionV3\nfrom keras.applications.inception_resnet_v2 import InceptionResNetV2\nfrom keras.applications.vgg16 import VGG16\nfrom keras.applications.nasnet import NASNetMobile\n\n\nfrom keras.callbacks import ModelCheckpoint,EarlyStopping,CSVLogger,ReduceLROnPlateau\n\nimport matplotlib.pyplot as plt\n\nimport os\nprint(os.listdir(\"../input\"))\n\ndef append_ext(fn):\n    return fn+\".png\"\n\ndef remove_ext(fn):\n    return fn[:-4]","execution_count":1,"outputs":[{"output_type":"stream","text":"Using TensorFlow backend.\n","name":"stderr"},{"output_type":"stream","text":"['inceptionresnetv2', 'imet-2019-fgvc6', 'vgg19']\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"In order to compare the performances of models, it is important to seed everything. This means random and numpy, but also tensorflow and Keras. The following code was taken from [this article](https://towardsdatascience.com/properly-setting-the-random-seed-in-machine-learning-experiments-7da298d1320b) from Cecelia Shao. The article is worth a read for a more in depth look of the effects of correctly seeding."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Set a seed value\nseed_value= 7 \n\n# 1. Set `PYTHONHASHSEED` environment variable at a fixed value\nos.environ['PYTHONHASHSEED']=str(seed_value)\n# 2. Set `python` built-in pseudo-random generator at a fixed value\nrandom.seed(seed_value)\n# 3. Set `numpy` pseudo-random generator at a fixed value\nnp.random.seed(seed_value)\n# 4. Set `tensorflow` pseudo-random generator at a fixed value\ntf.set_random_seed(seed_value)\n# 5 Configure a new global `tensorflow` session\nsession_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)\nsess = tf.Session(graph=tf.get_default_graph(), config=session_conf)\nK.set_session(sess)","execution_count":2,"outputs":[]},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"train_labels=pd.read_csv('../input/imet-2019-fgvc6/train.csv', dtype=str)\n#Changing the attribute ids into lists instead of str seperated by a ' ' to be able to count them\ntrain_labels['attribute_ids']=train_labels['attribute_ids'].str.split(' ')\ntrain_labels[\"id\"]=train_labels[\"id\"].apply(append_ext)\n\ntest_labels=pd.read_csv('../input/imet-2019-fgvc6/sample_submission.csv', dtype=str)\ntest_labels[\"id\"]=test_labels[\"id\"].apply(append_ext)\n\nprint('train : \\n', train_labels.head())\nprint('\\ntest : \\n', test_labels.head())\n\nprint('\\ntrain shape: ', len(train_labels))\nprint('\\ntest shape: ', len(test_labels))","execution_count":3,"outputs":[{"output_type":"stream","text":"train : \n                      id              attribute_ids\n0  1000483014d91860.png            [147, 616, 813]\n1  1000fe2e667721fe.png        [51, 616, 734, 813]\n2  1001614cb89646ee.png                      [776]\n3  10041eb49b297c08.png  [51, 671, 698, 813, 1092]\n4  100501c227f8beea.png  [13, 404, 492, 903, 1093]\n\ntest : \n                      id attribute_ids\n0  10023b2cc4ed5f68.png         0 1 2\n1  100fbe75ed8fd887.png         0 1 2\n2  101b627524a04f19.png         0 1 2\n3  10234480c41284c6.png         0 1 2\n4  1023b0e2636dcea8.png         0 1 2\n\ntrain shape:  109237\n\ntest shape:  7443\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"labels = pd.read_csv('../input/imet-2019-fgvc6/labels.csv', dtype=str)\nprint('labels : ', '\\n', labels.head())\n\nprint('\\nlabels len :', len(labels))","execution_count":4,"outputs":[{"output_type":"stream","text":"labels :  \n   attribute_id          attribute_name\n0            0        culture::abruzzi\n1            1     culture::achaemenid\n2            2         culture::aegean\n3            3         culture::afghan\n4            4  culture::after british\n\nlabels len : 1103\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"datagen=ImageDataGenerator(rescale=1./255.,validation_split=0.2)","execution_count":5,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"B_size = 128\nTarget_size = (96,96) \n\ntrain_generator=datagen.flow_from_dataframe(\n                                            dataframe=train_labels,\n                                            directory=\"../input/imet-2019-fgvc6/train/\",\n                                            x_col=\"id\",\n                                            y_col=\"attribute_ids\",\n                                            subset=\"training\",\n                                            batch_size=B_size,\n                                            seed=seed_value,\n                                            shuffle=True,\n                                            class_mode=\"categorical\",\n                                            target_size=Target_size\n)\n\nvalid_generator=datagen.flow_from_dataframe(\n                                            dataframe=train_labels,\n                                            directory=\"../input/imet-2019-fgvc6/train/\",\n                                            x_col=\"id\",\n                                            y_col=\"attribute_ids\",\n                                            subset=\"validation\",\n                                            batch_size=B_size,\n                                            seed=seed_value,\n                                            shuffle=True,\n                                            class_mode=\"categorical\",\n                                            target_size=Target_size\n)\n\ntest_datagen=ImageDataGenerator(rescale=1./255.)\n\ntest_generator=test_datagen.flow_from_dataframe(\n                                                dataframe=test_labels,\n                                                directory=\"../input/imet-2019-fgvc6/test/\",\n                                                x_col=\"id\",\n                                                y_col=None,\n                                                batch_size=B_size,\n                                                seed=seed_value,\n                                                shuffle=False,\n                                                class_mode=None,\n                                                target_size=Target_size\n)","execution_count":6,"outputs":[{"output_type":"stream","text":"Found 87390 images belonging to 1103 classes.\nFound 21847 images belonging to 1103 classes.\nFound 7443 images.\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_generator.n//train_generator.batch_size","execution_count":7,"outputs":[{"output_type":"execute_result","execution_count":7,"data":{"text/plain":"682"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"focal loss taken from [this Kernel from KeepLearning](https://www.kaggle.com/mathormad/resnet50-v2-keras-focal-loss-mix-up)"},{"metadata":{"trusted":true},"cell_type":"code","source":"gamma = 2.0\nepsilon = K.epsilon()\ndef focal_loss(y_true, y_pred):\n    pt = y_pred * y_true + (1-y_pred) * (1-y_true)\n    pt = K.clip(pt, epsilon, 1-epsilon)\n    CE = -K.log(pt)\n    FL = K.pow(1-pt, gamma) * CE\n    loss = K.sum(FL, axis=1)\n    return loss","execution_count":8,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"f2_score taken from [this Kernel from Alexander Teplyuk](https://www.kaggle.com/ateplyuk/keras-starter)"},{"metadata":{"trusted":true},"cell_type":"code","source":"def f2_score(y_true, y_pred):\n    beta = 2\n    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)), axis=1)\n    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)), axis=1)\n    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)), axis=1)\n    \n    precision = true_positives / (predicted_positives + K.epsilon())\n    recall = true_positives / (possible_positives + K.epsilon())\n    \n    return K.mean(((1+beta**2)*precision*recall) / ((beta**2)*precision+recall+K.epsilon()))","execution_count":9,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Callbacks\n\ncheckpoint = ModelCheckpoint(filepath='weights_test.hdf5',\n                             monitor='val_loss',\n                             verbose=1,\n                             save_best_only=True)\n\nearlystop = EarlyStopping(monitor='val_loss',\n                          min_delta=0,\n                          patience=3,\n                          mode='auto')","execution_count":10,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def make_model(model_choice, model_name, input_tensor, weights_link, nb_epoch):\n    '''Function to create a model\n    Input:\n    - model_choice          for ex: VGG19(include_top=False, input_tensor=input_tensor)\n    - model_name            (str), name that will be given to the model in tensorboard\n    - input_tensor          Input(width_image, height_image, nb_channels)\n    - weights_link          (str) since no internet, link to the dataset with weights\n    - nb_epoch              (int) number of epoch to train on\n    \n    Output:\n    - model made with keras.model.Model'''\n    \n    base_model = model_choice\n    base_model.load_weights(weights_link)\n    base_model.trainable = False\n    x = base_model(input_tensor)\n    out = Flatten()(x)\n    out = Dense(1103, activation=\"softmax\")(out)\n    model = Model(input_tensor, out)\n    \n    model.compile(optimizer=Adam(0.001), loss=focal_loss, metrics=[f2_score])\n    model.summary()\n    \n    history = model.fit_generator(generator=train_generator,\n                    steps_per_epoch=STEP_SIZE_TRAIN,\n                    validation_data=valid_generator,\n                    validation_steps=STEP_SIZE_VALID,\n                    epochs=nb_epoch,\n                    callbacks=[checkpoint, earlystop])\n\n    \n    return model, history","execution_count":11,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"STEP_SIZE_TRAIN=train_generator.n//train_generator.batch_size\nSTEP_SIZE_VALID=valid_generator.n//valid_generator.batch_size\nSTEP_SIZE_TEST=test_generator.n//test_generator.batch_size","execution_count":12,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"number_epoch = 15\nwidth, height = Target_size\ninput_tensor = Input((width, height, 3))\n\nweights_link = ('../input/inceptionresnetv2/inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5')\n\n\nInceptionResNetV2_model, history = make_model(InceptionResNetV2(weights=None,\n                                                       include_top=False,\n                                                       input_tensor=input_tensor),\n                                              'InceptionResNetV2',\n                                              input_tensor,\n                                              weights_link,\n                                              nb_epoch = number_epoch)","execution_count":13,"outputs":[{"output_type":"stream","text":"WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nColocations handled automatically by placer.\n_________________________________________________________________\nLayer (type)                 Output Shape              Param #   \n=================================================================\ninput_1 (InputLayer)         (None, 96, 96, 3)         0         \n_________________________________________________________________\ninception_resnet_v2 (Model)  (None, 1, 1, 1536)        54336736  \n_________________________________________________________________\nflatten_1 (Flatten)          (None, 1536)              0         \n_________________________________________________________________\ndense_1 (Dense)              (None, 1103)              1695311   \n=================================================================\nTotal params: 56,032,047\nTrainable params: 1,695,311\nNon-trainable params: 54,336,736\n_________________________________________________________________\nWARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nUse tf.cast instead.\nEpoch 1/15\n682/682 [==============================] - 905s 1s/step - loss: 16.7244 - f2_score: 0.0041 - val_loss: 18.9897 - val_f2_score: 0.0378\n\nEpoch 00001: val_loss improved from inf to 18.98973, saving model to weights_test.hdf5\nEpoch 2/15\n682/682 [==============================] - 871s 1s/step - loss: 14.9791 - f2_score: 0.0083 - val_loss: 19.4110 - val_f2_score: 0.0383\n\nEpoch 00002: val_loss did not improve from 18.98973\nEpoch 3/15\n682/682 [==============================] - 877s 1s/step - loss: 14.2896 - f2_score: 0.0113 - val_loss: 19.7086 - val_f2_score: 0.0339\n\nEpoch 00003: val_loss did not improve from 18.98973\nEpoch 4/15\n682/682 [==============================] - 853s 1s/step - loss: 13.8663 - f2_score: 0.0126 - val_loss: 20.4749 - val_f2_score: 0.0327\n\nEpoch 00004: val_loss did not improve from 18.98973\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"model_name = 'InceptionResNetV2'\n\nfig, ax =plt.subplots(1,2, figsize=(15, 8))\n    \nax[0].plot(history.history['f2_score'])\nax[0].plot(history.history['val_f2_score'])\nax[0].set_title(model_name +  ' Model F2 score')\nax[0].legend([model_name +  ' Training',model_name +  ' Validation'])\n#ax[0].ylabel('F2 score')\n#ax[0].xlabel('epoch')\n    \nax[1].plot(history.history['loss'])\nax[1].plot(history.history['val_loss'])\nax[1].set_title(model_name +  ' Model loss')\nax[1].legend([model_name +  ' Training',model_name +  ' Validation'])\n#ax[1].ylabel('Loss')\n#ax[1].xlabel('epoch')","execution_count":14,"outputs":[{"output_type":"execute_result","execution_count":14,"data":{"text/plain":"<matplotlib.legend.Legend at 0x7f9a83851940>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1080x576 with 2 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_generator.reset()\npred=InceptionResNetV2_model.predict_generator(test_generator,\nsteps=STEP_SIZE_TEST+1,\nverbose=1)","execution_count":15,"outputs":[{"output_type":"stream","text":"59/59 [==============================] - 54s 920ms/step\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"pred is of shape  7443 x 1103: 7443 test examples, and 1103 different labels.\n\nNext step: apply threshold, if over a certain threshold, then consider it as a label. Otherwise, not."},{"metadata":{"trusted":true},"cell_type":"code","source":"max_of_each_img=[]\nfor i in range(len(pred)):\n    max_of_each_img.append(pred[i].max())\nsns.distplot(max_of_each_img)","execution_count":16,"outputs":[{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n","name":"stderr"},{"output_type":"execute_result","execution_count":16,"data":{"text/plain":"<matplotlib.axes._subplots.AxesSubplot at 0x7f9a83425a90>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"threshold_count = 0.03\n\nnb_label_over_thresh_of_each_img=[]\nfor i in range(len(pred)):\n    nb_labels = 0\n    for prediction in range(len(pred[i])):\n        if pred[i][prediction]>=threshold_count:\n            nb_labels+=1\n    nb_label_over_thresh_of_each_img.append(nb_labels)\nsns.distplot(nb_label_over_thresh_of_each_img)\nprint('threshhold used is: ', threshold_count)\nprint('There are {} images without labels'.format(nb_label_over_thresh_of_each_img.count(nb_label_over_thresh_of_each_img==0)))","execution_count":31,"outputs":[{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n","name":"stderr"},{"output_type":"stream","text":"threshhold used is:  0.03\nThere are 171 images without labels\n","name":"stdout"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"import operator\n\nthreshold = 0.03\n\nlabel_for_test_img = []\nfor i in range(len(pred)):\n    #list to store the label number over the threshold\n    label_number={}\n    for prediction in range(len(pred[i])):\n        if pred[i][prediction]>=threshold:\n            label_number[prediction] = prediction\n    sorted_label_number = sorted(label_number.items(), key=operator.itemgetter(1), reverse=True)\n    label_for_test_img.append([i[0] for i in sorted_label_number[:5]])\n#    print('for image {} labels are: {}'.format(i, label_number))\n\nlabel_for_test_img[:10]","execution_count":32,"outputs":[{"output_type":"execute_result","execution_count":32,"data":{"text/plain":"[[962, 809, 129, 121, 97],\n [903, 536, 387, 202, 129],\n [1061, 921, 560, 230, 203],\n [897, 203, 157, 129],\n [1053, 895, 449, 230],\n [997, 988, 897, 209, 157],\n [1051, 897, 739, 560, 209],\n [988, 897, 860, 656, 560],\n [1062, 129, 29],\n [860, 797, 739, 656, 636]]"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"valid_generator.reset()\npred_valid=InceptionResNetV2_model.predict_generator(valid_generator,\n                                   steps=STEP_SIZE_VALID+1,\n                                   verbose=1)","execution_count":33,"outputs":[{"output_type":"stream","text":"171/171 [==============================] - 130s 758ms/step\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"label_for_valid_img = []\nfor i in range(len(pred_valid)):\n    #list to store the label number over the threshold\n    label_number={}\n    for prediction in range(len(pred_valid[i])):\n        if pred_valid[i][prediction]>=threshold:\n            label_number[prediction] = prediction\n    sorted_label_number = sorted(label_number.items(), key=operator.itemgetter(1), reverse=True)\n    label_for_valid_img.append([i[0] for i in sorted_label_number[:5]])\n#    print('for image {} labels are: {}'.format(i, label_number))\n\nlabel_for_valid_img[:10]","execution_count":34,"outputs":[{"output_type":"execute_result","execution_count":34,"data":{"text/plain":"[[921, 536],\n [157],\n [557, 202],\n [997, 988, 897, 820, 157],\n [897, 540, 157],\n [636, 609, 560, 203, 157],\n [962, 927, 609, 308, 230],\n [1054, 860, 687, 656, 202],\n [921, 897, 823, 757, 573],\n [1006, 820, 532, 469, 203]]"},"metadata":{}}]},{"metadata":{"_kg_hide-output":false,"trusted":true},"cell_type":"code","source":"test_labels[\"id\"]=test_labels[\"id\"].apply(remove_ext)","execution_count":35,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_list = pd.Series([list(x) for x in label_for_test_img])\ntest_str = test_list.apply(lambda x: [str(i) for n,i in enumerate(x)])\ntest_str = test_str.apply(lambda l: ' '.join(l))","execution_count":36,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"results=pd.DataFrame({\"id\":test_labels[\"id\"],\n                      \"attribute_ids\":test_str})\nresults.to_csv(\"submission.csv\",index=False)","execution_count":37,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"results.head()","execution_count":38,"outputs":[{"output_type":"execute_result","execution_count":38,"data":{"text/plain":"             id         attribute_ids\n0  10023b2cc4ed    962 809 129 121 97\n1  100fbe75ed8f   903 536 387 202 129\n2  101b627524a0  1061 921 560 230 203\n3  10234480c412       897 203 157 129\n4  1023b0e2636d      1053 895 449 230","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>id</th>\n      <th>attribute_ids</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>10023b2cc4ed</td>\n      <td>962 809 129 121 97</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>100fbe75ed8f</td>\n      <td>903 536 387 202 129</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>101b627524a0</td>\n      <td>1061 921 560 230 203</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>10234480c412</td>\n      <td>897 203 157 129</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1023b0e2636d</td>\n      <td>1053 895 449 230</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.4","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}