import numpy as np
import torch
import torchvision
import tensorflow as tf
from torch.autograd import Variable
import matplotlib.pyplot as plt
%matplotlib inline
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
a = np.random.rand(2,3)
b = torch.from_numpy(a)
# Q4.1 Display the contents of a, b
print('contents of a:\n', a)
print('contents of b:\n', b)
A = torch.rand(2,2)
b = torch.rand(2,1)
x = torch.rand(2,1, requires_grad=True)
y = torch.matmul(A,x) + b
print(y)
z = y.sum()
print(z)
z.backward()
print(x.grad)
print(x)
trainingdata = torchvision.datasets.FashionMNIST('./FashionMNIST/',train=True,download=True,transform=torchvision.transforms.ToTensor())
testdata = torchvision.datasets.FashionMNIST('./FashionMNIST/',train=False,download=True,transform=torchvision.transforms.ToTensor())
# Q4.2 How many training and testing data points are there in the dataset?
# What is the number of features in each data point?
print('Training data points: ', len(trainingdata))
print('Test data points: ', len(testdata))
img = trainingdata.data[0]
img = img.reshape(28, 28)
img = img.flatten()
print('Number of features in each data point: ', len(img))
randnums= np.random.randint(1,60000,15)
# Q4.3 Assuming each sample is an image of size 28x28, show it in matplotlib.
plt.figure(figsize=(10,10))
for i in range(15):
image, label = trainingdata[randnums[i]]
image = image.reshape(28, 28)
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.imshow(image, cmap=plt.cm.binary)
plt.xlabel(label)
plt.show()
trainDataLoader = torch.utils.data.DataLoader(trainingdata, batch_size=64, shuffle=True)
testDataLoader = torch.utils.data.DataLoader(testdata, batch_size=64, shuffle=False)
trainDataIter = iter(trainDataLoader)
images, labels = trainDataIter.next()
print(images.size(), labels)
# Q4.4 Visualize the first 10 images of the first minibatch
# returned by testDataLoader.
testDataIter = iter(testDataLoader)
test_images, test_labels = testDataIter.next()
plt.figure(figsize=(10,10))
for i in range(10):
image = test_images[i].reshape(28, 28)
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.imshow(image, cmap=plt.cm.binary)
plt.xlabel(test_labels[i])
plt.show()
class LinearReg(torch.nn.Module):
def __init__(self):
super(LinearReg, self).__init__()
self.linear = torch.nn.Linear(28*28,10)
def forward(self, x):
x = x.view(-1,28*28)
transformed_x = self.linear(x)
return transformed_x
net = LinearReg().cuda()
Loss = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.01)
train_loss_history = []
test_loss_history = []
# Q4.5 Write down a for-loop that trains this network for 20 epochs,
# and print the train/test losses.
# Save them in the variables above. If done correctly, you should be able to
# execute the next code block.
num_epochs = 20
for epoch in range(num_epochs):
epoch_train_loss = 0
current_epoch_train_loss = 0
count = 0
for images, labels in trainDataLoader:
# Transfering images and labels to GPU if available
images, labels = images.to(device), labels.to(device)
# Forward pass
outputs = net(images)
loss = Loss(outputs, labels)
# Initializing the gradient as 0 so there is no mixing of gradient among the batches
optimizer.zero_grad()
#Backward propagation of error
loss.backward()
# Optimizing the parameters
optimizer.step()
epoch_train_loss += loss.data
count += 1
current_epoch_train_loss = epoch_train_loss/count
train_loss_history.append(current_epoch_train_loss)
if count % 5 == 0:
print("Epoch: {}, Train Loss: {}".format(epoch, current_epoch_train_loss))
for epoch in range(num_epochs):
epoch_test_loss = 0
current_epoch_test_loss = 0
count = 0
for test_images, test_labels in testDataLoader:
test_images, test_labels = test_images.to(device), test_labels.to(device)
predictions = net(test_images)
epoch_test_loss += Loss(predictions, test_labels)
count += 1
current_epoch_test_loss = epoch_test_loss/count
test_loss_history.append(current_epoch_test_loss)
if count % 5 == 0:
print("Epoch: {}, Train Loss: {}".format(epoch, current_epoch_test_loss))
plt.plot(range(20),train_loss_history,'-',linewidth=3,label='Train error')
plt.plot(range(20),test_loss_history,'-',linewidth=3,label='Test error')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.grid(True)
plt.legend()
predicted_output = net(images)
print(torch.max(predicted_output, 1))
fit = Loss(predicted_output, labels)
print(labels)
def evaluate(dataloader):
# Q4.6 Implement a function here that evaluates training and testing accuracy.
# Here, accuracy is measured by probability of successful classification.
accuracy = 0
for images, labels in dataloader:
images, labels = images.to(device), labels.to(device)
predictions = net(images)
predicted_labels = predictions.max(1).indices
accuracy += (predicted_labels == labels).sum(dtype=torch.float32)
return accuracy/len(dataloader.dataset)
print('Train acc = %0.2f, test acc = %0.2f' % (evaluate(trainDataLoader), evaluate(testDataLoader)))
