cs231n 2018 Lecture09

Fei-Fei Li & Justin Johnson & Serena Yeung Lecture 9 - 1 May 1, 2018
Administrative
A2 due Wed May 2
Midterm: In-class Tue May 8. Covers material through

Lecture 10 (Thu May 3).
Sample midterm released on piazza.
Midterm review session: Fri May 4 discussion section
Last time: Deep learning frameworks
PaddlePaddle Chainer
(Baidu)
Caffe Caffe2
(UC Berkeley) (Facebook) MXNet
(Amazon)
CNTK
Developed by U Washington, CMU, MIT,
Hong Kong U, etc but main framework of
(Microsoft)
Torch PyTorch choice at AWS
(NYU / Facebook) (Facebook)

Deeplearning4j
Theano TensorFlow
(U Montreal) (Google)
And others...
Last time: Deep learning frameworks
(1) Easily build big computational graphs

(2) Easily compute gradients in computational graphs
(3) Run it all efficiently on GPU (wrap cuDNN, cuBLAS, etc)
Today: CNN Architectures
Case Studies
- AlexNet
- VGG
- GoogLeNet
- ResNet
Also....
- NiN (Network in Network) - DenseNet
- Wide ResNet - FractalNet
- ResNeXT - SqueezeNet
- Stochastic Depth - NASNet
- Squeeze-and-Excitation Network
Review: LeNet-5
[LeCun et al., 1998]
Conv filters were 5x5, applied at stride 1

Subsampling (Pooling) layers were 2x2 applied at stride 2
i.e. architecture is [CONV-POOL-CONV-POOL-FC-FC]
Case Study: AlexNet
[Krizhevsky et al. 2012]
Architecture:
CONV1
MAX POOL1
NORM1
CONV2
MAX POOL2
NORM2
CONV3
CONV4
CONV5
Max POOL3
FC6
FC7
FC8
Case Study: AlexNet
Input: 227x227x3 images
First layer (CONV1): 96 11x11 filters applied at stride 4

=>
Q: what is the output volume size? Hint: (227-11)/4+1 = 55
Case Study: AlexNet

=>
Output volume [55x55x96]
Q: What is the total number of parameters in this layer?
Case Study: AlexNet

=>
Output volume [55x55x96]
Parameters: (11*11*3)*96 = 35K
Case Study: AlexNet

After CONV1: 55x55x96
Second layer (POOL1): 3x3 filters applied at stride 2
Q: what is the output volume size? Hint: (55-3)/2+1 = 27
Case Study: AlexNet


Output volume: 27x27x96
Q: what is the number of parameters in this layer?
Case Study: AlexNet


Output volume: 27x27x96
Parameters: 0!
Case Study: AlexNet

After POOL1: 27x27x96
...
Case Study: AlexNet
Full (simplified) AlexNet architecture:

[227x227x3] INPUT
[55x55x96] CONV1: 96 11x11 filters at stride 4, pad 0
[27x27x96] MAX POOL1: 3x3 filters at stride 2
[27x27x96] NORM1: Normalization layer
[4096] FC6: 4096 neurons
[4096] FC7: 4096 neurons
[1000] FC8: 1000 neurons (class scores)
Case Study: AlexNet

[227x227x3] INPUT
Details/Retrospectives:
- first use of ReLU
- used Norm layers (not common anymore)
- heavy data augmentation
- dropout 0.5
- batch size 128
- SGD Momentum 0.9
- Learning rate 1e-2, reduced by 10
manually when val accuracy plateaus
- L2 weight decay 5e-4
[4096] FC6: 4096 neurons
- 7 CNN ensemble: 18.2% -> 15.4%
[4096] FC7: 4096 neurons
Case Study: AlexNet

