VGGNet通过反复堆叠3×3的小型卷积核和2×2的最大池化层，构筑了16~19层深的神经网络。在错误率大大降低的同时扩展性很强，迁移到其它图片数据上的泛化能力很好，而且结构简单。

VGGNet拥有从A到E的五个级别，每一级网络都比前一级根深，但是参数并没有增加很多，因为卷积部分消耗参量不大，主要在全连接层。D和E就是常说的VGGNet-16和VGGNet-19。

VGGNet拥有5段卷积，每一段卷积内有2~3个卷积层，同时每段尾部都会连接一个最大池化层用来缩小图片尺寸，5段卷积后有3个全连接层，然后通过softmax(）来预测结果。

总结一些关键点：

1. 在级别C中有几个1×1的卷积层，1×1的卷积的意义主要在于线性变换，因为输入通道数和输出通道数不变，没有发生降维。
2. VGGNet中经常出现多个完全一样的3×3的卷积层堆叠在一起的情况，因为两个3×3的卷积层串联相当于1个5×5的卷积层，即一个像素会跟周围5×5的像素产生联系，可以说感受视野大小为5×5。
   首先，2个串联的3×3卷积层（2×9个参数）拥有比1个5×5的卷积层(25个参数）更少的参数量；其次，2个串联的3×3卷积层（使用2次ReLU激活函数）拥有比1个5×5的卷积层（使用1次ReLU激活函数）更多的非线性变换，使得学习能力更强。
3. 使用Mutlti-Scale的方法做数据增强，将原始图像缩放到不同的尺寸S然后随机剪裁程224×224的图片，这样可以增加更多的数据量，对防止模型过拟合有很不错的效果。
   同时作者另S的取值在[256, 512]这个区间内取值，可以获得更多版本的数据，然后一起训练。
4. VGGNet的模型参数虽然比AlexNet多，但反而只需要较少的迭代次数就可以收敛，主要原因是更深的网络和更小的卷积核带来的隐式的正则化效果。

作者提出了以下几个观点：
1. LRN层作用不大
2. 越深的网络效果越好
3. 1x1的卷积也是很有效的， 但没有3x3的卷积好，大一些的卷积核可以学习更大的空间特征。

输入是224x224x3的图像，下面是每一层的大小：
conv1_1 [32, 224, 224, 64]
conv1_2 [32, 224, 224, 64]
pool1 [32, 112, 112, 64]
conv2_1 [32, 112, 112, 128]
conv2_2 [32, 112, 112, 128]
pool2 [32, 56, 56, 128]
conv3_1 [32, 56, 56, 256]
conv3_2 [32, 56, 56, 256]
conv3_3 [32, 56, 56, 256]
pool3 [32, 28, 28, 256]
conv4_1 [32, 28, 28, 512]
conv4_2 [32, 28, 28, 512]
conv4_3 [32, 28, 28, 512]
pool4 [32, 14, 14, 512]
conv5_1 [32, 14, 14, 512]
conv5_2 [32, 14, 14, 512]
conv5_3 [32, 14, 14, 512]
pool5 [32, 7, 7, 512]
fc6 [32, 4096]
fc7 [32, 4096]
fc8 [32, 1000]

下面是使用Tensorflow的实现：

# _*_ coding:utf-8 _*_

import math
import time
import tensorflow as tf
from datetime import datetime

batch_size = 32
num_batches = 100

# 卷积层
'''
    input_op输入的tensor
    kh, kw是卷积核的高和宽
    dh, w是步长到的高和宽
    p参数列表
'''
def conv_op(input_op, name, kh, kw, n_out, dh, dw, p):
    n_in = input_op.get_shape()[-1].value

    with tf.name_scope(name) as scope:
        kernel = tf.get_variable(scope+'w',
                                 shape=[kh, kw, n_in, n_out], dtype=tf.float32,
                                 initializer=tf.contrib.layers.xavier_initializer_conv2d())
        conv = tf.nn.conv2d(input_op, kernel, strides=[1, dh, dw, 1], padding='SAME')
        biases = tf.Variable(tf.constant(0.0, shape=[n_out], dtype=tf.float32), trainable=True, name='biases')
        z = tf.nn.bias_add(conv, biases)
        activation = tf.nn.relu(z, name=scope)
        p += [kernel, biases]

    return activation

# 全连接层
def fc_op(input_op, name, n_out, p):
    n_in = input_op.get_shape()[-1].value

    with tf.name_scope(name) as scope:
        kernel = tf.get_variable(scope+'w',
                                 shape=[n_in, n_out], dtype=tf.float32,
                                 initializer=tf.contrib.layers.xavier_initializer())
        biases = tf.Variable(tf.constant(0.1, shape=[n_out], dtype=tf.float32), trainable=True, name='biases')
        activation = tf.nn.relu_layer(input_op, kernel, biases, name=scope)
        p += [kernel, biases]

    return activation

# 最大池化层
def mpool_op(input_op, name, kh, kw, dh, dw):
    return tf.nn.max_pool(input_op,
                          ksize=[1, kh, kw, 1],
                          strides=[1, dh, dw, 1],
                          padding='SAME',
                          name=name)

# 网络结构
def inference_op(input_op, keep_prob):
    parameters = []

    # 第一段卷积网络
    conv1_1 = conv_op(input_op, name='conv1_1', kh=3, kw=3, n_out=64, dh=1, dw=1, p=parameters)
    conv1_2 = conv_op(conv1_1, name='conv1_2', kh=3, kw=3, n_out=64, dh=1, dw=1, p=parameters)
    pool1 = mpool_op(conv1_2, name='pool1', kh=2, kw=2, dw=2, dh=2)

    # 第二段卷积网络
    conv2_1 = conv_op(pool1, name='conv2_1', kh=3, kw=3, n_out=128, dh=1, dw=1, p=parameters)
    conv2_2 = conv_op(conv2_1, name='conv2_2', kh=3, kw=3, n_out=128, dh=1, dw=1, p=parameters)
    pool2 = mpool_op(conv2_2, name='pool2', kh=2, kw=2, dh=2, dw=2)

    # 第三段卷积网络
    conv3_1 = conv_op(pool2, name='conv3_1', kh=3, kw=3, n_out=256, dh=1, dw=1, p=parameters)
    conv3_2 = conv_op(conv3_1, name='conv3_2', kh=3, kw=3, n_out=256, dh=1, dw=1, p=parameters)
    conv3_3 = conv_op(conv3_2, name='conv3_3', kh=3, kw=3, n_out=256, dh=1, dw=1, p=parameters)
    pool3 = mpool_op(conv3_3, name='pool3', kh=2, kw=2, dh=2, dw=2)

    # 第四段卷积网络
    conv4_1 = conv_op(pool3, name='conv4_1', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
    conv4_2 = conv_op(conv4_1, name='conv4_2', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
    conv4_3 = conv_op(conv4_2, name='conv4_3', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
    pool4 = mpool_op(conv4_3, name='pool4', kh=2, kw=2, dh=2, dw=2)

    # 第五段卷积网络
    conv5_1 = conv_op(pool4, name='conv5_1', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
    conv5_2 = conv_op(conv5_1, name='conv5_1', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
    conv5_3 = conv_op(conv5_2, name='conv5_3', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
    pool5 = mpool_op(conv5_3, name='conv5_3', kh=2, kw=2, dh=2, dw=2)

    # 扁平化
    shp = pool5.get_shape()
    flattened_shape = shp[1].value * shp[2].value * shp[3].value
    resh1 = tf.reshape(pool5, [-1, flattened_shape], name='resh1')

    # 全连接层
    fc6 = fc_op(resh1, name='fc6', n_out=4096, p=parameters)
    fc6_drop = tf.nn.dropout(fc6, keep_prob, name='fc6_drop')
    fc7 = fc_op(fc6_drop, name='fc7', n_out=4096, p=parameters)
    fc7_drop = tf.nn.dropout(fc7, keep_prob, name='fc7_drop')
    fc8 = fc_op(fc7_drop, name='fc8', n_out=1000, p=parameters)
    softmax = tf.nn.softmax(fc8)
    predictions = tf.argmax(softmax, 1)

    return predictions, softmax, fc8, parameters