2020-05-02 21:40:17 +00:00
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import torch.nn as nn\n",
"import torchvision.transforms as transforms\n",
"import torchvision.datasets as datasets"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"mean_gray = 0.1307\n",
"stddev_gray = 0.3081\n",
"\n",
"# input[channel] = (input[channel]-meaan[channel]) / std[channel]\n",
"\n",
"transforms = transforms.Compose([transforms.ToTensor(),\n",
" transforms.Normalize((mean_gray,),(stddev_gray,))])\n",
"\n",
"train_dataset = datasets.MNIST(root='./data', \n",
" train=True, \n",
" transform=transforms, \n",
" download=True)\n",
"\n",
"test_dataset = datasets.MNIST(root='./data', \n",
" train=False, \n",
" transform=transforms)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
2020-05-04 00:03:20 +00:00
"<matplotlib.image.AxesImage at 0x7fd7823b2f10>"
2020-05-02 21:40:17 +00:00
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"random_img = train_dataset[20][0].numpy() * stddev_gray + mean_gray\n",
"plt.imshow(random_img.reshape(28,28), cmap='gray')"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
2020-05-03 18:26:33 +00:00
"name": "stdout",
"output_type": "stream",
"text": [
"4\n"
]
2020-05-02 21:40:17 +00:00
}
],
"source": [
"print(train_dataset[20][1])"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"batch_size = 100\n",
"\n",
"train_load = torch.utils.data.DataLoader(dataset=train_dataset,\n",
" batch_size=batch_size,\n",
" shuffle=True)\n",
"\n",
"test_load = torch.utils.data.DataLoader(dataset=test_dataset,\n",
" batch_size=batch_size,\n",
" shuffle=True)\n"
]
},
{
"cell_type": "code",
2020-05-03 18:26:33 +00:00
"execution_count": 6,
2020-05-02 21:40:17 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"100"
]
},
2020-05-03 18:26:33 +00:00
"execution_count": 6,
2020-05-02 21:40:17 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(test_load)"
]
},
{
"cell_type": "code",
2020-05-04 00:03:20 +00:00
"execution_count": 7,
2020-05-02 21:40:17 +00:00
"metadata": {},
"outputs": [],
2020-05-03 18:26:33 +00:00
"source": [
"class CNN(nn.Module):\n",
" def __init__(self):\n",
" super(CNN,self).__init__()\n",
" # Same padding means that input_size = output_size\n",
" # same_padding = (filter_size - 1) / 2\n",
" self.cnn1 = nn.Conv2d(in_channels=1, out_channels=8, kernel_size=(3,3), stride=1, padding=1)\n",
" # The output from this layer has size:\n",
" # [(input_size - filter_size + 2*(padding)) / stride] + 1\n",
" self.batchnorm1 = nn.BatchNorm2d(8)\n",
" self.relu = nn.ReLU()\n",
" self.maxpool = nn.MaxPool2d(kernel_size=(2,2))\n",
" # Pooling output size is 28/2 = 14 (downsampling)\n",
" # Same padding size is (5 - 1)/2 = 2\n",
" self.cnn2 = nn.Conv2d(in_channels=8, out_channels=32, kernel_size=(5,5), stride=1, padding=2)\n",
" self.batchnorm2 = nn.BatchNorm2d(32)\n",
" # Pooling output size is 14/2 = 7 (downsampling)\n",
" # We have to flatten the output channels 32*7*7 = 1568\n",
" self.fc1 = nn.Linear(1568,600)\n",
" self.dropout = nn.Dropout(p=0.5)\n",
" self.fc2 = nn.Linear(600,10)\n",
" \n",
" def forward(self,x):\n",
" out = self.cnn1(x)\n",
" out = self.batchnorm1(out)\n",
" out = self.relu(out)\n",
" out = self.maxpool(out)\n",
" out = self.cnn2(out)\n",
" out = self.batchnorm2(out)\n",
" out = self.relu(out)\n",
" out = self.maxpool(out)\n",
" # we have to flatten the 32 feature maps, output of our last maxpool (100, 1568)\n",
2020-05-04 00:03:20 +00:00
" out = out.view(-1, 1568) # <- setting the number of rows to -1 is important, because \n",
" out = self.fc1(out) # when we try to predict we would require to use a size 100 (batch size)\n",
" out = self.relu(out) # tensor but -1 infers the size.\n",
2020-05-03 18:26:33 +00:00
" out = self.dropout(out)\n",
" out = self.fc2(out)\n",
" \n",
" return out\n",
" "
]
2020-05-04 00:03:20 +00:00
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"model = CNN()\n",
"\n",
"CUDA = torch.cuda.is_available()\n",
"\n",
"if CUDA:\n",
" model = model.cuda()\n",
" \n",
"loss_fn = nn.CrossEntropyLoss()\n",
"optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"For one iteration this is what happens:\n",
"Input shape: torch.Size([100, 1, 28, 28])\n",
"Labels shape: torch.Size([100])\n",
"Output shape: torch.Size([100, 10])\n",
"Predicted shape: torch.Size([100, 1, 28, 28])\n",
"Predicted tensor: \n",
"tensor([7, 9, 6, 3, 4, 9, 7, 6, 9, 9, 3, 3, 3, 5, 4, 2, 3, 9, 9, 3, 4, 6, 4, 4,\n",
" 3, 2, 9, 2, 2, 4, 9, 6, 9, 2, 4, 3, 9, 2, 4, 5, 6, 4, 9, 2, 2, 9, 2, 9,\n",
" 7, 9, 9, 6, 9, 6, 2, 6, 3, 4, 4, 2, 6, 2, 4, 6, 4, 7, 7, 4, 9, 7, 8, 9,\n",
" 6, 6, 4, 4, 8, 6, 2, 4, 8, 2, 3, 6, 4, 3, 2, 2, 8, 9, 4, 9, 3, 4, 6, 4,\n",
" 3, 4, 3, 6])\n"
]
}
],
"source": [
"# Understand what is happening\n",
"iteration = 0\n",
"correct = 0\n",
"\n",
"for i,(inputs, labels) in enumerate(train_load):\n",
" \n",
" if CUDA:\n",
" inputs = inputs.cuda()\n",
" labels = labels.cuda()\n",
" \n",
" print('For one iteration this is what happens:')\n",
" print('Input shape: ', inputs.shape)\n",
" print('Labels shape: ', labels.shape)\n",
" output = model(inputs)\n",
" print('Output shape: ', output.shape)\n",
" _, predicted = torch.max(output, dim=1)\n",
" print('Predicted shape: ', inputs.shape)\n",
" print('Predicted tensor: ')\n",
" print(predicted)\n",
" correct += (predicted==labels).sum()\n",
" break\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/10, Training loss: 1.153, Training accuracy: 0.626, Testing loss: 6.920, Testing accuracy: 0.969\n",
"Epoch 2/10, Training loss: 0.341, Training accuracy: 0.885, Testing loss: 2.045, Testing accuracy: 0.981\n",
"Epoch 3/10, Training loss: 0.156, Training accuracy: 0.954, Testing loss: 0.937, Testing accuracy: 0.985\n",
"Epoch 4/10, Training loss: 0.106, Training accuracy: 0.970, Testing loss: 0.635, Testing accuracy: 0.987\n",
"Epoch 5/10, Training loss: 0.090, Training accuracy: 0.974, Testing loss: 0.539, Testing accuracy: 0.988\n",
"Epoch 6/10, Training loss: 0.077, Training accuracy: 0.978, Testing loss: 0.461, Testing accuracy: 0.989\n",
"Epoch 7/10, Training loss: 0.071, Training accuracy: 0.980, Testing loss: 0.428, Testing accuracy: 0.988\n",
"Epoch 8/10, Training loss: 0.068, Training accuracy: 0.980, Testing loss: 0.411, Testing accuracy: 0.990\n",
"Epoch 9/10, Training loss: 0.060, Training accuracy: 0.983, Testing loss: 0.361, Testing accuracy: 0.989\n",
"Epoch 10/10, Training loss: 0.062, Training accuracy: 0.982, Testing loss: 0.372, Testing accuracy: 0.990\n"
]
},
{
"data": {
"text/plain": [
"\"\\n\\n#Training the CNN\\nnum_epochs = 10\\n\\n#Define the lists to store the results of loss and accuracy\\ntrain_loss = []\\ntest_loss = []\\ntrain_accuracy = []\\ntest_accuracy = []\\n\\n#Training\\nfor epoch in range(num_epochs): \\n #Reset these below variables to 0 at the begining of every epoch\\n correct = 0\\n iterations = 0\\n iter_loss = 0.0\\n \\n model.train() # Put the network into training mode\\n \\n for i, (inputs, labels) in enumerate(train_load):\\n \\n if CUDA:\\n inputs = inputs.cuda()\\n labels = labels.cuda()\\n \\n outputs = model(inputs) \\n loss = loss_fn(outputs, labels) \\n iter_loss += loss.item() # Accumulate the loss\\n optimizer.zero_grad() # Clear off the gradient in (w = w - gradient)\\n loss.backward() # Backpropagation \\n optimizer.step() # Update the weights\\n \\n # Record the correct predictions for training data \\n _, predicted = torch.max(outputs, 1)\\n correct += (predicted == labels).sum()\\n iterations += 1\\n \\n # Record the training loss\\n train_loss.append(iter_loss/iterations)\\n # Record the training accuracy\\n train_accuracy.append((100 * correct / len(train_dataset)))\\n \\n #Testing\\n testing_loss = 0.0\\n correct = 0\\n iterations = 0\\n\\n model.eval() # Put the network into evaluation mode\\n \\n for i, (inputs, labels) in enumerate(test_load):\\n\\n if CUDA:\\n inputs = inputs.cuda()\\n labels = labels.cuda()\\n \\n outputs = model(inputs) \\n loss = loss_fn(outputs, labels) # Calculate the loss\\n testing_loss += loss.item()\\n # Record the correct predictions for training data\\n _, predicted = torch.max(outputs, 1)\\n correct += (predicted == labels).sum()\\n \\n iterations += 1\\n\\n # Record the Testing loss\\n test_loss.append(testing_loss/iterations)\\n # Record the Testing accuracy\\n test_accuracy.append((100 * correct / len(test_dataset)))\\n \\n print ('Epoch {}/{}, Training Loss: {:.3f}, Training Accuracy: {:.3f}, Testing Loss: {:.3f}, Testing Acc: {:.3f}'\\n .format(epoch+1, num_epochs, train_loss[-1], train_accuracy[-1], \\n test_loss[-1], test_accuracy[-1]))\\n\""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Training of the CNN\n",
"num_epochs = 10\n",
"train_loss = list()\n",
"train_accuracy = list()\n",
"test_loss = list()\n",
"test_accuracy = list()\n",
"\n",
"\n",
"for epoch in range(num_epochs):\n",
" correct = 0\n",
" iterations = 0\n",
" iter_loss = 0.0\n",
" \n",
" # When batch normalization and dropout are used\n",
" # we have to specify our model that we are training\n",
" model.train()\n",
" \n",
" for i,(inputs, labels) in enumerate(train_load):\n",
" \n",
" if CUDA:\n",
" inputs = inputs.cuda()\n",
" labels = labels.cuda()\n",
" \n",
" outputs = model(inputs)\n",
" loss = loss_fn(outputs,labels)\n",
" iter_loss += loss.item()\n",
" \n",
" optimizer.zero_grad()\n",
" loss.backward()\n",
" optimizer.step()\n",
" \n",
" _, predicted = torch.max(outputs, dim=1)\n",
" correct += (predicted==labels).sum().item()\n",
" iterations += 1\n",
" \n",
" train_loss.append(iter_loss/iterations)\n",
" train_accuracy.append(correct/len(train_dataset))\n",
" \n",
" # Testing phase\n",
" testing_loss = 0.0\n",
" correct = 0\n",
" iterations = 0\n",
" \n",
" model.eval()\n",
" \n",
" for i,(inputs, labels) in enumerate(test_load):\n",
" \n",
" if CUDA:\n",
" inputs = inputs.cuda()\n",
" labels = labels.cuda()\n",
" \n",
" outputs = model(inputs)\n",
" loss = loss_fn(outputs,labels)\n",
" testing_loss += loss.item()\n",
" \n",
" _, predicted = torch.max(outputs, dim=1)\n",
" correct += (predicted==labels).sum().item()\n",
" iterations += 1\n",
" \n",
" test_loss.append(iter_loss/iterations)\n",
" test_accuracy.append(correct/len(test_dataset))\n",
" \n",
" print('Epoch {}/{}, Training loss: {:.3f}, Training accuracy: {:.3f}, Testing loss: {:.3f}, Testing accuracy: {:.3f}'.format(\n",
" epoch+1,num_epochs,train_loss[-1],train_accuracy[-1],test_loss[-1],test_accuracy[-1]))\n",
"\n",
"\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 720x720 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Plotting the loss\n",
"\n",
"f = plt.figure(figsize=(10,10))\n",
"plt.plot(train_loss, label='Training loss')\n",
"plt.plot(test_loss, label='Testing loss')\n",
"plt.legend()\n",
"plt.show()\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 720x720 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Plotting the accuracy\n",
"\n",
"f = plt.figure(figsize=(10,10))\n",
"plt.plot(train_accuracy, label='Training accuracy')\n",
"plt.plot(test_accuracy, label='Testing accuracy')\n",
"plt.legend()\n",
"plt.show()\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Prediction is: 1\n",
"Actual label is: 1\n"
]
}
],
"source": [
"img = test_dataset[31][0].resize_((1,1,28,28))\n",
"label = test_dataset[31][1]\n",
"\n",
"model.eval()\n",
"\n",
"if CUDA:\n",
" model = model.cuda()\n",
" img = img.cuda()\n",
" \n",
"output = model(img)\n",
"_, predicted = torch.max(output, dim=1)\n",
"print('Prediction is: {}'.format(predicted.item()))\n",
"print('Actual label is: {}'.format(label))\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x7fd77db5b250>"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"random_img = test_dataset[31][0].numpy() * stddev_gray + mean_gray\n",
"plt.imshow(random_img.reshape(28,28), cmap='gray')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
2020-05-02 21:40:17 +00:00
}
],
"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",
2020-05-15 14:33:24 +00:00
"version": "3.7.7"
2020-05-02 21:40:17 +00:00
}
},
"nbformat": 4,
"nbformat_minor": 4
}