[227x227x3] INPUT
[55x55x48] x 2
[27x27x256] CONV2: 256 5x5 filters at stride 1, pad 2 Historical note: Trained on GTX 580
[13x13x256] MAX POOL2: 3x3 filters at stride 2 GPU with only 3 GB of memory.
[13x13x256] NORM2: Normalization layer Network spread across 2 GPUs, half
[13x13x384] CONV3: 384 3x3 filters at stride 1, pad 1 the neurons (feature maps) on each
[13x13x384] CONV4: 384 3x3 filters at stride 1, pad 1 GPU.
[4096] FC6: 4096 neurons
[4096] FC7: 4096 neurons
Case Study: AlexNet

[227x227x3] INPUT
[27x27x96] NORM1: Normalization layer CONV1, CONV2, CONV4, CONV5:
[27x27x256] CONV2: 256 5x5 filters at stride 1, pad 2 Connections only with feature maps
[13x13x256] MAX POOL2: 3x3 filters at stride 2 on same GPU
[4096] FC6: 4096 neurons
[4096] FC7: 4096 neurons
Case Study: AlexNet

[227x227x3] INPUT
[27x27x96] NORM1: Normalization layer CONV3, FC6, FC7, FC8:
[27x27x256] CONV2: 256 5x5 filters at stride 1, pad 2 Connections with all feature maps in
[13x13x256] MAX POOL2: 3x3 filters at stride 2 preceding layer, communication
[13x13x256] NORM2: Normalization layer across GPUs
[4096] FC6: 4096 neurons
[4096] FC7: 4096 neurons
ImageNet Large Scale Visual Recognition Challenge (ILSVRC) winners
152 layers 152 layers 152 layers
19 layers 22 layers
shallow 8 layers 8 layers
First CNN-based winner 152 layers 152 layers 152 layers
19 layers 22 layers
ZFNet: Improved
hyperparameters over 152 layers 152 layers 152 layers
AlexNet
19 layers 22 layers
ZFNet [Zeiler and Fergus, 2013]
AlexNet but:
CONV1: change from (11x11 stride 4) to (7x7 stride 2)
CONV3,4,5: instead of 384, 384, 256 filters use 512, 1024, 512
ImageNet top 5 error: 16.4% -> 11.7%
Deeper Networks 152 layers 152 layers 152 layers
19 layers 22 layers
Case Study: VGGNet
[Simonyan and Zisserman, 2014]
Small filters, Deeper networks
8 layers (AlexNet)
-> 16 - 19 layers (VGG16Net)
Only 3x3 CONV stride 1, pad 1

and 2x2 MAX POOL stride 2
11.7% top 5 error in ILSVRC’13

(ZFNet)
-> 7.3% top 5 error in ILSVRC’14 AlexNet VGG16 VGG19
Case Study: VGGNet
Q: Why use smaller filters? (3x3 conv)
AlexNet VGG16 VGG19
Case Study: VGGNet
Stack of three 3x3 conv (stride 1) layers

has same effective receptive field as
one 7x7 conv layer
Q: What is the effective receptive field of

three 3x3 conv (stride 1) layers?
AlexNet VGG16 VGG19
Case Study: VGGNet

one 7x7 conv layer
[7x7]
AlexNet VGG16 VGG19
Case Study: VGGNet

one 7x7 conv layer
But deeper, more non-linearities
And fewer parameters: 3 * (32C2) vs.

72C2 for C channels per layer
AlexNet VGG16 VGG19
INPUT: [224x224x3] memory: 224*224*3=150K params: 0 (not counting biases)
CONV3-64: [224x224x64] memory: 224*224*64=3.2M params: (3*3*3)*64 = 1,728
POOL2: [112x112x64] memory: 112*112*64=800K params: 0
CONV3-256: [56x56x256] memory: 56*56*256=800K params: (3*3*128)*256 = 294,912
CONV3-512: [28x28x512] memory: 28*28*512=400K params: (3*3*256)*512 = 1,179,648
FC: [1x1x4096] memory: 4096 params: 7*7*512*4096 = 102,760,448
FC: [1x1x4096] memory: 4096 params: 4096*4096 = 16,777,216
FC: [1x1x1000] memory: 1000 params: 4096*1000 = 4,096,000 VGG16
TOTAL memory: 24M * 4 bytes ~= 96MB / image (for a forward pass)

