# mr-siddharthabanerjee/jupyter1

a year ago
In [1]:
``````import torch
import torch.nn as nn
import torch.nn.functional as F``````
In [31]:
``````class Net(nn.Module):

def __init__(self):
super(Net, self).__init__()
# 1 input image channel, 6 output channels, 3x3 square convolution
# kernel
self.conv1 = nn.Conv2d(1, 6, 3)
self.conv2 = nn.Conv2d(6, 16, 3)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
# Max pooling over a (2, 2) window
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

def num_flat_features(self, x):
size = x.size()[1:]  # all dimensions except the batch dimension
num_features = 1
for s in size:
num_features *= s
return num_features

``````
In [32]:
``````net = Net()
print(net)
``````
```Net( (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1)) (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1)) (fc1): Linear(in_features=576, out_features=120, bias=True) (fc2): Linear(in_features=120, out_features=84, bias=True) (fc3): Linear(in_features=84, out_features=10, bias=True) ) ```
In [33]:
``````params = list(net.parameters())
print(len(params))
print(params[0].size())``````
```10 torch.Size([6, 1, 3, 3]) ```
In [34]:
``````input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
``````
```tensor([[ 0.1707, -0.0176, 0.0281, -0.0333, 0.0537, -0.0026, 0.2111, -0.0131, -0.1948, 0.0129]], grad_fn=<AddmmBackward>) ```
In [35]:
``````net.zero_grad()
out.backward(torch.randn(1, 10))``````
In [36]:
``````output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)
``````
```tensor(0.7265, grad_fn=<MseLossBackward>) ```
In [37]:
``````print(loss.grad_fn)  # MSELoss
```<MseLossBackward object at 0x143f638d0> <AddmmBackward object at 0x143f63cd0> <AccumulateGrad object at 0x143f638d0> ```
In [38]:
``````net.zero_grad()     # zeroes the gradient buffers of all parameters

loss.backward()

``````
```conv1.bias.grad before backward tensor([0., 0., 0., 0., 0., 0.]) conv1.bias.grad after backward tensor([ 0.0144, 0.0010, 0.0151, -0.0027, 0.0071, 0.0171]) ```
In [39]:
``````import torch.optim as optim

optimizer = optim.SGD(net.parameters(), lr=0.01)

output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update``````
In [5]:
``````
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')

``````
```Files already downloaded and verified Files already downloaded and verified ```
In [6]:
``````import matplotlib.pyplot as plt
import numpy as np

# functions to show an image

def imshow(img):
img = img / 2 + 0.5     # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()

# get some random training images
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))``````
``` deer horse frog cat ```
In [7]:
``````import matplotlib.pyplot as plt
import numpy as np

# functions to show an image

def imshow(img):
img = img / 2 + 0.5     # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()

# get some random training images
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))``````
``` dog deer frog car ```
In [8]:
``````import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

net = Net()
``````
In [9]:
``````import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)``````
In [10]:
``````for epoch in range(2):  # loop over the dataset multiple times

running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data

# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()

# print statistics
running_loss += loss.item()
if i % 2000 == 1999:    # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0

print('Finished Training')``````
```[1, 2000] loss: 2.260 [1, 4000] loss: 1.965 [1, 6000] loss: 1.712 [1, 8000] loss: 1.604 [1, 10000] loss: 1.510 [1, 12000] loss: 1.477 [2, 2000] loss: 1.414 [2, 4000] loss: 1.381 [2, 6000] loss: 1.352 [2, 8000] loss: 1.306 [2, 10000] loss: 1.305 [2, 12000] loss: 1.275 Finished Training ```
In [12]:
``````PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))``````
```GroundTruth: cat ship ship plane ```
In [13]:
``````net = Net()
outputs = net(images)
_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))``````
```Predicted: cat ship ship ship ```
In [14]:
``````correct = 0
total = 0
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))``````
```Accuracy of the network on the 10000 test images: 54 % ```
In [16]:
``````class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1

for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))``````
```Accuracy of plane : 47 % Accuracy of car : 62 % Accuracy of bird : 50 % Accuracy of cat : 32 % Accuracy of deer : 43 % Accuracy of dog : 44 % Accuracy of frog : 64 % Accuracy of horse : 57 % Accuracy of ship : 81 % Accuracy of truck : 63 % ```
In [ ]:
`` ``