-
Notifications
You must be signed in to change notification settings - Fork 0
/
Image Classification_Convolution Neural Network.py
145 lines (115 loc) · 4.64 KB
/
Image Classification_Convolution Neural Network.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
# -*- coding: utf-8 -*-
"""cnn_hw3.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1pdIfi0titQl6fkNxA7Kvat7ZzyW3Vubt
"""
import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix
"""**Loading and normalizing the CIFAR10 training and test datasets using torchvision**
a) Images are converted to a data structure that stores a lot of numbers, using Torch Tensor.
b) These numbers are then normalized with mean and sd =0.5 for n channels.
c) These images or numbers are imported as training and testing sets
"""
# Loading and normalizing CIFAR10
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) #composing 2 transformations together - Normalization and TensorTorch, a data structure to store numbers
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) #importing the dataset from TorchVision, transformations are specified in the previous step
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 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
dataiter = iter(trainloader)
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)))
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, 10, 3) #3=numbers of colors in input image; 5=kernel size; 6= out channel
self.conv2 = nn.Conv2d(10, 120, 3) #6= input which is also previous out channel; 5=kernel size; 12= outchannel, larger than 1st conv layer
self.pool = nn.MaxPool2d(2, 2)
self.conv3 = nn.Conv2d(120, 240, 5) #12= input same as previous out channel; 5= kernel size; 32= outchannel, larger than 2nd conv layer
self.fc1 = nn.Linear(240*1*1, 360)
self.fc2 = nn.Linear(360, 960)
self.fc3 = nn.Linear(960, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = self.pool(F.relu(self.conv3(x)))
x = x.view(-1, 240*1*1)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
print(net)
import torch.optim as optim
#Defining the loss function
criterion = nn.CrossEntropyLoss()
#Defining the optimizer
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(35): # loop
net_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
output = net(inputs)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
# print statistics
net_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, net_loss / 2000))
net_loss = 0.0
print('Finished Training')
#accuracy calculation
correct=0
total=0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of network on the 10000 test images: %d %%' % (100 * correct / total))
# Save the trained model
# Add code here
PATH = './cnn_saved_model'
torch.save(net.state_dict(), PATH)
# Print Confusion matrix for the test set
# Add code here
predictions = np.ones(10000)
y_test = np.ones(10000)
predictions = torch.FloatTensor(predictions)
y_test = torch.FloatTensor(y_test)
i = 0
with torch.no_grad():
for data in testloader:
images, y = data
print(y)
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
print(predicted)
i = i + 1
break