代写Grads Only、代做Network留学生、代写Matlab设计、Matlab代做

日期：2018-12-01 10:04

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 1/12

Homework Seven (Grads Only)

Due Dec 3 by 3pm Points 100 Submitting a file upload Available after Oct 31 at 12am

Submit Assignment

For this assignment, you will be asked to train a deep convolutional neural network from scratch.

We will be learning about many of the concepts needed in this homework assignment in the weeks of 11/12, 11/19,

and 11/26. However, you are advised to begin teaching yourself about Neural Networks *now* and refine your work as

we cover material. The MATLAB website has numerous tutorials on performing Deep Learning in

MATLAB. https://www.mathworks.com/solutions/deep-learning/examples/training-a-model-from-scratch.html

(https://www.mathworks.com/solutions/deep-learning/examples/training-a-model-from-scratch.html)

In this project, you will train a deep convolutional network from scratch to recognize scenes. The starter code gives

you a very simple network architecture which doesn't work that well and you will add jittering, normalization,

regularization, and more layers to increase recognition accuracy to 50, 60, or perhaps 70%. Unfortunately, we only

have 1,500 training examples so it doesn't seem possible to train a network from scratch which outperforms handcrafted

features.

Project materials including starter code, training and testing data, and html writeup template: hw7.zip.

You must separately download MatConvNet 1.0 beta 16. (direct link to beta 16). MAKE SURE YOU USE THE

BETA 16 VERSION.

MatConvNet isn't precompiled like VLFeat, so we compiled it for you.

Make sure you have the MATLAB Parallel Computing Toolbox installed.

Starter Code Outline

The following is an outline of the stencil code:

hw7.m . The top level function for training a deep network from scratch for scene recognition. If you run this starter

code unmodified it will train a simple network that achieves only 25% accuracy (about as good as the tiny images

baseline in project 4). hw7.m calls:

hw7_setup_data.m . Loads the 15 scene database into MatConvNet imdb format.

hw7_cnn_init.m . Initializes the convolutional network by specifying the various layers which perform convolution,

max pooling, non-linearities, normalization, regularization, and the final loss layer.

hw7_get_batch() (defined inside hw7.m ) This operates on each batch of training images to be passed into the

network during training. This is where you can "jitter" your training data.

The deep network training will be performed by cnn_train.m which in turn calls vl_simplenn.m

(http://www.vlfeat.org/matconvnet/mfiles/simplenn/vl_simplenn/) but you will not need to modify those functions for this

project.

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 2/12

Part 0

First install MatConvNet and make sure it is working, using the code below. Step through the following MatConvNet

"Quick start" demo. You can simply copy and paste the commands into the Matlab command window.

% install and compile MatConvNet

% (you can skip this if you already installed MatConvNet beta 16 and the mex files)

% untar('http://www.vlfeat.org/matconvnet/download/matconvnet-1.0-beta16.tar.gz') ;

% cd matconvnet-1.0-beta16

% run matlab/vl_compilenn

% download a pre-trained CNN from the web (needed once)

websave('imagenet-vgg-f.mat', 'http://www.vlfeat.org/matconvnet/models/imagenet-vgg-f.mat') ;

% If you have problems downloading through Matlab,

% you can simply put the url into a web browser and save the file.

% Or potentially modify the save location (and adapt below) to save somewhere where you have permissions.

% setup MatConvNet. Your path might be different.

run '../../matconvnet-1.0-beta16/matlab/vl_setupnn'

% load the 233MB pre-trained CNN

net = load('imagenet-vgg-f.mat') ;

% Fix any compatibility issues with the network

net = vl_simplenn_tidy(net) ;

% load and preprocess an image

im = imread('peppers.png') ;

im_ = single(im) ; % note: 255 range

im_ = imresize(im_, net.meta.normalization.imageSize(1:2)) ;

im_ = im_ - net.meta.normalization.averageImage ;

% run the CNN

res = vl_simplenn(net, im_) ;

% show the classification result

scores = squeeze(gather(res(end).x)) ;

[bestScore, best] = max(scores) ;

figure(1) ; clf ; imagesc(im) ;

title(sprintf('%s (%d), score %.3f',...

net.meta.classes.description{best}, best, bestScore)) ;

Troubleshooting. If you encounter errors trying to run this demo, make sure: (1) You have MatConvNet 1.0 beta 16

(not a different version). (2) Your mex files are in the correct location [MatConvNetPath]/matlab/mex/ . If you encounter

errors about invalid mex files in Windows you may be missing Visual C++ Redistributable Packages

(https://www.microsoft.com/en-us/download/details.aspx?id=40784) . If you encounter an error about

about labindex being undefined you may be missing the parallel computing toolbox for Matlab.

Before we start building our own deep convolutional networks, it might be useful to have a look at MatConvNet's

tutorial (http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html) . In particular, you should be able to understand

Part 1 of the tutorial. In addition to the examples shown in parts 3 and 4 of the tutorial, MatConvNet has example

code (http://www.vlfeat.org/matconvnet/training/) for training networks to recognize the MNIST and CIFAR datasets.

Your project follows the same outline as those examples. Feel free to take a look at that code for inspiration. You can

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 3/12

run the example code to watch the training process MNIST and CIFAR. Training will take about 5 and 15 minutes for

those datasets, respectively.

Compiling MatConvNet with GPU support is more complex and not needed for this project. If you're trying to do extra

credit and find yourself frustrated with training times you can try, though.

Training a deep network from scratch

For the bits below, make sure you are running your code from the code directory of the hw7 directory; if you get errors,

make sure your hw7 directory and /home/tom/Downloads/matconvnet-1.0-beta16 directory are in the same higherlevel

directory.

Run hw7.m and bask in the glory of deep learning. Gone are the days of hand designed features. Now we have endto-end

learning in which a highly non-linear representation is learned for our data to maximize our objective (in this

case, 15-way classification accuracy). Instead of an anemic 70% accuracy we can now recognize scenes with... 25%

accuracy. OK, that didn't work at all. What's going on?

First, let's take a look at the network architecture used in this experiment. Here is the code from hw7_cnn_init.m that

specifies the network structure:

Let's make sure we understand what's going on here. This simple baseline network has 4 layers -- a convolutional

layer, followed by a max pool layer, followed by a rectified linear layer, followed by another convolutional layer. This

last convolutional layer might be called a "fully connected" or "fc" layer because its output has a spatial resolution of

1x1. Equivalently, every unit in the output of that layer is a function of the entire previous layer (thus "fully connected").

But mathematically there's not really any difference from "convolutional" layers so we specify them in the same way in

MatConvNet.

Let's look at the first convolutional layer. The "weights" are the filters being learned. They are initialized with random

numbers from a Gaussian distribution. The inputs to randn(9,9,1,10) mean the filters have a 9x9 spatial resolution,

span 1 filter depth (because the input images are grayscale), and that there are 10 filters. The network also learns a

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 4/12

bias or constant offset to associate with the output of each filter. This is what zeros(1,10) initializes.

The next layer is a max pooling layer. It will take a max over a 7x7 sliding window and then subsample the resulting

image / map with a stride of 7. Thus the max pooling layer will decrease the spatial resolution by a factor of 7

according to the stride parameter. The filter depth will remain the same (10). There are other pooling possibilities

(e.g. average pooling) but we will only use max pooling in this project.

The next layer is the non-linearity. Any values in the feature map from the max pooling layer which are negative will be

set to 0. There are other non-linearity possibilities (e.g. sigmoid) but we will use only rectified linear in this project.

Note that the pool layer and relu layer have no learned parameters associated with them. We are hand-specifying their

behavior entirely, so there are no weights to initialize as in the convolutional layers.

Finally, we have the last layer which is convolutional (but might be called "fully connected" because it happens to

reduce the spatial resolution to 1x1). The filters learned at this layer operate on the rectified, subsampled, maxpooled

filter responses from the first layer. The output of this layer must be 1x1 spatial resolution (or "data size") and

it must have a filter depth of 15 (corresponding to the 15 categories of the 15 scene database). This is achieved by

initializing the weights with randn(8,8,10,15) . 8x8 is the spatial resolution of the filters. 10 is the number of filter

dimensions that each of these filters take as input and 15 is the number of dimensions out. 10 is highlighted in green

to emphasize that it must be the same in those 3 places -- if the first convolutional layer has weights for 10 filters, it

must also have offsets for 10 filters, and the next convolutional layer must take as input 10 filter dimensions.

At the top of our network we add one more layer which is only used for training. This is the "loss" layer. There are

many possible loss functions but we will use the "softmax" loss for this project. This loss function will measure how

badly the network is doing for any input (i.e. how different its final layer activations are from the ground truth, where

ground truth in our case is category membership). The network weights will update, through backpropagation, based

on the derivative of the loss function. With each training batch the network weights will take a tiny gradient descent

step in the direction that should decrease the loss function (but isn't actually guaranteed to, because the steps are of

some finite length, or because dropout regularization will turn off part of the network).

How did we know to make the final layer filters have a spatial resolution of 8x8? It's not obvious because we don't

directly specify output resolution. Instead it is derived from the input image resolution and the filter widths, padding,

and strides of the previous layers. Luckily MatConvNet provides a visualization function vl_simplenn_display to help us

figure this out. Here is what it looks like if we specify the net as shown above and then call vl_simplenn_display(net,

'inputSize', [64 64 1 50]) .

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 5/12

If the last convolutional layer had a filter size of 6x6 that would lead to a "data size" in the network visualization of 3x3

and we would know we need to change things (subsample more in previous layers or create wider filters in the final

layer). In general it is not at all obvious what the right network architecture is. It takes a lot of artistry (read as: black

magic) to design the right network and training strategy for optimal performance.

We just said the network has 4 real layers but this visualization shows 6. That's because it includes a layer 0 which is

the input image and a layer 5 which is the loss layer. For each layer this visualization shows several useful attributes.

"data size" is the spatial resolution of the feature maps at each level. In this network and most deep networks this

will decrease as you move up thet network. "data depth" is the number of channels or filters in each layer. This will

tend to increase as you move up a network. "rf size" is the receptive field size. That is how large an area in the original

image a particular network unit is sensitive to. This will increase as you move up the network. Finally this visualization

shows us that the network has 10,000 free parameters, the vast majority of them associated with the last convolutional

layer.

OK, now we understand a bit about the network. Let's analyze its performance. After 30 training epochs (30 passes

through the training data) Matlab's Figure 1 should look like this:

(Note: your plots might slightly different due to updates in MATLAB.)

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 6/12

We'll be studying these figures quite a bit during this project so it's important to understand what it shows.

The left pane shows the training loss (blue) and validation loss (dashed orange) across training epochs. Each training

epoch is a pass over the entire training set of 1500 images broken up into "batches" of 50 training instances. The code

shuffles the order of the training instances randomly each epoch. When the network makes mistakes, it incurs a "loss"

and backpropagation updates the weights of the network in a direction that shoulddecrease the loss. Therefore the

blue line should more or less decrease monotonically. On the other hand, the orange line is the loss incurred on

theheld out test set. The figure refers to it as "val" or "validation". In a realistic recognition scenario we might have

three sets of data: train, validation, and test. We would use validation to assess how well our training is working and to

know when to stop training and then we would test on a completely held out test set. For this project the validation set

is our test set. We're trying to maximize performance on the validation set and that's it. The pass through the validation

set does not change the network weights in any way. The pass through the validation set is also 3 times faster than

the training pass because it does not have the "backwards" pass to update network weights.

The middle pane shows the training and testing accuracy on the train and test (val) data sets across the same training

epochs. It shows top 1 error -- how often the highest scoring guess is wrong. We're interested in top 1 error,

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 7/12

specifically the top 1 error on the held out validation / test set.

The right pane shows top 5 error -- how often all of the 5 highest scoring guesses are wrong. We're not as worried

about this metric.

In this experiment, the training and test top 1 error started out around 93% which is exactly what we would expect. If

you have 15 categories and you make a random guess on each test case, you will be wrong 93% of the time. As the

training progressed and the network weights moved away from their random initialization, accuracy increased.

Note the areas circled in green corresponding to the first 8 training epochs. During these epochs, the

training and validation error were decreasing which is exactly what we want to see. Beyond that point the error on the

training dataset kept decreasing, but the validation error did not. Our lowest error on the validation/test set is around

75% (or 25% accuracy). We are overfitting to our training data. This is hard to avoid with a small training set. In fact, if

we let this experiment run for 200 epochs we see that it is possible for the training accuracy to become perfect with no

appreciable increase in test accuracy:

Now we are going to take several steps to improve the performance of our convolutional network. The modifications

we make will familiarize you with the building blocks of deep learning that can lead to impressive accuracy with

enough training data. With the relatively small amount of training data in the 15 scene database, it is very hard to

outperform hand-crafted features.

Learning rate. Before we start making changes, there is a very important learning parameter that you might need to

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 8/12

tune any time you change the network or the data being input to the network. The learning rate (set by default

as opts.LearningRate = 0.0001 in hw7.m ) determines the size of the gradient descent steps taken by the network

weights. If things aren't working, try making it much smaller or larger (e.g. by factors of 10). If the objective remains

exactly constant over the first dozen epochs, the learning rate might have been too high and "broken" some aspect of

the network. If the objective spikes or even becomes NaN then the learning rate may also be too large. However, a

very small learning rate requires many training epochs.

Problem 1: We don't have enough training data. Let's "jitter".

If you left-right flip (mirror) an image of a scene, it never changes categories. A kitchen doesn't become a forest when

mirrored. This isn't true in all domains -- a "d" becomes a "b" when mirrored, so you can't "jitter" digit recognition

training data in the same way. But we can synthetically increase our amount of training data by left-right mirroring

training images during the learning process.

The learning process calls getBatch() in hw7.m each time it wants training or testing images. Modify getBatch() to

randomly flip some of the images (or entire batches). Useful functions: rand and fliplr .

You can try more elaborate forms of jittering -- zooming in a random amount, rotating a random amount, taking a

random crop, etc. Mirroring helps quite a bit on its own, though, and is easy to implement. You should see a 5% to

10% increase in accuracy (or drop in top 1 validation error) by adding mirroring.

After you implement mirroring, you should notice that your training error doesn't drop as quickly. That's actually a good

thing, because it means the network isn't overfitting to the 1,500 original training images as much (because it sees

3,000 training images now, although they're not as good as 3,000 truly independent samples). Because the training

and test errors fall more slowly, you may need more training epochs or you may try modifying the learning rate.

Problem 2: The images aren't zero-centered.

One simple trick which can help a lot is to subtract the mean from every image. Modify hw7_setup_data.m so that it

computes the mean image and then subtracts the mean from all images before returning imdb . It would arguably be

more proper to only compute the mean from the training images (since the test/validation images should be strictly

held out) but it won't make much of a difference. After doing this you should see another 15% or so increase in

accuracy. Most of this increase will show up in the first few iterations.

Problem 3: Our network isn't regularized.

If you train your network (especially for more than the default number of epochs) you'll see that the training error can

decrease to zero while the val top1 error hovers at 40% to 50%. The network has learned weights which can perfectly

recognize the training data, but those weights don't generalize to held out test data. The best regularization would be

more training data but we don't have that. Instead we will use dropout regularization. We add a dropout layer to our

convolutional net as follows:

What does dropout regularization do? It randomly turns off network connections at training time to fight overfitting. This

prevents a unit in one layer from relying too strongly on a single unit in the previous layer. Dropout regularization can

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 9/12

be interpreted as simultaneously training many "thinned" versions of your network. At test test, all connections are

restored which is analogous to taking an average prediction over all of the "thinned" networks. You can see a more

complete discussion of dropout regularization in this paper

(https://www.cs.toronto.edu/~hinton/absps/JMLRdropout.pdf) .

The dropout layer has only one free parameter -- the dropout rate -- the proportion of connections that are randomly

deleted. The default of 0.5 should be fine. Insert a dropout layer between your convolutional layers. In particular, insert

it directly before your last convolutional layer. Your test accuracy should increase by another 10%. Your train accuracy

should decrease much more slowly. That's to be expected -- you're making life much harder for the training algorithm

by cutting out connections randomly.

If you increase the number of training epochs (and maybe decrease the learning rate) you should be able to achieve

55% test accuracy (45% top1 val error) or slightly better at this point. Notice how much more structured the learned

filters are at this point compared to the initial network before we made improvements:

Problem 4: Our network isn't deep.

Let's take a moment to reflect on what our convolutional network is actually doing. We learn filters which seem to be

looking horizontal edges, vertical edges, and parallel edges. Some of the filters have diagonal orientations and some

seem to be looking for high frequencies or center-surround. This learned filter bank is applied to each input image, the

maximum response from each 7x7 block is taken by the max pooling, and then the rectified linear layer zeros out

negative values. The fully connected layer sees a 10 channel image with 8x8 spatial resolution. It learns 15 linear

classifiers (a linear filter with a learned threshold is basically a linear classifier) on this 8x8 filter response map. This

architecture is reminiscent of hand-crafted features like the gist scene descriptor

(http://people.csail.mit.edu/torralba/code/spatialenvelope/) developed precisely for scene recoginition (on 8 scene

categories which would later be incorporated into the 15 scene database). The gist descriptor actually works better

than our learned feature. The gist descriptor with a non-linear classifier can achieve 74.7% accuracy on the 15 scene

database.

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 10/12

Our convolutional network to this point isn't "deep". It has two layers with learned weights. Contrast this with the

example networks for MNIST and CIFAR in MatConvNet which contain 4 and 5 layers, respectively. AlexNet and

VGG-F contain 8 layers. The VGG "very deep" networks (http://www.robots.ox.ac.uk/~vgg/research/very_deep/)

contain 16 and 19 layers. ResNet (https://arxiv.org/abs/1512.03385) contains up to 150 layers.

One quite unsatisfying aspect of our current network architecture is that the max-pooling operation covers a window of

7x7 and then is subsampled with a stride of 7. That seems overly lossy and deep networks usually do not subsample

by more than a factor of 2 or 3 each layer.

Let's make our network deeper by adding an additional convolutional layer in hw7_cnn_init.m . In fact, we probably don't

want to add just a convolutional layer, but another max-pool layer and relu layer, as well. For example, you might

insert a convolutional layer after the existing relu layer with a 5x5 spatial support followed by a max-pool over a 3x3

window with a stride of 2. You can reduce the max-pool window in the previous layer, adjust padding, and reduce the

spatial resolution of the final layer until vl_simplenn_display(net, 'inputSize', [64 64 1 50]) , which is called at the end

of hw7_cnn_init() shows that your network's final layer (not counting the softmax) has a data size of 1 and a data

depth of 15. You also need to make sure that the data depth output by any channel matches the data depth input to

the following channel. For instance, maybe your new convolutional layer takes in the 10 channels of the first layer but

outputs 15 channels. The final layer would then need to have its weights initialized accordingly to account for the fact

that it operates on a 15 channel image instead of a 10 channel image.

Training deeper networks is tricky. The networks are slower to train and more sensitive to initialization and learning

rate. For now, try to add one or two more blocks of "conv / pool / relu" and see if you can simply match your

performance of the previous section.

Problem 5: Our "deep" network is slow to train and brittle.

You might have noticed that your deeper network doesn't seem to learn very reasonable filters in the first layer. It is

harder for the gradients to pass from the last layer all the way to the first in a deeper architecture. Normalization can

help. In particular, let's add a batch normalization (https://arxiv.org/abs/1502.03167) layer after each convolutional

layer except for the last. So if you have 4 total convolutional layers we will add 3 batch normalization layers.

Add the following code to hw7_cnn_init(). You can call this function to add batch normalization to your conv layers

after you've built your network. Be careful with the layer indexing, because calling net = insertBnorm(net,

layer_index) will add a new layer and thus shift the index of later convolutional layers.

% --------------------------------------------------------------------

function net = insertBnorm(net, l)

% --------------------------------------------------------------------

assert(isfield(net.layers{l}, 'weights'));

ndim = size(net.layers{l}.weights{1}, 4);

layer = struct('type', 'bnorm', ...

'weights', {{ones(ndim, 1, 'single'), zeros(ndim, 1, 'single')}}, ...

'learningRate', [1 1 0.05], ...

'weightDecay', [0 0]) ;

net.layers{l}.weights{2} = [] ; % eliminate bias in previous conv layer

net.layers = horzcat(net.layers(1:l), layer, net.layers(l+1:end)) ;

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 11/12

Batch normalization by itself won't necessarily increase accuracy, but it will allow you to use much higher learning

rates. Try increasing your learning rate by a factor of 10 or even 100 and now you can rapidly explore and train

different network architectures. Notice how the first layer filters start to show structure quickly with batch

normalization.

We leave it up to you to determine the specifics of your deeper network: number of layers, number of filters in each

layer, size of filters in each layer, padding, max-pooling, stride, dropout factor, etc. It is not required that your deeper

network increases accuracy over the shallow network (but it can with the right hyperparameters). As long as you can

achieve 50% test accuracy for some epoch with a deeper network which uses mirroring to jitter, zero-centers the

images as they are loaded, and regularizes the network with a dropout layer you will receive full credit. Try to keep the

total training time under 10 minutes. You can achieve high accuracy in 100 epochs and in less in less than 10

minutes.

Additional optional improvements

Enjoy chasing higher accuracy? Here's some optional directions to investigate which might help improve your

accuracy.

If you look at MatConvNet's ImageNet examples you can see that the learning rate isn't constant during training.

You can specify learning rate as pts.learningRate = logspace(-3, -5, 120) to have it change from .001 to .00001 over

120 training epochs, for instance. This form of learning rate schedule can improve performance slightly.

You can try increasing the filter depth of the network. The example networks for MNIST, CIFAR, and ImageNet

have 20, 32, and 64 filters in the first layer and it tends to increase as you go up the network.

The MNIST, CIFAR, and ImageNet examples in MatConvNet show numerous advanced strategies: Use of

normalization layers, variable learning rate per layer (the two elements of the per-layer learning rate

in cnn_cifar_init.m are the relative learning rates for the filters and the bias terms), use of average pooling instead

of max pooling for some layers, initializing weights with distributions other than randn , more dramatic jittering, etc.

The more free parameters your network has the more prone to overfitting it is. Multiple dropout layers can help

fight back against this, but will slow down training considerably.

One obvious limitation of our network is that it operates on 64x64 images when the scene images are generally

closer to 256x256. We're definitely losing valuable texture information by working at low resolution. Luckily, it's not

necessarily slow to work with the higher resolution images if you put a greater-than-one stride in your first

convolutional layer. The VGG-F network adopts this strategy. You can see in cnn_imagenet_init.m that its first layer

uses 11x11 filters with a stride of 4. This is 1/16th as many evaluations as a stride of 1.

The images can be normalized more strongly (e.g. making them have unit standard deviation) but this did not help

in my experiments.

You can try alternate loss layers at the top of your network. E.g. net.layers{end+1} = struct('name', 'hinge loss',

'type', 'loss', 'loss', 'mhinge') for hinge loss.

You can train the VGG-F network from scratch on the 15 scene database. You can call cnn_imagenet_init.m to get a

randomly initialized VGG-F and train it just like your other networks. It works better than I would expect considering

how little training data we have.

The best accuracy you can expect to achieve is 67.6% in 100 epochs, without any data augmentation beyond

mirroring and without changing the input resolution.

Write up

2018/11/22 Homework Seven (Grads Only)

https://elearning.mines.edu/courses/9621/assignments/41937 12/12

For this project, submit a PDF project report. In the report you will describe your algorithm and any decisions you

made to write your algorithm a particular way. Then you will show and discuss the results of your algorithm. We

suggest showing results plots (Matlab figure 1) and filter visualization (Matlab figure 2) as needed. In addition, submit

an archive containing all your code for this assignment. Do not hand in any networks, training data, or MatConvNet

itself! You only need to hand in 3 source files: hw7.m, hw7_cnn_init.m, and hw7_setup_data.m . You can of course hand in

any helper functions you created.

All turn-in files should be compiled into a single archive (e.g., .zip).

Credits: The design of this homework assignment comes from Georgia Tech's CV course.