I use this model: # Load the datasets

train$\_$data $=$ datasets.MNIST$($

root $=$ 'data',

train $=$ True,

transform $=$ transforms.Compose$([$transforms$.$ToTensor$()]),$

download $=$ True

$)$

test$\_$data $=$ datasets.MNIST$($

root $=$ 'data',

train $=$ False,

transform $=$ transforms.Compose$([$transforms$.$ToTensor$()]),$

download $=$ True$)$ train$\_$loader $=$ torch.utils.data.DataLoader$($train$\_$data,

batch$\_$size$=100,$

num$\_$workers$=0)$

test$\_$loader $=$ torch.utils.data.DataLoader$($test$\_$data,

batch$\_$size$=100,$

num$\_$workers$=0)$

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$)$

# flatten the output of conv$2$ to $($batch$\_$size, $32*7*7)$

x $=$ x$.$view$($x$.$size$(0),-1)$

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

return output # Instantiate the model, define the loss function and the optimizer

cnn $=$ CNN$()$

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

optimizer $=$ torch.optim.Adam$($cnn$.$parameters$(),$ lr $=0\mathrm{.}01)$ # Training the model

num$\_$epochs $=10$

# Make sure cnn is in training mode

cnn$.$train$()$

# Setting up the empty errors array

errors$=[]$

# How many batches are there in our training set?

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

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

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

output $=$ cnn$($images$)$ # Forward pass: Compute predicted y by passing x to the model

curr$\_$error $=$ loss$\_$func$($output$,$ labels$)$ # Compute loss

errors.append$($curr$\_$error.item$())$ # Append the current error to the errors list

optimizer.zero$\_$grad$()$ # Clear gradients for this training step

curr$\_$error.backward$()$ # Backpropagation: compute gradients

optimizer.step$()$ # Apply gradients $($update weights$)$

# Print training status every $100$ batches

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

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

$.$format$($epoch $+1,$ num$\_$epochs, i $+1,$ total$\_$step, curr$\_$error.item$()))$ cnn$.$eval$()$

num$\_$correct$=0$

for images, labels in test$\_$loader:

test$\_$output $=$ cnn$($images$)$

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

num$\_$correct $+=($pred$\_$y $==$ labels$).$sum$().$item$()$ # count the correct number

idx$\_$mask $=(($pred$\_$y $==$ labels$)==$ False$).$nonzero$()$

accuracy$=$num$\_$correct$/$len$($test$\_$data$)$

print$(\text{'}$Test Accuracy of the model on the MNIST test images: $\%\mathrm{.}2$f$\text{'}\%$ accuracy$)$ to Train a CNN to classify digits in the MNIST dataset and calculate the test accuracy. Now I want to Create a new

version of the dataset that has smoothed$/$filtered the images by applying a median filter twice, then use

the same model to calculate a new test accuracy. Create one more version of the dataset where the

images are smoothed in the same way and then sharpened, again use the same model to calculate a

new test accuracy. $($Hint: Use transforms!$).$