Template code below:

###add lines to import modules as needed

##

def build$\_$model$1()$:

model $=$ None # Add code to define model $1.$

return model

def build$\_$model$2()$:

model $=$ None#add code to define model $1$

return model

def build$\_$model$3()$:

model $=$ None #add code to define model $1$

##this one should use the functional API so you can create the residual connections

return model

def build$\_$model$150$k$()$:

model $=$ None # add code to define model $1$

return model

#nio training or dataset construction should happen over this line

if $\_\_\_$name $==\text{'}\_\_$main$\_\_\text{'}$:

##########

##add code here to load the CIFAR$10$ data set

######

## build and train model $1$

model$1=$ build$\_$model$1()$

#compaile and train model $1$

##build, compile and train model $2($DS convolutions$)$

model$2=$ build$\_$model$2()$

### repeate for model $3$ and your best sub$-50$l params model

We're going to examine a convolutional neural network $($CNN$)$ used for classifying images in

the CIFAR$-10$ dataset.

A$.$ Each input image is $3232$ pixels with red$/$green$/$blue channels for a total size of

$32323.$

B$.$ The layers are as follows:

Conv $2$D: $32$ filters, $33$ kernel, stride$=2($in both $x,y$ dimensions$),$ "same" padding

BatchNorm

Conv $2$D: $64$ filters, $33$ kernel, stride$=2($in both $x,y$ dimensions$),$ "same" padding

BatchNorm

Conv $2$D: $128$ filters, $33$ kernel, stride$=2($in both $x,y$ dimensions$),$ "same" padding

BatchNorm

Four more pairs of Conv$2$D$+$Batchnorm, just like the last, except with no striding

option $($so stride defaults to $1).$

Conv $2$D: $128$ filters, $33$ kernel, $($in both $x,y$ dimensions$),$ "same" padding

BatchNorm

MaxPooling, $44$ pooling size, $44$ stride

Flatten

Dense $($aka Fully Connected$),128$ units.

BatchNorm

Dense $($aka Fully Connected$),10$ units

Use a spreadsheet or a script to calculate for each layer the number of parameters, the

number of multiply$-$accumulate operations, and the output size. Turn in a pdf showing a

table of parameter and mac counts per layer, as well as the spreadsheet or script you used

to calculate it$.$

The next steps will be turned in on GitHub. Copy the file hw$2\_$template.py to

hw$2\_$complete.py for your work.

The automatic grading scripts will assume you used the filename hw$2\_$complete.py$,$ so

please follow this instruction precisely.

Create a function named build$\_$model$1()($above the $"$if $")$ line, which implements

the above model in Keras. Use your function to build the model and, name it 'model$1\text{'}.$ Use

the summary$()$ method to check your parameter count and output size calculations. $($Make

sure to 'compile' it$).$

Load the CIFAR$-10$ set and split the training set into a training and validation subset.

Your training, test, and validation sets should be in variables named, respectively:

$($train$\_$images, train$\_$labels$),($test$\_$images, test$\_$labels$),($val$\_$images, val$\_$labels$)$

Train for $50$ epochs. What is the training, validation, and test accuracy at the end of

training?

INCLUDE Did you observe any overfitting? Should the model train for longer, shorter, or

about that number of epochs.

Take or find a picture of something that is one of the output classes

$(\text{'}$airplane$,$"automobile,"bird,"cat,'deer,"dog,'frog,"horse,"ship,"truck'$).$ Save it as a png or jpg$,$

crop and$/$or rescale it to $3232$ pixels, and run your classifier on it$.$ Name the

cropped$/$scaled image "test$\_$image$\_$classname.ext" where classname is one of the output

classes listed and 'ext' is the appropriate filename extension $($jpg or png$).$

INCLUDE Does it correctly label the picture?

Repeat steps $2,3,4,5$ with a model where all convolutional layers except for the first one are

replaced with depthwise$-$separable convolutions. Name this model 'model$2\text{'},$ and build it

with a function called "build$\_$model$2()"$

For example, a layer

Conv $2$D: $64$ filters, $33$ kernel, stride$=2($in both $x,y$ dimensions$),$ "same" padding

Would become either

SeparableConv $2$D: $64$ filters, $33$ kernel, stride$=2($in both $x,y$ dimensions$),$

"same" padding

$.$ OR

Depthwise Conv $2$D: $33$ kernel, stride$=2($in both $x,y$ dimensions$),$ "same"

padding, use$\_$bias$=$False

Disable the bias here, because applying a bias to both sub$-$layers is redundant

Conv$2$D: $64$ filters $($edit$),11$ kernel, stride$=1$

Note: Striding by $2$ twice would effectively stride by $4$

Note: padding does not matter for a $11$ kernel.

Only the $11$ convolutionn would include the activation $($eg "relu"$)$

INCLUDE For this model, did you observe any overfitting? Should the model train for longer,

shorter, or about that number of epochs.

Create a function that builds a $3$rd model, with the same structure as the first model

$($standard convolutions rather than separable convolution$)$ but add dropout layers after the

convolutions and residual connections $($aka skip connections$)$ around every two

convolutional blocks $($a "block" here refers to a convolution layer, batchnorm, and dropout$).$

Start the skip connections after the first convolution layer, because there is no benefit to

delivering gradients all the way back to the inputs. The building function should be called

build$\_$model$3()$ and the model should be named model$3.$ Also note that here you will need

to use the functional API B$,$ rather than the Sequential