TOTAL params: 138M parameters
CONV3-64: [224x224x64] memory: 224*224*64=3.2M params: (3*3*3)*64 = 1,728 Note:
CONV3-128: [112x112x128] memory: 112*112*128=1.6M params: (3*3*64)*128 = 73,728 Most memory is in
CONV3-128: [112x112x128] memory: 112*112*128=1.6M params: (3*3*128)*128 = 147,456 early CONV
POOL2: [14x14x512] memory: 14*14*512=100K params: 0 Most params are
CONV3-512: [14x14x512] memory: 14*14*512=100K params: (3*3*512)*512 = 2,359,296 in late FC
TOTAL memory: 24M * 4 bytes ~= 96MB / image (only forward! ~*2 for bwd)
TOTAL memory: 24M * 4 bytes ~= 96MB / image (only forward! ~*2 for bwd) Common names
Case Study: VGGNet
Details:
- ILSVRC’14 2nd in classification, 1st in
localization
- Similar training procedure as Krizhevsky
2012
- No Local Response Normalisation (LRN)
- Use VGG16 or VGG19 (VGG19 only
slightly better, more memory)
- Use ensembles for best results
- FC7 features generalize well to other
tasks
AlexNet VGG16 VGG19
Deeper Networks 152 layers 152 layers 152 layers
19 layers 22 layers
Case Study: GoogLeNet
[Szegedy et al., 2014]
Deeper networks, with computational

efficiency
- 22 layers
- Efficient “Inception” module
- No FC layers
- Only 5 million parameters!
12x less than AlexNet Inception module
- ILSVRC’14 classification winner
(6.7% top 5 error)
“Inception module”: design a

good local network topology
(network within a network) and
then stack these modules on
top of each other
Inception module
Apply parallel filter operations on

the input from previous layer:
- Multiple receptive field sizes
for convolution (1x1, 3x3,
5x5)
- Pooling operation (3x3)
Concatenate all filter outputs

Naive Inception module together depth-wise
Apply parallel filter operations on

the input from previous layer:
- Multiple receptive field sizes
for convolution (1x1, 3x3,
5x5)
- Pooling operation (3x3)
Concatenate all filter outputs

Naive Inception module together depth-wise
Q: What is the problem with this?

[Hint: Computational complexity]
Case Study: GoogLeNet Q: What is the problem with this?
[Szegedy et al., 2014] [Hint: Computational complexity]
Example:
Module input:
28x28x256
Naive Inception module
Q1: What is the output size of the

Example: 1x1 conv, with 128 filters?
Module input:
28x28x256
Q1: What is the output size of the

Example: 1x1 conv, with 128 filters?
28x28x128
Module input:
28x28x256
Q2: What are the output sizes of

Example: all different filter operations?
28x28x128
Module input:
28x28x256
Q2: What are the output sizes of

Example: all different filter operations?
28x28x128 28x28x192 28x28x96 28x28x256
Module input:
28x28x256
Q3:What is output size after

Example: filter concatenation?
28x28x128 28x28x192 28x28x96 28x28x256
Module input:
28x28x256

28x28x(128+192+96+256) = 28x28x672
28x28x128 28x28x192 28x28x96 28x28x256
Module input:
28x28x256

Conv Ops:
28x28x(128+192+96+256) = 28x28x672 [1x1 conv, 128] 28x28x128x1x1x256
[3x3 conv, 192] 28x28x192x3x3x256
[5x5 conv, 96] 28x28x96x5x5x256
28x28x128 28x28x192 28x28x96 28x28x256 Total: 854M ops
Module input:
28x28x256

Conv Ops:
28x28x(128+192+96+256) = 28x28x672 [1x1 conv, 128] 28x28x128x1x1x256
[3x3 conv, 192] 28x28x192x3x3x256
[5x5 conv, 96] 28x28x96x5x5x256
28x28x128 28x28x192 28x28x96 28x28x256 Total: 854M ops
Very expensive compute
Module input: Pooling layer also preserves feature

