Please design a suitable Convolutional Neural Network $($CNN$)$ to classify handwritten digits. The code needs to be able to be run in Jupyter. The images in this dataset are blurred in a way that is similar to that caused by camera shake. The training and test images as well as the Training and Test labels are provided as separate CSV formatted files $$ trainx.csv$,$ testx.csv$,$ trainy.csv$,$ and testy.csv$.$ The shape of trainy and testy is $(10,)$ and image shape for testx and trainx is $(784,).$ A jupyter code that can read the training images and displays one of them is given in CODE $1.$

CODE $2$ is the CNN code I have so far but does not open the csv images. Please adjust CODE $2$ so that it is using and reading these files, either train x and test y or all $4$ of them. A code that works please. The goal is to obtain as good a CNN as I can get by: $(1)$ Adjusting the hyperparameters such as learning rate, number of training epochs, convolutional kernel size, stride, pooling strategy etc. $(2)$ Changing the number of feature maps $(3)$ Including an additional convolutional layer $(4)$ Adding an extra fully connected layer. First I need a working code for my images in order to do that.

CODE $1$:

import numpy as np

import csv

import matplotlib.pyplot as plt

with open$(\text{'}./$trainx$.$csv$\text{'},\text{'}$r$\text{'})$ as csv$\_$file:

csvreader $=$ csv$.$reader$($csv$\_$file$)$

for data in csvreader:

img $=$ np$.$array$($data$,$ dtype$=$'int$64\text{'})$

print$($img$.$shape$)$

pixels $=$ img.reshape$((28,28))$

print$($pixels$.$shape$)$

plt$.$imshow$($pixels$,$ cmap$=$'gray'$)$

plt$.$show$()$

CODE $2$:

import numpy as np

import torch

import torch.nn as nn

import torch.nn$.$functional as F

from torch.utils.data import DataLoader

from torchvision import datasets, transforms

import matplotlib.pyplot as plt

$\%$matplotlib inline

T $=$ transforms.ToTensor$()$

train $=$ datasets.MNIST$($root$="./$Data$",$ train$=$True, download$=$True, transform$=$T$)$

train

test $=$ datasets.MNIST$($root$="./$Data$",$ train$=$False, download$=$True, transform$=$T$)$

test

train$\_$loader $=$ DataLoader$($train$,$ batch$\_$size$=100,$ shuffle$=$True$)$

test$\_$loader $=$ DataLoader$($test$,$ batch$\_$size$=500,$ shuffle$=$False$)$

class CNN$($nn$.$Module$)$:

def $\_\_$init$\_\_($self$)$:

super$($CNN$,$ self$).\_\_$init$\_\_()$

self.conv$1=$ nn$.$Sequential$($

nn$.$Conv$2$d$($in$\_$channels$=1,$ out$\_$channels$=16,$

kernel$\_$size$=5,$ stride$=1,$ padding$=2,),$

nn$.$ReLU$(),$

nn$.$MaxPool$2$d$($kernel$\_$size$=2),)$

self.conv$2=$ nn$.$Sequential$($

nn$.$Conv$2$d$(16,32,5,1,2),$

nn$.$ReLU$(),$

nn$.$MaxPool$2$d$(2),)$

self.out $=$ nn$.$Linear$(32*7*7,10)$

def forward$($self$,$ x$)$:

x $=$ self.conv$1($x$)$

x $=$ self.conv$2($x$)$

x $=$ x$.$view$($x$.$size$(0),-1)$ # flatten conv$2$ output to $($batch$\_$size $32*7*7)$

output $=$ self.out$($x$)$

return output, x # return x for visualization

cnn $=$ CNN$()$

print$($cnn$)$

loss$\_$fn $=$ nn$.$CrossEntropyLoss$()$

loss$\_$fn

from torch import optim

optimizer $=$ optim.Adam$($cnn$.$parameters$(),$ lr$=0\mathrm{.}001)$

optimizer

from torch.autograd import Variable

num$\_$epochs $=4$

def train$\_$model$($model$,$ num$\_$epochs, cnn$,$ loader$)$:

model.train$()$

total$\_$step $=$ len$($loader$)$

for epoch in range$($num$\_$epochs$)$:

for i$,($images$,$ labels$)$ in enumerate$($loader$)$:

b$\_$x $=$ Variable$($images$)$

b$\_$y $=$ Variable$($labels$)$

output $=$ cnn$($b$\_$x$)[0]$

loss $=$ loss$\_$fn$($output$,$ b$\_$y$)$

optimizer.zero$\_$grad$()$

loss.backward$()$

optimizer.step$()$

if $($i$+1)\%100==0$:

print$(\text{'}$Epoch $[\{\}/\{\}],$ Step $[\{\}/\{\}],$ Loss: $\{$:$\mathrm{.}4$f$\}\text{'}$

$.$format$($epoch$+1,$ num$\_$epochs, i$+1,$ total$\_$step, loss.item$()))$

train$\_$model$($cnn$,$ num$\_$epochs, cnn$,$ train$\_$loader$)$

test$\_$correct $=[]$

def eval$\_$model$($model$,$ dataloader$)$:

model.eval$()$

tst$\_$corr $=0$

with torch.no$\_$grad$()$:

for i$,($images$,$ labels$)$ in enumerate$($dataloader$)$:

test$\_$output, last$\_$layer $=$ model$($images$)$

predicted $=$ torch.max$($test$\_$output, $1)[1].$data.squeeze$()$

tst$\_$corr $+=($predicted $==$ labels$).$sum$()$

test$\_$correct.append$($tst$\_$corr$)$

eval$\_$model$($cnn$,$ test$\_$loader$)$

print$($f$\text{'}$Test accuracy: $\{$test$\_$correct$[-1].$item$()*100/10000$:$\mathrm{.}3$f$\}\%\text{'})$