MNIST Convolution Neural Network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model: Convolutional Neural Network\n",
    "### Dataset - MNIST\n",
    "\n",
    "Models included: \n",
    "\n",
    "| Model A | Model B   | Model C |\n",
    "| ----- | ---- |\n",
    "|  ReLU | ReLU | ReLU |\n",
    "| 2 Convolution Layers | 2 Convolution Layers | 3 Convolution Layers |\n",
    "| 2 Hidden Layers | 1 Hidden Layers | 3 Hidden Layers | \n",
    "| 91.58% | 95.76% | 96.13 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 0. Necessary Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Necessary imports\n",
    "import torch\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "import torchvision.datasets as dsets\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1. Load Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = dsets.MNIST(root='./MNISTdata',\n",
    "                           train=True,\n",
    "                           transform=transforms.ToTensor(),\n",
    "                           download=True)\n",
    "\n",
    "test_dataset = dsets.MNIST(root='./MNISTdata',\n",
    "                          train=False,\n",
    "                          transform=transforms.ToTensor())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Make Dataset iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "no_iters = 12000\n",
    "no_epochs = no_iters / ( len(train_dataset) / batch_size )\n",
    "no_epochs = int(no_epochs)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model A: 2 Layer CNN along with maxpool downscalling with Batch Normalization + 2 Connected Layers\n",
    "#### Optimizer - SGD + Nesterov Momentum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 2000, Loss: 0.03746171295642853, Train Accuracy: 99.855, Test Accuracy: 99.2\n",
      "Iteration: 4000, Loss: 0.00221843714825809, Train Accuracy: 99.99666666666667, Test Accuracy: 99.26\n",
      "Iteration: 6000, Loss: 0.0008015346247702837, Train Accuracy: 100.0, Test Accuracy: 99.32\n",
      "Iteration: 8000, Loss: 0.00014590263890568167, Train Accuracy: 100.0, Test Accuracy: 99.33\n",
      "Iteration: 10000, Loss: 0.00012578963651321828, Train Accuracy: 100.0, Test Accuracy: 99.34\n",
      "Iteration: 12000, Loss: 9.32502734940499e-05, Train Accuracy: 100.0, Test Accuracy: 99.32\n"
     ]
    }
   ],
   "source": [
    "#### 3. Create Model Class\n",
    "class CNNModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNNModel, self).__init__()\n",
    "        \n",
    "        #Convolution 1\n",
    "        self.cnn1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5, stride=1, padding=2)\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.norm1 = nn.BatchNorm2d(32)\n",
    "        \n",
    "        # Max pool 1\n",
    "        self.maxpool1 = nn.MaxPool2d(kernel_size=2)\n",
    "        \n",
    "        # Convolution 2\n",
    "        self.cnn2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=1, padding=2)\n",
    "        self.relu2 = nn.ReLU()\n",
    "        self.norm2 = nn.BatchNorm2d(64)\n",
    "        \n",
    "        # Max pool 2\n",
    "        self.maxpool2 = nn.MaxPool2d(kernel_size=2)\n",
    "        \n",
    "        #FNN 1\n",
    "        self.fc1 = nn.Linear(64*7*7, 64*7*7)\n",
    "        self.relu3 = nn.ReLU()\n",
    "        \n",
    "        #Linear\n",
    "        self.fc2 = nn.Linear(64*7*7, 10)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        #Convolution 1\n",
    "        out = self.cnn1(x)\n",
    "        out = self.relu1(out)\n",
    "        out = self.norm1(out)\n",
    "        \n",
    "        #Max pool 1\n",
    "        out = self.maxpool1(out)\n",
    "        \n",
    "        #Convolution 2\n",
    "        out = self.cnn2(out)\n",
    "        out = self.relu2(out)\n",
    "        out = self.norm2(out)\n",
    "        \n",
    "        #Max pool 2\n",
    "        out = self.maxpool2(out)\n",
    "        \n",
    "        #Resize\n",
    "        #original size: (100, 64, 7, 7)\n",
    "        #out.size(0): 100\n",
    "        #New out size: (100, 64*7*7)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        \n",
    "        #FNN 1\n",
    "        out = self.fc1(out)\n",
    "        out = self.relu3(out)\n",
    "        \n",
    "        #Linear\n",
    "        out = self.fc2(out)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "#### 4. Instantiate Model Class\n",
    "if torch.cuda.is_available():\n",
    "    model =CNNModel().cuda()\n",
    "else:\n",
    "    model = CNNModel()\n",
    "    \n",
    "#### 5. Instantiate Loss Class\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "#### 6. Instantiate Optimizer Class\n",
    "learning_rate = 0.01\n",
    "moment = 0.9\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum = moment, nesterov = True)\n",
    "\n",
    "#### 7. Train Model\n",
    "iter = 1\n",
    "for epoch in range(no_epochs):\n",
    "    train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "    for i,(images,labels) in enumerate(train_loader):\n",
    "        #Variables\n",
    "        if torch.cuda.is_available():\n",
    "            images = images.cuda()\n",
    "            labels = labels.cuda()\n",
    "            \n",
    "        #Clear Gradient\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        #Outpus\n",
    "        outputs = model(images)\n",
    "        \n",
    "        #Calculate loss: softmax -> cross entropy loss\n",
    "        loss = criterion(outputs, labels)\n",
    "        \n",
    "        #Generate gradients w.r.t. parameters\n",
    "        loss.backward()\n",
    "        \n",
    "        #Update Parameters\n",
    "        optimizer.step()\n",
    "        \n",
    "        iter += 1\n",
    "        if iter %2000 ==0:\n",
    "            #Calculate Accuracy\n",
    "            correct=0\n",
    "            total=0\n",
    "            train_accuracy = 0\n",
    "            test_accuracy = 0\n",
    "            \n",
    "            #Train Accuracy\n",
    "            for images,labels in train_loader:\n",
    "                if torch.cuda.is_available():\n",
    "                    images = images.cuda()\n",
    "                #outputs\n",
    "                outputs = model(images)\n",
    "                \n",
    "                #Get predictions from maximum value\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                \n",
    "                #Total number of labels\n",
    "                total += labels.size(0)\n",
    "                \n",
    "                #Total Correct Labels\n",
    "                if torch.cuda.is_available():\n",
    "                    correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    \n",
    "            train_accuracy = 100 * float(correct) / total\n",
    "            correct=0\n",
    "            total=0\n",
    "            \n",
    "            #Test Accuracy\n",
    "            for images,labels in test_loader:\n",
    "                if torch.cuda.is_available():\n",
    "                    images = images.cuda()\n",
    "                #outputs\n",
    "                outputs = model(images)\n",
    "                \n",
    "                #Get predictions from maximum value\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                \n",
    "                #Total number of labels\n",
    "                total += labels.size(0)\n",
    "                \n",
    "                #Total Correct Labels\n",
    "                if torch.cuda.is_available():\n",
    "                    correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    \n",
    "            test_accuracy = 100 * float(correct) / total\n",
    "            \n",
    "            print('Iteration: {}, Loss: {}, Train Accuracy: {}, Test Accuracy: {}'.format(iter, loss.item(), train_accuracy, test_accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model B: 2 Layer CNN along with maxpool downscalling with Batch Normalization + 1 Connected Layers\n",
    "#### Optimizer - SGD + Nesterov Momentum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 2000, Loss: 0.013690710067749023, Train Accuracy: 99.70166666666667, Test Accuracy: 99.05\n",
      "Iteration: 4000, Loss: 0.0013229942414909601, Train Accuracy: 99.97833333333334, Test Accuracy: 99.13\n",
      "Iteration: 6000, Loss: 0.000182514195330441, Train Accuracy: 100.0, Test Accuracy: 99.21\n",
      "Iteration: 8000, Loss: 0.0003331089101266116, Train Accuracy: 100.0, Test Accuracy: 99.23\n",
      "Iteration: 10000, Loss: 0.00012549399980343878, Train Accuracy: 100.0, Test Accuracy: 99.22\n",
      "Iteration: 12000, Loss: 0.00011435509077273309, Train Accuracy: 100.0, Test Accuracy: 99.23\n"
     ]
    }
   ],
   "source": [
    "#### 3. Create Model Class\n",
    "class CNNModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNNModel, self).__init__()\n",
    "        \n",
    "        #Convolution 1\n",
    "        self.cnn1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5, stride=1, padding=2)\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.norm1 = nn.BatchNorm2d(32)\n",
    "        \n",
    "        # Max pool 1\n",
    "        self.maxpool1 = nn.MaxPool2d(kernel_size=2)\n",
    "        \n",
    "        # Convolution 2\n",
    "        self.cnn2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=1, padding=2)\n",
    "        self.relu2 = nn.ReLU()\n",
    "        self.norm2 = nn.BatchNorm2d(64)\n",
    "        \n",
    "        # Max pool 2\n",
    "        self.maxpool2 = nn.MaxPool2d(kernel_size=2)\n",
    "        \n",
    "        #Linear\n",
    "        self.fc = nn.Linear(64*7*7, 10)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        #Convolution 1\n",
    "        out = self.cnn1(x)\n",
    "        out = self.relu1(out)\n",
    "        out = self.norm1(out)\n",
    "        \n",
    "        #Max pool 1\n",
    "        out = self.maxpool1(out)\n",
    "        \n",
    "        #Convolution 2\n",
    "        out = self.cnn2(out)\n",
    "        out = self.relu2(out)\n",
    "        out = self.norm2(out)\n",
    "        \n",
    "        #Max pool 2\n",
    "        out = self.maxpool2(out)\n",
    "        \n",
    "        #Resize\n",
    "        #original size: (100, 64, 7, 7)\n",
    "        #out.size(0): 100\n",
    "        #New out size: (100, 64*7*7)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        \n",
    "        #Linear\n",
    "        out = self.fc(out)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "#### 4. Instantiate Model Class\n",
    "if torch.cuda.is_available():\n",
    "    model =CNNModel().cuda()\n",
    "else:\n",
    "    model = CNNModel()\n",
    "    \n",
    "#### 5. Instantiate Loss Class\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "#### 6. Instantiate Optimizer Class\n",
    "learning_rate = 0.01\n",
    "moment = 0.9\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum = moment, nesterov = True)\n",
    "\n",
    "#### 7. Train Model\n",
    "iter = 1\n",
    "for epoch in range(no_epochs):\n",
    "    train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "    for i,(images,labels) in enumerate(train_loader):\n",
    "        #Variables\n",
    "        if torch.cuda.is_available():\n",
    "            images = images.cuda()\n",
    "            labels = labels.cuda()\n",
    "            \n",
    "        #Clear Gradient\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        #Outpus\n",
    "        outputs = model(images)\n",
    "        \n",
    "        #Calculate loss: softmax -> cross entropy loss\n",
    "        loss = criterion(outputs, labels)\n",
    "        \n",
    "        #Generate gradients w.r.t. parameters\n",
    "        loss.backward()\n",
    "        \n",
    "        #Update Parameters\n",
    "        optimizer.step()\n",
    "        \n",
    "        iter += 1\n",
    "        if iter %2000 ==0:\n",
    "            #Calculate Accuracy\n",
    "            correct=0\n",
    "            total=0\n",
    "            train_accuracy = 0\n",
    "            test_accuracy = 0\n",
    "            \n",
    "            #Train Accuracy\n",
    "            for images,labels in train_loader:\n",
    "                if torch.cuda.is_available():\n",
    "                    images = images.cuda()\n",
    "                #outputs\n",
    "                outputs = model(images)\n",
    "                \n",
    "                #Get predictions from maximum value\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                \n",
    "                #Total number of labels\n",
    "                total += labels.size(0)\n",
    "                \n",
    "                #Total Correct Labels\n",
    "                if torch.cuda.is_available():\n",
    "                    correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    \n",
    "            train_accuracy = 100 * float(correct) / total\n",
    "            correct=0\n",
    "            total=0\n",
    "            \n",
    "            #Test Accuracy\n",
    "            for images,labels in test_loader:\n",
    "                if torch.cuda.is_available():\n",
    "                    images = images.cuda()\n",
    "                #outputs\n",
    "                outputs = model(images)\n",
    "                \n",
    "                #Get predictions from maximum value\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                \n",
    "                #Total number of labels\n",
    "                total += labels.size(0)\n",
    "                \n",
    "                #Total Correct Labels\n",
    "                if torch.cuda.is_available():\n",
    "                    correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    \n",
    "            test_accuracy = 100 * float(correct) / total\n",
    "            \n",
    "            print('Iteration: {}, Loss: {}, Train Accuracy: {}, Test Accuracy: {}'.format(iter, loss.item(), train_accuracy, test_accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model C: 3 Layer CNN along with maxpool downscalling and Batch Normalization + 2 Connected Layers\n",
    "#### Optimizer - SGD + Nesterov Momentum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 2000, Loss: 0.008390073664486408, Train Accuracy: 99.66, Test Accuracy: 99.25\n",
      "Iteration: 4000, Loss: 0.003684034338220954, Train Accuracy: 99.94833333333334, Test Accuracy: 99.26\n",
      "Iteration: 6000, Loss: 0.00016717911057639867, Train Accuracy: 99.99833333333333, Test Accuracy: 99.37\n",
      "Iteration: 8000, Loss: 0.00014894484775140882, Train Accuracy: 100.0, Test Accuracy: 99.33\n",
      "Iteration: 10000, Loss: 0.00033684729714877903, Train Accuracy: 100.0, Test Accuracy: 99.37\n",
      "Iteration: 12000, Loss: 7.460594497388229e-05, Train Accuracy: 100.0, Test Accuracy: 99.35\n"
     ]
    }
   ],
   "source": [
    "#### 3. Create Model Class\n",
    "class CNNModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNNModel, self).__init__()\n",
    "        \n",
    "        #Convolution 1\n",
    "        self.cnn1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.norm1 = nn.BatchNorm2d(16)\n",
    "        \n",
    "        # Max pool 1\n",
    "        self.maxpool1 = nn.MaxPool2d(kernel_size=2,stride=1)\n",
    "        \n",
    "        # Convolution 2\n",
    "        self.cnn2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)\n",
    "        self.relu2 = nn.ReLU()\n",
    "        self.norm2 = nn.BatchNorm2d(32)\n",
    "        \n",
    "        # Max pool 2\n",
    "        self.maxpool2 = nn.MaxPool2d(kernel_size=2)\n",
    "        \n",
    "        #Convolution 3\n",
    "        self.cnn3 = nn.Conv2d(in_channels=32,out_channels=64, kernel_size=3,stride=1,padding=1)\n",
    "        self.relu3 = nn.ReLU()\n",
    "        self.norm3 = nn.BatchNorm2d(64)\n",
    "        \n",
    "        #Max pool 3\n",
    "        self.maxpool3=nn.MaxPool2d(kernel_size=2)\n",
    "\n",
    "        #FNN 1\n",
    "        self.fc1 = nn.Linear(64*6*6, 64*6*6)\n",
    "        self.relu4 = nn.ReLU()\n",
    "        \n",
    "        #Linear\n",
    "        self.fc2 = nn.Linear(64*6*6, 10)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        #Convolution 1\n",
    "        out = self.cnn1(x)\n",
    "        out = self.relu1(out)\n",
    "        out = self.norm1(out)\n",
    "        \n",
    "        #Max pool 1\n",
    "        out = self.maxpool1(out)\n",
    "        \n",
    "        #Convolution 2\n",
    "        out = self.cnn2(out)\n",
    "        out = self.relu2(out)\n",
    "        out = self.norm2(out)\n",
    "        \n",
    "        #Max pool 2\n",
    "        out = self.maxpool2(out)\n",
    "        \n",
    "        #Convolution 3\n",
    "        out = self.cnn3(out)\n",
    "        out = self.relu3(out)\n",
    "        out = self.norm3(out)\n",
    "        \n",
    "        #Max pool 3\n",
    "        out = self.maxpool3(out)\n",
    "        \n",
    "        #Resize\n",
    "        #original size: (100, 64, 6, 6)\n",
    "        #out.size(0): 100\n",
    "        #New out size: (100, 64*6*6)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        #FNN 1\n",
    "        out = self.fc1(out)\n",
    "        out = self.relu4(out)\n",
    "        \n",
    "        #Linear\n",
    "        out = self.fc2(out)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "#### 4. Instantiate Model Class\n",
    "if torch.cuda.is_available():\n",
    "    model =CNNModel().cuda()\n",
    "else:\n",
    "    model = CNNModel()\n",
    "    \n",
    "#### 5. Instantiate Loss Class\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "#### 6. Instantiate Optimizer Class\n",
    "learning_rate = 0.01\n",
    "moment = 0.9\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum = moment, nesterov = True)\n",
    "\n",
    "#### 7. Train Model\n",
    "iter = 1\n",
    "for epoch in range(no_epochs):\n",
    "    train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "    for i,(images,labels) in enumerate(train_loader):\n",
    "        #Variables\n",
    "        if torch.cuda.is_available():\n",
    "            images = images.cuda()\n",
    "            labels = labels.cuda()\n",
    "            \n",
    "        #Clear Gradient\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        #Outpus\n",
    "        outputs = model(images)\n",
    "        \n",
    "        #Calculate loss: softmax -> cross entropy loss\n",
    "        loss = criterion(outputs, labels)\n",
    "        \n",
    "        #Generate gradients w.r.t. parameters\n",
    "        loss.backward()\n",
    "        \n",
    "        #Update Parameters\n",
    "        optimizer.step()\n",
    "        \n",
    "        iter += 1\n",
    "        if iter %2000 ==0:\n",
    "            #Calculate Accuracy\n",
    "            correct=0\n",
    "            total=0\n",
    "            train_accuracy = 0\n",
    "            test_accuracy = 0\n",
    "            \n",
    "            #Train Accuracy\n",
    "            for images,labels in train_loader:\n",
    "                if torch.cuda.is_available():\n",
    "                    images = images.cuda()\n",
    "                #outputs\n",
    "                outputs = model(images)\n",
    "                \n",
    "                #Get predictions from maximum value\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                \n",
    "                #Total number of labels\n",
    "                total += labels.size(0)\n",
    "                \n",
    "                #Total Correct Labels\n",
    "                if torch.cuda.is_available():\n",
    "                    correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    \n",
    "            train_accuracy = 100 * float(correct) / total\n",
    "            correct=0\n",
    "            total=0\n",
    "            \n",
    "            #Test Accuracy\n",
    "            for images,labels in test_loader:\n",
    "                if torch.cuda.is_available():\n",
    "                    images = images.cuda()\n",
    "                #outputs\n",
    "                outputs = model(images)\n",
    "                \n",
    "                #Get predictions from maximum value\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                \n",
    "                #Total number of labels\n",
    "                total += labels.size(0)\n",
    "                \n",
    "                #Total Correct Labels\n",
    "                if torch.cuda.is_available():\n",
    "                    correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    \n",
    "            test_accuracy = 100 * float(correct) / total\n",
    "            \n",
    "            print('Iteration: {}, Loss: {}, Train Accuracy: {}, Test Accuracy: {}'.format(iter, loss.item(), train_accuracy, test_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}