28x28x256 depth, which means total depth after
concatenation can only grow at every
layer!

28x28x(128+192+96+256) = 529k Solution: “bottleneck” layers that

use 1x1 convolutions to reduce
28x28x128 28x28x192 28x28x96 28x28x256
feature depth
Module input:
28x28x256
Reminder: 1x1 convolutions
1x1 CONV
56 with 32 filters
56
(each filter has size
1x1x64, and performs a
64-dimensional dot
56 product)
56
64 32
Reminder: 1x1 convolutions
1x1 CONV
56 with 32 filters
56
preserves spatial
dimensions, reduces depth!
56 Projects depth to lower 56

64 dimension (combination of 32
feature maps)

Inception module with dimension reduction
1x1 conv “bottleneck”
layers

Case Study: GoogLeNet Using same parallel layers as
naive example, and adding “1x1
conv, 64 filter” bottlenecks:
28x28x480
Conv Ops:
[1x1 conv, 64] 28x28x64x1x1x256
[1x1 conv, 64] 28x28x64x1x1x256
28x28x128 28x28x192 28x28x96 28x28x64
[1x1 conv, 128] 28x28x128x1x1x256
[3x3 conv, 192] 28x28x192x3x3x64
[5x5 conv, 96] 28x28x96x5x5x64
28x28x64 28x28x64 28x28x256
[1x1 conv, 64] 28x28x64x1x1x256
Total: 358M ops
Module input: Compared to 854M ops for naive version

28x28x256 Bottleneck can also reduce depth after
pooling layer
Stack Inception modules

with dimension reduction
on top of each other
Inception module
Full GoogLeNet
architecture
Stem Network:
Conv-Pool-
2x Conv-Pool
Full GoogLeNet
architecture
Stacked Inception
Modules
Full GoogLeNet
architecture
Classifier output
Full GoogLeNet
architecture
Classifier output
(removed expensive FC layers!)
Full GoogLeNet
architecture
Auxiliary classification outputs to inject additional gradient at lower layers

(AvgPool-1x1Conv-FC-FC-Softmax)
Full GoogLeNet
architecture
22 total layers with weights

(parallel layers count as 1 layer => 2 layers per Inception module. Don’t count auxiliary output layers)
Deeper networks, with computational

efficiency
- 22 layers
- Efficient “Inception” module
- No FC layers
- 12x less params than AlexNet
- ILSVRC’14 classification winner Inception module
(6.7% top 5 error)
“Revolution of Depth”
19 layers 22 layers
Case Study: ResNet
[He et al., 2015]
relu
Very deep networks using residual F(x) + x
connections
..
.
- 152-layer model for ImageNet X
F(x) relu
- ILSVRC’15 classification winner identity
(3.57% top 5 error)
- Swept all classification and
detection competitions in X
ILSVRC’15 and COCO’15! Residual block
Case Study: ResNet
[He et al., 2015]
What happens when we continue stacking deeper layers on a “plain” convolutional

neural network?
Case Study: ResNet
[He et al., 2015]

neural network?
Q: What’s strange about these training and test curves?

[Hint: look at the order of the curves]
Case Study: ResNet
[He et al., 2015]

neural network?
56-layer model performs worse on both training and test error

-> The deeper model performs worse, but it’s not caused by overfitting!
Case Study: ResNet
[He et al., 2015]
Hypothesis: the problem is an optimization problem, deeper models are harder to

optimize
Case Study: ResNet
[He et al., 2015]
Hypothesis: the problem is an optimization problem, deeper models are harder to

optimize
The deeper model should be able to perform at

least as well as the shallower model.
A solution by construction is copying the learned

layers from the shallower model and setting
additional layers to identity mapping.
Case Study: ResNet
[He et al., 2015]
Solution: Use network layers to fit a residual mapping instead of directly trying to fit a
desired underlying mapping
relu
H(x) F(x) + x
F(x) X
relu relu
identity
X X
“Plain” layers Residual block
Case Study: ResNet
[He et al., 2015]
Solution: Use network layers to fit a residual mapping instead of directly trying to fit a
desired underlying mapping
H(x) = F(x) + x relu
H(x) F(x) + x
Use layers to
fit residual
F(x) X F(x) = H(x) - x
relu relu
identity
instead of
H(x) directly
X X
“Plain” layers Residual block
Case Study: ResNet
[He et al., 2015]
Full ResNet architecture:

