Pytorch Concepts(Neural Networks).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing pakages\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "import numpy as np\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import helper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "#we will use the torchvision package for downloading the mnist dataset\n",
    "from torchvision import datasets,transforms\n",
    "#we use transforms to normalize the data\n",
    "transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])\n",
    "#mean 0.5 and std dev 0.5 for the image to normalize\n",
    "trainset = datasets.MNIST('~/.pytorch/MNIST_data',download=True,train=True,transform = transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset,batch_size=64,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torch.Tensor'>\n",
      "torch.Size([64, 1, 28, 28])\n",
      "torch.Size([64])\n"
     ]
    }
   ],
   "source": [
    "dataiter = iter(trainloader)\n",
    "images,labels = dataiter.next()\n",
    "print(type(images))\n",
    "print(images.shape)\n",
    "print(labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f1e27874ac8>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e278d4a90>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 253
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(images[1].numpy().squeeze(),cmap='Greys_r')\n",
    "#squeeze returns a tensor of dimension of input of size 1 removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#defining the activation function\n",
    "def sigmoid(x):\n",
    "    return 1/(1+torch.exp(-x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 1, 28, 28])\n",
      "torch.Size([64, 784])\n",
      "torch.Size([64, 784])\n"
     ]
    }
   ],
   "source": [
    "#previous shape of images\n",
    "print(images.shape)\n",
    "#flattining the input\n",
    "inputs = images.view(images.shape[0],-1)\n",
    "#we can also write 784 insted of -1\n",
    "inputs_a = images.view(images.shape[0],784)\n",
    "print(inputs.shape)\n",
    "print(inputs_a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making the basic network\n",
    "#layer 1\n",
    "w1 = torch.randn((784,256))\n",
    "b1 = torch.randn((256))\n",
    "#layer 2\n",
    "w2 = torch.randn((256,10))\n",
    "b2 = torch.randn((10))\n",
    "#defining the hidden layer\n",
    "h = sigmoid(torch.mm(inputs,w1)+b1)\n",
    "#defining the output layer\n",
    "out = torch.mm(h,w2)+b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#as the network in not trained so in the output the class probability of all the classes is same\n",
    "#out_cov = out.type(torch.IntTensor)\n",
    "#code to convert the type of tensor \n",
    "#torch.sum(torch.exp(out),dim=1).view(-1,1)\n",
    "#this view(-1,1) convert a row to a column tensor and a column tensor to a row tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(out_cov[0])\n",
    "# we can apply softmax and get the probability\n",
    "#dim=1 sum accross columns\n",
    "#as our result is accross columns we need to sum across columns\n",
    "def softmax(x):\n",
    "    return torch.exp(x)/torch.sum(torch.exp(x),dim=1).view(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 10])\n",
      "tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
      "        1.0000])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Container object of 10 artists>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e26ebcac8>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 373
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "probabilities = softmax(out)\n",
    "print(probabilities.shape)\n",
    "print(probabilities.sum(dim=1))\n",
    "# we got all one as the probabilities all sum to one\n",
    "# we can plot the distribution and get the more or less same distribution as the model is not trained\n",
    "#now without doing the sum we can alos see the uniform distribution\n",
    "#print(probabilities[0])\n",
    "#u = probabilities[0]\n",
    "graph_pro = torch.sum(probabilities,dim=0)/64\n",
    "plt.bar([0,1,2,3,4,5,6,7,8,9],graph_pro.numpy().squeeze())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "#there are multiple methods to build a nureal network in pytorch \n",
    "#frist method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import nn\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        #defining the hidden layer\n",
    "        self.hidden = nn.Linear(784,256)\n",
    "        #defining the output layer\n",
    "        self.output = nn.Linear(256,10)\n",
    "        #defining the activation layer\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        #we need to find softmax accross columns\n",
    "        self.softmax = nn.Softmax(dim=1)\n",
    "    #must have this method\n",
    "    #order in init is not important \n",
    "    #order in forward method is important\n",
    "    def forward(self,x):\n",
    "        #passing the input tensor to the expression\n",
    "        x = self.hidden(x)\n",
    "        x = self.sigmoid(x)\n",
    "        x = self.output(x)\n",
    "        x = self.softmax(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Network(\n",
       "  (hidden): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (output): Linear(in_features=256, out_features=10, bias=True)\n",
       "  (sigmoid): Sigmoid()\n",
       "  (softmax): Softmax()\n",
       ")"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Network()\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can define model more consisely by functional module of pytorch\n",
    "import torch.nn.functional as F\n",
    "class Network(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        #hidden layer defining \n",
    "        self.hidden = nn.Linear(784,256)\n",
    "        #output layer\n",
    "        self.output = nn.Linear(256,10)\n",
    "    def forward(self,x):\n",
    "        #applying the sigmoid activation\n",
    "        x = F.sigmoid(self.hidden(x))\n",
    "        #output layer with softmax activation\n",
    "        x = F.softmax(self.output(x),dim=1)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Network(\n",
       "  (hidden): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (output): Linear(in_features=256, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier = Network()\n",
    "classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Network(\n",
       "  (fc1): Linear(in_features=784, out_features=128, bias=True)\n",
       "  (fc2): Linear(in_features=128, out_features=64, bias=True)\n",
       "  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#MultiLayer Perceptron\n",
    "class Network(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        #defining hidden layers\n",
    "        self.fc1=nn.Linear(784,128)\n",
    "        self.fc2=nn.Linear(128,64)\n",
    "        #Output layer\n",
    "        self.fc3=nn.Linear(64,10)\n",
    "    def forward(self,x):\n",
    "        x=self.fc1(x)\n",
    "        x=F.relu(x)\n",
    "        x=self.fc2(x)\n",
    "        x=F.relu(x)\n",
    "        x=self.fc3(x)\n",
    "        x=F.softmax(x,dim=1)\n",
    "        \n",
    "        return x\n",
    "model = Network()\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter containing:\n",
      "tensor([[ 0.0278, -0.0242,  0.0052,  ..., -0.0252,  0.0005, -0.0161],\n",
      "        [-0.0221,  0.0215,  0.0080,  ..., -0.0253,  0.0212,  0.0251],\n",
      "        [-0.0182,  0.0019, -0.0293,  ..., -0.0247,  0.0032, -0.0034],\n",
      "        ...,\n",
      "        [-0.0081, -0.0146,  0.0265,  ..., -0.0032, -0.0127,  0.0293],\n",
      "        [-0.0156, -0.0093, -0.0155,  ..., -0.0281,  0.0203,  0.0323],\n",
      "        [ 0.0234,  0.0144, -0.0232,  ..., -0.0222, -0.0337,  0.0155]],\n",
      "       requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([-0.0103,  0.0143, -0.0243,  0.0297, -0.0292, -0.0173,  0.0216, -0.0142,\n",
      "         0.0332, -0.0071, -0.0051,  0.0099, -0.0290, -0.0277,  0.0118, -0.0112,\n",
      "        -0.0159, -0.0353, -0.0014,  0.0285,  0.0335, -0.0103, -0.0242, -0.0179,\n",
      "        -0.0305,  0.0053, -0.0026,  0.0104,  0.0282, -0.0084, -0.0356, -0.0098,\n",
      "        -0.0002,  0.0197,  0.0214, -0.0210,  0.0022, -0.0060,  0.0219,  0.0123,\n",
      "        -0.0307, -0.0017, -0.0129,  0.0313, -0.0152, -0.0026, -0.0246, -0.0184,\n",
      "        -0.0329,  0.0221,  0.0159,  0.0028, -0.0328,  0.0318,  0.0274,  0.0329,\n",
      "        -0.0088,  0.0179, -0.0201,  0.0167, -0.0319, -0.0283, -0.0198, -0.0284,\n",
      "         0.0265, -0.0049, -0.0002,  0.0126,  0.0074, -0.0084,  0.0031, -0.0310,\n",
      "         0.0195, -0.0115,  0.0197, -0.0259, -0.0348,  0.0194,  0.0150,  0.0157,\n",
      "         0.0197, -0.0236, -0.0076,  0.0069,  0.0005, -0.0257, -0.0290,  0.0307,\n",
      "         0.0264, -0.0143,  0.0212,  0.0047,  0.0217,  0.0242, -0.0152,  0.0257,\n",
      "         0.0015, -0.0070,  0.0010, -0.0219, -0.0086,  0.0304,  0.0220,  0.0144,\n",
      "        -0.0033, -0.0149,  0.0300, -0.0030,  0.0175, -0.0115,  0.0169,  0.0296,\n",
      "        -0.0181,  0.0310, -0.0120,  0.0231, -0.0324, -0.0261,  0.0108, -0.0135,\n",
      "        -0.0327, -0.0294,  0.0317, -0.0150,  0.0078,  0.0191,  0.0087, -0.0109],\n",
      "       requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "#initializing weights and biases\n",
    "#as the weigths and biases are initialized randomly\n",
    "print(model.fc1.weight)\n",
    "print(model.fc1.bias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can also fill the data randomly\n",
    "model.fc1.bias.data.fill_(0)\n",
    "#_ inplace operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0097,  0.0168, -0.0140,  ...,  0.0091, -0.0119, -0.0108],\n",
       "        [ 0.0049,  0.0071, -0.0100,  ...,  0.0113,  0.0190,  0.0037],\n",
       "        [ 0.0058, -0.0004, -0.0097,  ...,  0.0048,  0.0093, -0.0105],\n",
       "        ...,\n",
       "        [ 0.0118, -0.0041,  0.0018,  ...,  0.0062, -0.0206, -0.0042],\n",
       "        [ 0.0098, -0.0013,  0.0157,  ..., -0.0076,  0.0008, -0.0035],\n",
       "        [ 0.0124,  0.0026, -0.0082,  ...,  0.0029,  0.0014,  0.0070]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sample from random normal with standard dev = 0.01\n",
    "model.fc1.weight.data.normal_(std=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e26ec46d8>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 224,
       "width": 423
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#forward pass\n",
    "#grabbing the data\n",
    "dataiter = iter(trainloader)\n",
    "images,labels = dataiter.next()\n",
    "\n",
    "#resizing the whole data\n",
    "images.resize_(64,1,784)\n",
    "\n",
    "#forward pass thru the network\n",
    "img_idx = 0\n",
    "ps = model.forward(images[img_idx,:])\n",
    "\n",
    "img = images[img_idx]\n",
    "#helper is custom made python script to work\n",
    "helper.view_classify(img.view(1,28,28),ps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Linear(in_features=784, out_features=128, bias=True)\n",
      "  (1): ReLU()\n",
      "  (2): Linear(in_features=128, out_features=64, bias=True)\n",
      "  (3): ReLU()\n",
      "  (4): Linear(in_features=64, out_features=10, bias=True)\n",
      "  (5): Softmax()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "#we can use the sequential module of the pytorch so to easily define the model\n",
    "input_size = 784\n",
    "hidden_sizes = [128,64]\n",
    "output_size = 10\n",
    "\n",
    "#feed forward network\n",
    "model = nn.Sequential(nn.Linear(input_size,hidden_sizes[0]),\n",
    "                      nn.ReLU(),\n",
    "                      nn.Linear(hidden_sizes[0],hidden_sizes[1]),\n",
    "                      nn.ReLU(),\n",
    "                      nn.Linear(hidden_sizes[1],output_size),\n",
    "                      nn.Softmax(dim=1))\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e26f68908>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 224,
       "width": 423
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#forward pass thru the network and display output\n",
    "images,labels = next(iter(trainloader))\n",
    "images.resize_(images.shape[0],1,784)\n",
    "ps = model.forward(images[0,:])\n",
    "helper.view_classify(images[0].view(1,28,28),ps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(in_features=784, out_features=128, bias=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[-0.0218,  0.0146,  0.0139,  ..., -0.0131,  0.0303, -0.0296],\n",
       "        [ 0.0014,  0.0307, -0.0283,  ..., -0.0087, -0.0286, -0.0179],\n",
       "        [ 0.0196,  0.0351,  0.0357,  ..., -0.0230,  0.0095, -0.0016],\n",
       "        ...,\n",
       "        [-0.0201,  0.0230,  0.0001,  ...,  0.0247, -0.0037,  0.0170],\n",
       "        [ 0.0188, -0.0318,  0.0242,  ...,  0.0035, -0.0283,  0.0260],\n",
       "        [-0.0322, -0.0356, -0.0327,  ...,  0.0175, -0.0322, -0.0354]],\n",
       "       requires_grad=True)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(model[0])\n",
    "model[0].weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (fc1): Linear(in_features=784, out_features=128, bias=True)\n",
       "  (relu1): ReLU()\n",
       "  (fc2): Linear(in_features=128, out_features=64, bias=True)\n",
       "  (relu2): ReLU()\n",
       "  (output): Linear(in_features=64, out_features=10, bias=True)\n",
       "  (softmax): Softmax()\n",
       ")"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#other way of doing things\n",
    "from collections import OrderedDict\n",
    "model = nn.Sequential(OrderedDict([\n",
    "                      ('fc1', nn.Linear(input_size, hidden_sizes[0])),\n",
    "                      ('relu1', nn.ReLU()),\n",
    "                      ('fc2', nn.Linear(hidden_sizes[0], hidden_sizes[1])),\n",
    "                      ('relu2', nn.ReLU()),\n",
    "                      ('output', nn.Linear(hidden_sizes[1], output_size)),\n",
    "                      ('softmax', nn.Softmax(dim=1))]))\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(in_features=784, out_features=128, bias=True)\n",
      "Linear(in_features=784, out_features=128, bias=True)\n"
     ]
    }
   ],
   "source": [
    "print(model[0])\n",
    "print(model.fc1)"
   ]
  },
  {
   "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
}