diff --git a/TransferImplementation.ipynb b/TransferImplementation.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..eb8a29e16f94703a2f91a5a6b05eb41249343f15
--- /dev/null
+++ b/TransferImplementation.ipynb
@@ -0,0 +1,504 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Imports\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import PIL as pillow # used for image resizing\n",
+    "import random\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Dropout, Flatten\n",
+    "from tensorflow.keras.layers import Conv2D\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "from tensorflow.keras.optimizers import RMSprop\n",
+    "from tensorflow.keras.optimizers import Adadelta\n",
+    "from tensorflow.keras.layers import MaxPooling2D\n",
+    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "from tensorflow.keras.regularizers import l2\n",
+    "import shutil"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.5.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(tf.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Data Pre-processing function declared here\n",
+    "\n",
+    "def make_train_test_files(input_folder, tag):\n",
+    "    #Make the training and testing paths\n",
+    "    os.mkdir(str(train_path + \"\\\\\" + tag)) \n",
+    "    os.mkdir(str(test_path + \"\\\\\" + tag))\n",
+    "    train_count = 0\n",
+    "    test_count = 0\n",
+    "    test_flag = 0\n",
+    "    # Get all the files and shuffle them for random selections of training and testing\n",
+    "    all_files = os.listdir(input_folder)\n",
+    "    random.shuffle(all_files)\n",
+    "    if len(all_files) < (train_size + test_size): # Going to need to augment some files\n",
+    "        augment_count = (train_size + test_size) - len(all_files) # number needed to augment\n",
+    "        for filename in all_files:\n",
+    "            if test_flag == 0:\n",
+    "                if (os.path.getsize(input_folder+ \"\\\\\" + filename) < 7115): # Removes any of the files smaller than 7kb, junk files\n",
+    "                    continue\n",
+    "                image = pillow.Image.open(input_folder+ \"\\\\\" + filename)\n",
+    "                if train_count < augment_count: \n",
+    "                    image2 = image\n",
+    "                    rand = random.randint(-90, 90)\n",
+    "                    image2 = image2.rotate(rand)\n",
+    "                    rand2 = random.randint(0,1)\n",
+    "                    if rand2 == 1:\n",
+    "                        image2 = image2.transpose(pillow.Image.FLIP_LEFT_RIGHT)\n",
+    "                    else:\n",
+    "                        pass\n",
+    "                    image2 = image2.resize(dimensions)\n",
+    "                    image2.save(train_path + \"\\\\\" + tag + \"\\\\\" + \"aug\" + filename)\n",
+    "                    train_count = train_count + 1\n",
+    "                image = image.resize(dimensions)\n",
+    "                image.save(train_path + \"\\\\\" + tag + \"\\\\\" + filename)\n",
+    "                train_count = train_count + 1\n",
+    "                if train_count == train_size: # got enough training files\n",
+    "                    test_flag = 1\n",
+    "            else:\n",
+    "                if (os.path.getsize(input_folder+ \"\\\\\" + filename) < 7115): # Removes any of the files smaller than 7kb, junk files\n",
+    "                    continue # stops the loop and moves on to next file without altering the training count \n",
+    "                image = pillow.Image.open(input_folder+ \"\\\\\" + filename)\n",
+    "                image = image.resize(dimensions)\n",
+    "                image.save(test_path + \"\\\\\" + tag + \"\\\\\" + filename)\n",
+    "                del image\n",
+    "                test_count = test_count+1\n",
+    "                if test_count == test_size: # got enough training files\n",
+    "                    return\n",
+    "    # No need to augment files\n",
+    "    else:\n",
+    "        for filename in all_files: # Get the files\n",
+    "            if test_flag == 0:\n",
+    "                if (os.path.getsize(input_folder+ \"\\\\\" + filename) < 7115): # Removes any of the files smaller than 7kb, junk files\n",
+    "                    continue # stops the loop and moves on to next file without altering the training count \n",
+    "                image = pillow.Image.open(input_folder+ \"\\\\\" + filename)\n",
+    "                image = image.resize(dimensions)\n",
+    "                image.save(train_path + \"\\\\\" + tag + \"\\\\\" + filename)\n",
+    "                del image\n",
+    "                train_count = train_count+1\n",
+    "                if train_count == train_size: # got enough training files\n",
+    "                    test_flag = 1\n",
+    "            else:\n",
+    "                if (os.path.getsize(input_folder+ \"\\\\\" + filename) < 7115): # Removes any of the files smaller than 7kb, junk files\n",
+    "                    continue # stops the loop and moves on to next file without altering the training count \n",
+    "                image = pillow.Image.open(input_folder+ \"\\\\\" + filename)\n",
+    "                image = image.resize(dimensions)\n",
+    "                image.save(test_path + \"\\\\\" + tag + \"\\\\\" + filename)\n",
+    "                del image\n",
+    "                test_count = test_count+1\n",
+    "                if test_count == test_size: # got enough training files\n",
+    "                    return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import the data / Preprocess via the function \n",
+    "\n",
+    "# For result replication purposes uncomment the line below and pick a suitable seed\n",
+    "#random.seed(42) \n",
+    "\n",
+    "# These are the parameters to alter: number of training/testing sample, \n",
+    "#     the paths defined for Training and Testing\n",
+    "#     and the dimension all images are resized to\n",
+    "# Images are resized for consistency across all images\n",
+    "path = \"Flickr\" #Folder directory, if you unzip the Flickr.tar get the 'Flickr/Flickr', just change the value of path. \n",
+    "train_size = 1200\n",
+    "test_size = 300\n",
+    "batchsize = 32\n",
+    "dimensions = (450,450)\n",
+    "train_path = \"Flickr\\\\train\\\\\"\n",
+    "test_path = \"Flickr\\\\test\\\\\"\n",
+    "\n",
+    "\n",
+    "# Only uncomment below if you don't have data sorted already\n",
+    "\n",
+    "# Create training and testing folders\n",
+    "all_folders= os.listdir(path)\n",
+    "if \"train\" in all_folders:\n",
+    "   shutil.rmtree(str(path+\"\\\\\"+\"train\"))\n",
+    "   os.mkdir(str(path+\"\\\\\"+\"train\"))\n",
+    "else:\n",
+    "   os.mkdir(str(path+\"\\\\\"+\"train\"))\n",
+    "   \n",
+    "if \"test\" in all_folders:\n",
+    "   shutil.rmtree(str(path+\"\\\\\"+\"test\"))\n",
+    "   os.mkdir(str(path+\"\\\\\"+\"test\"))\n",
+    "else:\n",
+    "   os.mkdir(str(path+\"\\\\\"+\"test\"))\n",
+    "\n",
+    "#Populate the Training and Testing Folders\n",
+    "make_train_test_files(\"Flickr\\\\amusement\",\"amusement\")    \n",
+    "make_train_test_files(\"Flickr\\\\anger\",\"anger\")  \n",
+    "make_train_test_files(\"Flickr\\\\awe\",\"awe\")  \n",
+    "make_train_test_files(\"Flickr\\\\contentment\",\"contentment\")  \n",
+    "make_train_test_files(\"Flickr\\\\disgust\",\"disgust\")  \n",
+    "make_train_test_files(\"Flickr\\\\excitement\",\"excitement\")  \n",
+    "make_train_test_files(\"Flickr\\\\fear\",\"fear\")  \n",
+    "make_train_test_files(\"Flickr\\\\sadness\",\"sadness\")  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 7680 images belonging to 8 classes.\n",
+      "Found 1920 images belonging to 8 classes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This is the code to bring the images into the system ready for Keras\n",
+    "train_datagen = ImageDataGenerator(rescale=1./255, validation_split=0.20,\n",
+    "                                   #rotation_range=90,\n",
+    "                                   #horizontal_flip=True,\n",
+    "                                   #preprocessing_function=tf.keras.applications.mobilenet_v2.preprocess_input\n",
+    "                                  )\n",
+    "test_datagen = ImageDataGenerator(rescale=1./255)\n",
+    "\n",
+    "train_generator = train_datagen.flow_from_directory(\n",
+    "        train_path,\n",
+    "        target_size=(128,128),\n",
+    "        batch_size=32,\n",
+    "        color_mode=\"rgb\",\n",
+    "        class_mode='categorical',\n",
+    "        subset=\"training\",\n",
+    "        shuffle=True)\n",
+    "\n",
+    "valid_generator = train_datagen.flow_from_directory(\n",
+    "        train_path,\n",
+    "        target_size=(128,128),\n",
+    "        batch_size=32,\n",
+    "        color_mode=\"rgb\",\n",
+    "        class_mode='categorical',\n",
+    "        subset=\"validation\",\n",
+    "        shuffle=True)\n",
+    "\n",
+    "# test_generator = test_datagen.flow_from_directory(\n",
+    "#         test_path,\n",
+    "#         target_size=(128,128),\n",
+    "#         batch_size=32,\n",
+    "#         color_mode=\"rgb\",\n",
+    "#         class_mode='categorical',\n",
+    "#         shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Generating class weights to address data imbalance\n",
+    "\n",
+    "from sklearn.utils import class_weight\n",
+    "import numpy as np\n",
+    "\n",
+    "class_weights = class_weight.compute_class_weight(\n",
+    "               'balanced',\n",
+    "                np.unique(train_generator.classes), \n",
+    "                train_generator.classes)\n",
+    "\n",
+    "\n",
+    "train_class_weights = dict(enumerate(class_weights))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "mobilenetv2_1.00_128 (Functi (None, 4, 4, 1280)        2257984   \n",
+      "_________________________________________________________________\n",
+      "flatten (Flatten)            (None, 20480)             0         \n",
+      "_________________________________________________________________\n",
+      "dropout (Dropout)            (None, 20480)             0         \n",
+      "_________________________________________________________________\n",
+      "dense (Dense)                (None, 8)                 163848    \n",
+      "=================================================================\n",
+      "Total params: 2,421,832\n",
+      "Trainable params: 163,848\n",
+      "Non-trainable params: 2,257,984\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Initialise the pretrained model (Using Google's MobileNetV2)\n",
+    "pre_model = tf.keras.applications.MobileNetV2(input_shape=(128,128,3), include_top=False)\n",
+    "pre_model.trainable = False\n",
+    "\n",
+    "#Build our output layers on top of premodel (Need to experiment here)\n",
+    "emotion_model = Sequential([\n",
+    "    pre_model,\n",
+    "    #Conv2D(128, kernel_size=(3, 3), activation='relu',padding=\"valid\"),\n",
+    "    #MaxPooling2D(pool_size=(2, 2)),\n",
+    "    Flatten(),\n",
+    "    Dropout(0.5),\n",
+    "    Dense(8, activation='softmax')    \n",
+    "])\n",
+    "\n",
+    "\n",
+    "emotion_model.summary()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\array_ops.py:5049: calling gather (from tensorflow.python.ops.array_ops) with validate_indices is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "The `validate_indices` argument has no effect. Indices are always validated on CPU and never validated on GPU.\n",
+      "Epoch 1/25\n",
+      "240/240 [==============================] - 86s 307ms/step - loss: 4.0341 - accuracy: 0.3835 - val_loss: 3.6838 - val_accuracy: 0.4349\n",
+      "Epoch 2/25\n",
+      "240/240 [==============================] - 26s 109ms/step - loss: 2.7312 - accuracy: 0.5561 - val_loss: 3.8746 - val_accuracy: 0.4583\n",
+      "Epoch 3/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 2.2493 - accuracy: 0.6249 - val_loss: 4.6650 - val_accuracy: 0.4443\n",
+      "Epoch 4/25\n",
+      "240/240 [==============================] - 26s 110ms/step - loss: 1.8778 - accuracy: 0.6845 - val_loss: 4.8091 - val_accuracy: 0.4724\n",
+      "Epoch 5/25\n",
+      "240/240 [==============================] - 26s 107ms/step - loss: 1.7404 - accuracy: 0.7167 - val_loss: 5.3583 - val_accuracy: 0.4469\n",
+      "Epoch 6/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 1.7250 - accuracy: 0.7327 - val_loss: 5.4551 - val_accuracy: 0.4625\n",
+      "Epoch 7/25\n",
+      "240/240 [==============================] - 26s 108ms/step - loss: 1.6337 - accuracy: 0.7467 - val_loss: 6.0630 - val_accuracy: 0.4594\n",
+      "Epoch 8/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 1.4842 - accuracy: 0.7699 - val_loss: 6.1704 - val_accuracy: 0.4620\n",
+      "Epoch 9/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.4982 - accuracy: 0.7801 - val_loss: 6.4620 - val_accuracy: 0.4760\n",
+      "Epoch 10/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.4749 - accuracy: 0.7889 - val_loss: 6.9963 - val_accuracy: 0.4578\n",
+      "Epoch 11/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 1.4524 - accuracy: 0.7908 - val_loss: 7.0023 - val_accuracy: 0.4708\n",
+      "Epoch 12/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.4252 - accuracy: 0.8029 - val_loss: 7.3196 - val_accuracy: 0.4823\n",
+      "Epoch 13/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.4191 - accuracy: 0.8091 - val_loss: 7.8527 - val_accuracy: 0.4599\n",
+      "Epoch 14/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 1.4429 - accuracy: 0.8142 - val_loss: 8.3068 - val_accuracy: 0.4542\n",
+      "Epoch 15/25\n",
+      "240/240 [==============================] - 26s 107ms/step - loss: 1.3260 - accuracy: 0.8247 - val_loss: 8.6177 - val_accuracy: 0.4594\n",
+      "Epoch 16/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.4444 - accuracy: 0.8185 - val_loss: 8.7931 - val_accuracy: 0.4641\n",
+      "Epoch 17/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.3533 - accuracy: 0.8340 - val_loss: 9.1397 - val_accuracy: 0.4630\n",
+      "Epoch 18/25\n",
+      "240/240 [==============================] - 25s 106ms/step - loss: 1.3369 - accuracy: 0.8349 - val_loss: 9.1262 - val_accuracy: 0.4703\n",
+      "Epoch 19/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.3287 - accuracy: 0.8388 - val_loss: 9.8817 - val_accuracy: 0.4453\n",
+      "Epoch 20/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 1.2998 - accuracy: 0.8400 - val_loss: 9.5150 - val_accuracy: 0.4708\n",
+      "Epoch 21/25\n",
+      "240/240 [==============================] - 25s 106ms/step - loss: 1.3181 - accuracy: 0.8467 - val_loss: 9.7863 - val_accuracy: 0.4677\n",
+      "Epoch 22/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.4200 - accuracy: 0.8398 - val_loss: 10.2838 - val_accuracy: 0.4547\n",
+      "Epoch 23/25\n",
+      "240/240 [==============================] - 25s 104ms/step - loss: 1.3126 - accuracy: 0.8561 - val_loss: 10.5922 - val_accuracy: 0.4516\n",
+      "Epoch 24/25\n",
+      "240/240 [==============================] - 25s 105ms/step - loss: 1.2734 - accuracy: 0.8562 - val_loss: 10.4151 - val_accuracy: 0.4688\n",
+      "Epoch 25/25\n",
+      "240/240 [==============================] - 25s 106ms/step - loss: 1.3459 - accuracy: 0.8548 - val_loss: 10.9238 - val_accuracy: 0.4682\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Model Training here\n",
+    "STEP_SIZE_TRAIN=train_generator.n//train_generator.batch_size\n",
+    "STEP_SIZE_VALID=valid_generator.n//valid_generator.batch_size\n",
+    "emotion_model.compile(loss='categorical_crossentropy',optimizer=Adam(learning_rate=0.001, decay=1e-6),metrics=['accuracy'])\n",
+    "model_info = emotion_model.fit(\n",
+    "        train_generator,\n",
+    "        steps_per_epoch=STEP_SIZE_TRAIN,\n",
+    "        epochs=25,\n",
+    "        validation_data=valid_generator,\n",
+    "        validation_steps=STEP_SIZE_VALID,\n",
+    "        class_weight = train_class_weights\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
+      "In C:\\Users\\Sion\\Anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n",
+      "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Training and validation loss')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Calculate Results and such here\n",
+    "acc = model_info.history['accuracy']\n",
+    "val_acc = model_info.history['val_accuracy']\n",
+    "\n",
+    "# Retrieve a list of list results on training and validation data\n",
+    "# sets for each training epoch\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "loss = model_info.history['loss']\n",
+    "val_loss = model_info.history['val_loss']\n",
+    "\n",
+    "# Get number of epochs\n",
+    "epochs = range(len(loss))\n",
+    "\n",
+    "# Plot training and validation accuracy per epoch\n",
+    "plt.plot(epochs, acc)\n",
+    "plt.plot(epochs, val_acc)\n",
+    "plt.title('Training and validation accuracy')\n",
+    "\n",
+    "plt.figure()\n",
+    "\n",
+    "# Plot training and validation loss per epoch\n",
+    "plt.plot(epochs, loss)\n",
+    "plt.plot(epochs, val_loss)\n",
+    "plt.title('Training and validation loss')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Maybe add a random testing thing here about the darkness of an image with likelihood of fear being picked"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#save the model\n",
+    "# emotion_model.save('model.h5')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}