relu
- Stack residual blocks
F(x) + x
- Every residual block has ..
two 3x3 conv layers .
F(x) X
relu
identity
X
Residual block
Case Study: ResNet
[He et al., 2015]

relu
F(x) + x
- Periodically, double # of 3x3 conv, 128

filters and downsample F(x) X filters, /2
relu
identity spatially with
spatially using stride 2 stride 2
(/2 in each dimension)
3x3 conv, 64
filters
X
Residual block
Case Study: ResNet
[He et al., 2015]

relu
F(x) + x
- Periodically, double # of
filters and downsample F(x) X
relu
identity
spatially using stride 2
- Additional conv layer at
the beginning X
Residual block
Beginning
conv layer
Case Study: ResNet No FC layers
besides FC
1000 to
[He et al., 2015] output
classes
Full ResNet architecture: Global

relu average
- Stack residual blocks pooling layer
F(x) + x
after last
conv layer
- Periodically, double # of
filters and downsample F(x) X
relu
identity
spatially using stride 2
- Additional conv layer at
the beginning X
- No FC layers at the end Residual block
(only FC 1000 to output
classes)
Case Study: ResNet
[He et al., 2015]
Total depths of 34, 50, 101, or

..
152 layers for ImageNet .
Case Study: ResNet
[He et al., 2015]
For deeper networks

(ResNet-50+), use “bottleneck”
layer to improve efficiency
(similar to GoogLeNet)
Case Study: ResNet
[He et al., 2015]
1x1 conv, 256 filters projects

back to 256 feature maps
For deeper networks (28x28x256)
(ResNet-50+), use “bottleneck”
layer to improve efficiency 3x3 conv operates over
(similar to GoogLeNet) only 64 feature maps
1x1 conv, 64 filters

to project to
28x28x64
Case Study: ResNet
[He et al., 2015]
Training ResNet in practice:
- Batch Normalization after every CONV layer

- Xavier 2/ initialization from He et al.
- SGD + Momentum (0.9)
- Learning rate: 0.1, divided by 10 when validation error plateaus
- Mini-batch size 256
- Weight decay of 1e-5
- No dropout used
Case Study: ResNet
[He et al., 2015]
Experimental Results
- Able to train very deep
networks without degrading
(152 layers on ImageNet, 1202
on Cifar)
- Deeper networks now achieve
lowing training error as
expected
- Swept 1st place in all ILSVRC
and COCO 2015 competitions
Case Study: ResNet
[He et al., 2015]
Experimental Results
- Able to train very deep
networks without degrading
(152 layers on ImageNet, 1202
on Cifar)
- Deeper networks now achieve
lowing training error as
expected
- Swept 1st place in all ILSVRC
and COCO 2015 competitions
ILSVRC 2015 classification winner (3.6%
top 5 error) -- better than “human
performance”! (Russakovsky 2014)
19 layers 22 layers
Comparing complexity...
An Analysis of Deep Neural Network Models for Practical Applications, 2017.
Figures copyright Alfredo Canziani, Adam Paszke, Eugenio Culurciello, 2017. Reproduced with permission.
Comparing complexity... Inception-v4: Resnet + Inception!
VGG: Highest
Comparing complexity... memory, most
operations
GoogLeNet:
Comparing complexity... most efficient
AlexNet:
Comparing complexity... Smaller compute, still memory
heavy, lower accuracy
ResNet:
Comparing complexity... Moderate efficiency depending on
model, highest accuracy
Forward pass time and power consumption
Other architectures to know...
Network in Network (NiN)
[Lin et al. 2014]
- Mlpconv layer with

