1 - 引言

之前我們介紹了LeNet-5和AlexNet，在AlexNet發明之後，卷積神經網路的層數開始越來越複雜，VGG-16就是一個相對前面2個經典卷積神經網路模型層數明顯更多了。

VGGNet是牛津大學計算機視覺組（Visual Geometry Group）和Google DeepMind公司的研究員一起研發的深度卷積神經網路。

VGGNet探索了卷積神經網路的深度與其效能之間的關係，通過反覆堆疊33的小型卷積核和22的最大池化層，

VGGNet成功地構築了16~19層深的卷積神經網路。VGGNet相比之前state-of-the-art的網路結構，錯誤率大幅下降，

VGGNet論文中全部使用了 $3*3$的小型卷積核和 $2\ast 2$

VGG最大的優點或者說是創新之處在於：
VGGNet通過反覆堆疊3x3的小型卷積核和2x2的最大池化層，構築了16~19層深的神經網路。在錯誤率大大降低的同時擴充套件性很強，遷移到其它圖片資料上的泛化能力很好，而且結構簡單。

VGGNet擁有從A到E的五個級別，每一級網路都比前一級根深，但是引數並沒有增加很多，因為卷積部分消耗參量不大，主要在全連線層。D和E就是常說的VGGNet-16和VGGNet-19。

VGGNet擁有5段卷積，每一段卷積內有2~3個卷積層，同時每段尾部都會連線一個最大池化層用來縮小圖片尺寸，5段卷積後有3個全連線層，然後通過softmax(）來預測結果。

是一種雖然結構搭建簡單卻效能十分優異的卷積網路模型。

2 - VGG結構

訓練輸入為224224大小的RGB影象，需要減去影象均值。用一堆 $3*3,1*1$小卷積核進行卷積，連線max pooling。最後，連線3個全連線層，softmax分類器。

模型A-E：只增加深度，其他不變（增加33卷積核）

在吳恩達課程中，詳細的介紹了VGG-16的模型結構：

輸入是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]

3 - TensorFlow搭建VGG-16模型：

# _*_ 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