“micronetwork” within each conv
layer to compute more abstract
features for local patches
- Micronetwork uses multilayer
perceptron (FC, i.e. 1x1 conv
layers)
- Precursor to GoogLeNet and
ResNet “bottleneck” layers
- Philosophical inspiration for
GoogLeNet
Figures copyright Lin et al., 2014. Reproduced with permission.
Improving ResNets...
Identity Mappings in Deep Residual Networks

[He et al. 2016]
- Improved ResNet block design from

creators of ResNet
- Creates a more direct path for
propagating information throughout
network (moves activation to residual
mapping pathway)
- Gives better performance
Wide Residual Networks

[Zagoruyko et al. 2016]
- Argues that residuals are the

important factor, not depth
- User wider residual blocks (F x k
filters instead of F filters in each layer)
- 50-layer wide ResNet outperforms
152-layer original ResNet
- Increasing width instead of depth
more computationally efficient Basic residual block Wide residual block
(parallelizable)
Aggregated Residual Transformations for Deep
Neural Networks (ResNeXt)
[Xie et al. 2016]
- Also from creators of

ResNet
- Increases width of
residual block through
multiple parallel
pathways
(“cardinality”)
- Parallel pathways
similar in spirit to
Inception module
Deep Networks with Stochastic Depth
[Huang et al. 2016]
- Motivation: reduce vanishing gradients and

training time through short networks during
training
- Randomly drop a subset of layers during each
training pass
- Bypass with identity function
- Use full deep network at test time
Network ensembling
19 layers 22 layers
“Good Practices for Deep Feature Fusion”
[Shao et al. 2016]
- Multi-scale ensembling of Inception, Inception-Resnet, Resnet,

Wide Resnet models
- ILSVRC’16 classification winner
Adaptive feature map reweighting
19 layers 22 layers
Squeeze-and-Excitation Networks (SENet)
[Hu et al. 2017]
- Add a “feature recalibration” module that

learns to adaptively reweight feature maps
- Global information (global avg. pooling
layer) + 2 FC layers used to determine
feature map weights
- ILSVRC’17 classification winner (using
ResNeXt-152 as a base architecture)
Beyond ResNets...
FractalNet: Ultra-Deep Neural Networks without Residuals
[Larsson et al. 2017]
- Argues that key is transitioning

effectively from shallow to deep
and residual representations are
not necessary
- Fractal architecture with both
shallow and deep paths to output
- Trained with dropping out
sub-paths
- Full network at test time
Figures copyright Larsson et al., 2017. Reproduced with permission.
10
Fei-Fei Li & Justin Johnson & Serena Yeung Lecture 9 - May 1, 2018
0
Beyond ResNets...
Densely Connected Convolutional Networks
[Huang et al. 2017]
- Dense blocks where each layer is

connected to every other layer in
feedforward fashion
- Alleviates vanishing gradient,
strengthens feature propagation,
encourages feature reuse
Efficient networks...
SqueezeNet: AlexNet-level Accuracy With 50x Fewer
Parameters and <0.5Mb Model Size
[Iandola et al. 2017]
- Fire modules consisting of a

‘squeeze’ layer with 1x1 filters
feeding an ‘expand’ layer with 1x1
and 3x3 filters
- AlexNet level accuracy on
ImageNet with 50x fewer
parameters
- Can compress to 510x smaller
than AlexNet (0.5Mb) Figure copyright Iandola, Han, Moskewicz, Ashraf, Dally, Keutzer, 2017. Reproduced with permission.
Meta-learning: Learning to learn network architectures...
Neural Architecture Search with Reinforcement Learning (NAS)
[Zoph et al. 2016]
- “Controller” network that learns to design a good

network architecture (output a string
corresponding to network design)
- Iterate:
1) Sample an architecture from search space
2) Train the architecture to get a “reward” R
corresponding to accuracy
3) Compute gradient of sample probability, and
scale by R to perform controller parameter
update (i.e. increase likelihood of good
architecture being sampled, decrease
likelihood of bad architecture)
10
3
Meta-learning: Learning to learn network architectures...
Learning Transferable Architectures for Scalable Image
Recognition
[Zoph et al. 2017]
- Applying neural architecture search (NAS) to a
large dataset like ImageNet is expensive
- Design a search space of building blocks (“cells”)
that can be flexibly stacked
- NASNet: Use NAS to find best cell structure on
smaller CIFAR-10 dataset, then transfer
architecture to ImageNet
10
4
Summary: CNN Architectures
Case Studies
- AlexNet
- VGG
- GoogLeNet
- ResNet
Also....
- NiN (Network in Network) - DenseNet
- Wide ResNet - FractalNet
- ResNeXT - SqueezeNet
- Stochastic Depth - NASNet
- Squeeze-and-Excitation Network
10
5
Summary: CNN Architectures
- VGG, GoogLeNet, ResNet all in wide use, available in model zoos
- ResNet current best default, also consider SENet when available
- Trend towards extremely deep networks
- Significant research centers around design of layer / skip
connections and improving gradient flow
- Efforts to investigate necessity of depth vs. width and residual
connections
- Even more recent trend towards meta-learning
- Next time: Recurrent neural networks

cs231n 2018 Lecture09

Uploaded by

Copyright:

Available Formats

cs231n 2018 Lecture09

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

cs231n 2018 Lecture09

Uploaded by

Copyright:

Available Formats

Fei-Fei Li & Justin Johnson & Serena Yeung Lecture 9 - 1 May 1, 2018

Midterm: In-class Tue May 8. Covers material through

Sample midterm released on piazza.

Midterm review session: Fri May 4 discussion section

(NYU / Facebook) (Facebook)

(1) Easily build big computational graphs

Conv filters were 5x5, applied at stride 1

Input: 227x227x3 images

First layer (CONV1): 96 11x11 filters applied at stride 4

Input: 227x227x3 images

First layer (CONV1): 96 11x11 filters applied at stride 4

Q: What is the total number of parameters in this layer?

Input: 227x227x3 images

First layer (CONV1): 96 11x11 filters applied at stride 4

Input: 227x227x3 images

Second layer (POOL1): 3x3 filters applied at stride 2

Q: what is the output volume size? Hint: (55-3)/2+1 = 27

Input: 227x227x3 images

Second layer (POOL1): 3x3 filters applied at stride 2

Q: what is the number of parameters in this layer?

Input: 227x227x3 images

Second layer (POOL1): 3x3 filters applied at stride 2

Input: 227x227x3 images

Full (simplified) AlexNet architecture:

Full (simplified) AlexNet architecture:

Full (simplified) AlexNet architecture:

Full (simplified) AlexNet architecture:

Full (simplified) AlexNet architecture:

152 layers 152 layers 152 layers

shallow 8 layers 8 layers

First CNN-based winner 152 layers 152 layers 152 layers

shallow 8 layers 8 layers

shallow 8 layers 8 layers

Deeper Networks 152 layers 152 layers 152 layers

shallow 8 layers 8 layers

Small filters, Deeper networks

Only 3x3 CONV stride 1, pad 1

11.7% top 5 error in ILSVRC’13

Q: Why use smaller filters? (3x3 conv)

AlexNet VGG16 VGG19

Q: Why use smaller filters? (3x3 conv)

Stack of three 3x3 conv (stride 1) layers

Q: What is the effective receptive field of

AlexNet VGG16 VGG19

Q: Why use smaller filters? (3x3 conv)

Stack of three 3x3 conv (stride 1) layers

AlexNet VGG16 VGG19

Q: Why use smaller filters? (3x3 conv)

Stack of three 3x3 conv (stride 1) layers

But deeper, more non-linearities

And fewer parameters: 3 * (32C2) vs.

TOTAL memory: 24M * 4 bytes ~= 96MB / image (for a forward pass)

Deeper Networks 152 layers 152 layers 152 layers

shallow 8 layers 8 layers

Deeper networks, with computational

“Inception module”: design a

Apply parallel filter operations on

Concatenate all filter outputs

Apply parallel filter operations on