第二十四节，TensorFlow下slim库函数的使用以及使用VGG网络进行预训练、迁移学习(附代码)

在介绍这一节之前，需要你对slim模型库有一些基本了解，具体可以参考第二十二节，TensorFlow中的图片分类模型库slim的使用、数据集处理，这一节我们会详细介绍slim模型库下面的一些函数的使用。

一 简介

slim被放在tensorflow.contrib这个库下面，导入的方法如下：

import tensorflow.contrib.slim as slim

这样我们就可以使用slim了，既然说到了，先来了解tensorflow.contrib这个库，tensorflow官方对它的描述是：此目录中的任何代码未经官方支持，可能会随时更改或删除。每个目录下都有指定的所有者。它旨在包含额外功能和贡献，最终会合并到核心TensorFlow中，但其接口可能仍然会发生变化，或者需要进行一些测试，看是否可以获得更广泛的接受。所以slim依然不属于原生tensorflow。

那么什么是slim？slim到底有什么用？

上一节已经讲到slim是一个使构建，训练，评估神经网络变得简单的库。它可以消除原生tensorflow里面很多重复的模板性的代码，让代码更紧凑，更具备可读性。另外slim提供了很多计算机视觉方面的著名模型（VGG, AlexNet等），我们不仅可以直接使用，甚至能以各种方式进行扩展。

slim的子模块及功能介绍：

• arg_scope: provides a new scope named arg_scope that allows a user to define default arguments for specific operations within that scope.

除了基本的name_scope，variabel_scope外，又加了arg_scope，它是用来控制每一层的默认超参数的。（后面会详细说）

• data: contains TF-slim's dataset definition, data providers, parallel_reader, and decoding utilities.

貌似slim里面还有一套自己的数据定义，这个跳过，我们用的不多。

• evaluation: contains routines for evaluating models.

评估模型的一些方法，用的也不多。

• layers: contains high level layers for building models using tensorflow.

这个比较重要，slim的核心和精髓，一些复杂层的定义。

• learning: contains routines for training models.

一些训练规则。

• losses: contains commonly used loss functions.

一些loss。

• metrics: contains popular evaluation metrics.

评估模型的度量标准。

• nets: contains popular network definitions such as VGG and AlexNet models.

包含一些经典网络，VGG等，用的也比较多。

• queues: provides a context manager for easily and safely starting and closing QueueRunners.

文本队列管理，比较有用。

• regularizers: contains weight regularizers.

包含一些正则规则。

• variables: provides convenience wrappers for variable creation and manipulation.

这个比较有用，我很喜欢slim管理变量的机制。

 

二.slim定义模型

在slim中，组合使用variables, layers和scopes可以简洁的定义模型。

1.variable

定义于模型变量。生成一个weight变量, 用truncated normal初始化它, 并使用l2正则化，并将其放置于CPU上, 只需下面的代码即可：

#定义模型变量
weights = slim.model_variable('weights', shape=[10, 10, 3 , 3], 
                        initializer=tf.truncated_normal_initializer(stddev=0.1), 
                        regularizer=slim.l2_regularizer(0.05),
                        device='/CPU:0')
model_variables = slim.get_model_variables()

原生tensorflow包含两类变量：普通变量和局部变量。大部分变量都是普通变量，它们一旦生成就可以通过使用saver存入硬盘，局部变量只在session中存在，不会保存。

• slim进一步的区分了变量类型，定义了model_variables(模型变量)，这种变量代表了模型的参数。模型变量通过训练或者微调而得到学习，或者在评测或前向传播中可以从ckpt文件中载入。
• 非模型参数在实际前向传播中不需要的参数，比如global_step。同样的，移动平均反应了模型参数，但它本身不是模型参数。如下：

#常规变量
my_var = slim.variable('my_var',shape=[20, 1],
                       initializer=tf.zeros_initializer())
#get_variables()得到模型参数和常规参数
regular_variables_and_model_variables = slim.get_variables()

当我们通过slim的layers或着直接使用slim.model_variable创建变量时，tf会将此变量加入tf.GraphKeys.MODEL_VARIABLES这个集合中,当你需要构建自己的变量时，可以通过以下代码
将其加入模型参数。

#Letting TF-Slim know about the additional variable.
slim.add_model_variable(my_var)

 2.layers

抽象并封装了常用的层，并且提供了repeat和stack操作，使得定义网络更加方便。
首先让我们看看tensorflow怎么实现一个层，例如卷积层：

#在tensorflow下实现一个层
input_x = tf.placeholder(dtype=tf.float32,shape=[None,224,224,3])
with tf.name_scope('conv1_1') as scope:  
    weight = tf.Variable(tf.truncated_normal([3, 3, 3, 64], 
                        dtype=tf.float32,  
                        stddev=1e-1), 
                        name='weights')  
    conv = tf.nn.conv2d(input_x, weight, [1, 1, 1, 1], padding='SAME')  
    bias = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),  
                       trainable=True, name='biases')      
    conv1 = tf.nn.relu(tf.nn.bias_add(conv, bias), name=scope)

然后slim的实现：

#在slim实现一层
net = slim.conv2d(input_x, 64, [3, 3], scope='conv1_1')  

但这个不是重要的，因为tenorflow目前也有大部分层的简单实现，这里比较吸引人的是slim中的repeat和stack操作：

假设定义三个相同的卷积层：

net = ...  
net = slim.conv2d(net, 256, [3, 3], scope='conv2_1')  
net = slim.conv2d(net, 256, [3, 3], scope='conv2_2')  
net = slim.conv2d(net, 256, [3, 3], scope='conv2_3')  
net = slim.max_pool2d(net, [2, 2], scope='pool2')  

在slim中的repeat操作可以减少代码量：

net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv2')  
net = slim.max_pool2d(net, [2, 2], scope='pool2')  

repeat不仅只实现了相同操作相同参数的重复，它还将scope进行了展开，例子中的scope被展开为 'conv2/conv2_1', 'conv2/conv2_2' and 'conv2/conv2_3'。

而stack是处理卷积核或者输出不一样的情况,假设定义三层FC：

#stack的使用  stack是处理卷积核或者输出不一样的情况,
x = tf.placeholder(dtype=tf.float32,shape=[None,784])
x = slim.fully_connected(x, 32, scope='fc/fc_1')  
x = slim.fully_connected(x, 64, scope='fc/fc_2')  
x = slim.fully_connected(x, 128, scope='fc/fc_3')  

#使用stack操作：
x = slim.stack(x, slim.fully_connected, [32, 64, 128], scope='fc')  

同理卷积层也一样：

# 普通方法:  
net = slim.conv2d(input_x, 32, [3, 3], scope='core/core_1')  
net = slim.conv2d(net, 32, [1, 1], scope='core/core_2')  
net = slim.conv2d(net, 64, [3, 3], scope='core/core_3')  
net = slim.conv2d(net, 64, [1, 1], scope='core/core_4')  
  
# 简便方法:  
net = slim.stack(input_x, slim.conv2d, [(32, [3, 3]), (32, [1, 1]), (64, [3, 3]), (64, [1, 1])], scope='core')  

 3.scope

除了tensorflow中的name_scope和variable_scope, tf.slim新增了arg_scope操作，这一操作符可以让定义在这一scope中的操作共享参数，即如不指定参数的话，则使用默认参数。且参数可以被局部覆盖。

如果你的网络有大量相同的参数，如下：

net = slim.conv2d(input_x, 64, [11, 11], 4, padding='SAME',  
                  weights_initializer=tf.truncated_normal_initializer(stddev=0.01),  
                  weights_regularizer=slim.l2_regularizer(0.0005), scope='conv1')  
net = slim.conv2d(net, 128, [11, 11], padding='VALID',  
                  weights_initializer=tf.truncated_normal_initializer(stddev=0.01),  
                  weights_regularizer=slim.l2_regularizer(0.0005), scope='conv2')  
net = slim.conv2d(net, 256, [11, 11], padding='SAME',  
                  weights_initializer=tf.truncated_normal_initializer(stddev=0.01),  
                  weights_regularizer=slim.l2_regularizer(0.0005), scope='conv3')  

然后我们用arg_scope处理一下：

#使用arg_scope
with slim.arg_scope([slim.conv2d], padding='SAME',  
                    weights_initializer=tf.truncated_normal_initializer(stddev=0.01),  
                    weights_regularizer=slim.l2_regularizer(0.0005)):  
    net = slim.conv2d(input_x, 64, [11, 11], scope='conv1')  
    net = slim.conv2d(net, 128, [11, 11], padding='VALID', scope='conv2')  
    net = slim.conv2d(net, 256, [11, 11], scope='conv3')  

如上倒数第二行代码，对padding进行了重新赋值。那如果除了卷积层还有其他层呢？那就要如下定义：

with slim.arg_scope([slim.conv2d, slim.fully_connected],  
                      activation_fn=tf.nn.relu,  
                      weights_initializer=tf.truncated_normal_initializer(stddev=0.01),  
                      weights_regularizer=slim.l2_regularizer(0.0005)):  
    with slim.arg_scope([slim.conv2d], stride=1, padding='SAME'):  
        net = slim.conv2d(input_x, 64, [11, 11], 4, padding='VALID', scope='conv1')  
        net = slim.conv2d(net, 256, [5, 5],  
                      weights_initializer=tf.truncated_normal_initializer(stddev=0.03),  
                      scope='conv2')  
        net = slim.fully_connected(net, 1000, activation_fn=None, scope='fc')  

写两个arg_scope就行了。采用如上方法，定义一个VGG也就十几行代码的事了。

#定义一个vgg16网络
def vgg16(inputs):  
    with slim.arg_scope([slim.conv2d, slim.fully_connected],  
                      activation_fn=tf.nn.relu,  
                      weights_initializer=tf.truncated_normal_initializer(0.0, 0.01),  
                      weights_regularizer=slim.l2_regularizer(0.0005)):  
        net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')  
        net = slim.max_pool2d(net, [2, 2], scope='pool1')  
        net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')  
        net = slim.max_pool2d(net, [2, 2], scope='pool2')  
        net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')  
        net = slim.max_pool2d(net, [2, 2], scope='pool3')  
        net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')  
        net = slim.max_pool2d(net, [2, 2], scope='pool4')  
        net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')  
        net = slim.max_pool2d(net, [2, 2], scope='pool5')  
        net = slim.fully_connected(net, 4096, scope='fc6')  
        net = slim.dropout(net, 0.5, scope='dropout6')  
        net = slim.fully_connected(net, 4096, scope='fc7')  
        net = slim.dropout(net, 0.5, scope='dropout7')  
        net = slim.fully_connected(net, 1000, activation_fn=None, scope='fc8')  
        return net  

 

三.训练模型

这里直接选用经典网络。

import tensorflow as tf  
vgg = tf.contrib.slim.nets.vgg  
  
# Load the images and labels.  
images, labels = ...  
  
# Create the model.  
predictions, _ = vgg.vgg_16(images)  
  
# Define the loss functions and get the total loss.  
loss = slim.losses.softmax_cross_entropy(predictions, labels)  

关于loss,要说一下定义自己的loss的方法，以及注意不要忘记加入到slim中让slim看到你的loss。

还有正则项也是需要手动添加进loss当中的，不然最后计算的时候就不优化正则目标了。

# Load the images and labels.  
images, scene_labels, depth_labels, pose_labels = ...  
  
# Create the model.  
scene_predictions, depth_predictions, pose_predictions = CreateMultiTaskModel(images)  
  
# Define the loss functions and get the total loss.  
classification_loss = slim.losses.softmax_cross_entropy(scene_predictions, scene_labels)  
sum_of_squares_loss = slim.losses.sum_of_squares(depth_predictions, depth_labels)  
pose_loss = MyCustomLossFunction(pose_predictions, pose_labels)  
slim.losses.add_loss(pose_loss) # Letting TF-Slim know about the additional loss.  
  
# The following two ways to compute the total loss are equivalent:  
regularization_loss = tf.add_n(slim.losses.get_regularization_losses())  
total_loss1 = classification_loss + sum_of_squares_loss + pose_loss + regularization_loss  
  
# (Regularization Loss is included in the total loss by default).  
total_loss2 = slim.losses.get_total_loss()  

slim在learning.py中提供了一个简单而有用的训练模型的工具。我们只需调用slim.learning.create_train_op 和slim.learning.train就可以完成优化过程。

slim.learning.train函数被用来训练神经网络，函数定义如下：

def slim.learning.train(train_op,
          logdir,
          train_step_fn=train_step,
          train_step_kwargs=_USE_DEFAULT,
          log_every_n_steps=1,
          graph=None,
          master='',
          is_chief=True,
          global_step=None,
          number_of_steps=None,
          init_op=_USE_DEFAULT,
          init_feed_dict=None,
          local_init_op=_USE_DEFAULT,
          init_fn=None,
          ready_op=_USE_DEFAULT,
          summary_op=_USE_DEFAULT,
          save_summaries_secs=600,
          summary_writer=_USE_DEFAULT,
          startup_delay_steps=0,
          saver=None,
          save_interval_secs=600,
          sync_optimizer=None,
          session_config=None,
          trace_every_n_steps=None):

其中部分参数的说明如下：

• train_op: A `Tensor` that, when executed, will apply the gradients and return the loss value.
• logdir: The directory where training logs are written to. If None, model checkpoints and summaries will not be written.检查点文件和日志文件的保存路径。
• number_of_steps: The max number of gradient steps to take during training,as measured by 'global_step': training will stop if global_step is greater than 'number_of_steps'. If the value is left as None, training proceeds indefinitely.默认是一致循环训练。
• save_summaries_secs: How often, in seconds, to save summaries.
• summary_writer: `SummaryWriter` to use. Can be `None` to indicate that no summaries should be written. If unset, we create a SummaryWriter.
• startup_delay_steps: The number of steps to wait for before beginning. Note that this must be 0 if a sync_optimizer is supplied.
• saver: Saver to save checkpoints. If None, a default one will be created and used.
• save_interval_secs: How often, in seconds, to save the model to `logdir`.

g = tf.Graph()

# Create the model and specify the losses...
...

total_loss = slim.losses.get_total_loss()
optimizer = tf.train.GradientDescentOptimizer(learning_rate)

# create_train_op ensures that each time we ask for the loss, the update_ops
# are run and the gradients being computed are applied too.
train_op = slim.learning.create_train_op(total_loss, optimizer)
logdir = ... # Where checkpoints are stored.

slim.learning.train(
    train_op,
    logdir,
    number_of_steps=1000,     #迭代次数
          save_summaries_secs=300,        #存summary间隔秒数
          save_interval_secs=600)             #存模型间隔秒数

 

四.读取保存模型变量

在迁移学习中，我们经常会用到别人已经训练好的网络和模型参数，这时候我们可能需要从检查点文件中加载部分变量，下面我就会讲解如何加载指定变量。以及当前图的变量名和检查点文件中变量名不一致时怎么办。

1. 从检查恢复部分变量

通过以下功能我们可以载入模型的部分变量：

# Create some variables.
v1 = tf.Variable(..., name="v1")
v2 = tf.Variable(..., name="v2")
...
# Add ops to restore all the variables.
restorer = tf.train.Saver()

# Add ops to restore some variables.
restorer = tf.train.Saver([v1, v2])

# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:
  # Restore variables from disk.
  restorer.restore(sess, "/tmp/model.ckpt")
  print("Model restored.")
  # Do some work with the model
  ...

通过这种方式我们可以加载不同变量名的变量！

 2 从从检查点恢复部分变量还可以采用其他方法

# Create some variables.
v1 = slim.variable(name="v1", ...)
v2 = slim.variable(name="nested/v2", ...)
...

# Get list of variables to restore (which contains only 'v2'). These are all
# equivalent methods:
#从检查点文件中恢复name='v2'的变量
variables_to_restore = slim.get_variables_by_name("v2")     
# or 从检查点文件中恢复name带有2的所有变量
variables_to_restore = slim.get_variables_by_suffix("2")     
# or 从检查点文件中恢复命名空间scope='nested'的所有变量
variables_to_restore = slim.get_variables(scope="nested")    
# or 恢复命名空间scope='nested'的所有变量
variables_to_restore = slim.get_variables_to_restore(include=["nested"])  
# or 除了命名空间scope='v1'的变量
variables_to_restore = slim.get_variables_to_restore(exclude=["v1"])      

# Create the saver which will be used to restore the variables.
restorer = tf.train.Saver(variables_to_restore)

with tf.Session() as sess:
  # Restore variables from disk.
  restorer.restore(sess, "/tmp/model.ckpt")
  print("Model restored.")
  # Do some work with the model
  ...

3.当图的变量名与checkpoint中的变量名不同时，恢复模型参数

当从checkpoint文件中恢复变量时，Saver在checkpoint文件中定位到变量名，并且把它们映射到当前图中的变量中。之前的例子中，我们创建了Saver，并为其提供了变量列表作为参数。这时，在checkpoint文件中定位的变量名，是隐含地从每个作为参数给出的变量的var.op.name而获得的。这一方式在图与checkpoint文件中变量名字相同时，可以很好的工作。而当名字不同时，必须给Saver提供一个将checkpoint文件中的变量名映射到图中的每个变量的字典。

假设我们定义的网络变量是conv1/weights，而从VGG检查点文件加载的变量名为vgg16/conv1/weights，正常load肯定会报错（找不到变量名），但是可以这样：例子见下：

# Assuming that 'conv1/weights' should be restored from 'vgg16/conv1/weights'
def name_in_checkpoint(var):
  return 'vgg16/' + var.op.name

# Assuming that 'conv1/weights' and 'conv1/bias' should be restored from 'conv1/params1' and 'conv1/params2'
def name_in_checkpoint(var):
  if "weights" in var.op.name:
    return var.op.name.replace("weights", "params1")
  if "bias" in var.op.name:
    return var.op.name.replace("bias", "params2")

variables_to_restore = slim.get_model_variables()
variables_to_restore = {name_in_checkpoint(var):var for var in variables_to_restore}
restorer = tf.train.Saver(variables_to_restore)

with tf.Session() as sess:
  # Restore variables from disk.
  restorer.restore(sess, "/tmp/model.ckpt")

4.在一个不同的任务上对网络进行微调

比如我们要将1000类的imagenet分类任务应用于20类的Pascal VOC分类任务中，我们只导入部分层，见下例：

image, label = MyPascalVocDataLoader(...)
images, labels = tf.train.batch([image, label], batch_size=32)

# Create the model,20类
predictions = vgg.vgg_16(images,num_classes=20)

train_op = slim.learning.create_train_op(...)

# Specify where the Model, trained on ImageNet, was saved.
model_path = '/path/to/pre_trained_on_imagenet.checkpoint'

# Specify where the new model will live:
log_dir = '/path/to/my_pascal_model_dir/'

# Restore only the convolutional layers: 从检查点载入除了fc6,fc7,fc8层之外的参数
variables_to_restore = slim.get_variables_to_restore(exclude=['fc6', 'fc7', 'fc8'])
init_fn = assign_from_checkpoint_fn(model_path, variables_to_restore)

# Start training.
slim.learning.train(train_op, log_dir, init_fn=init_fn)

 下面会显示一个具体迁移学习的案例。

 

五 预训练

如果我们仍然是对1000类的数据集进行分类，此时我们可以利用训练好的模型参数进行初始化，然后继续训练。

文件夹结构如下，不懂得话，可以参考第二十二节，TensorFlow中的图片分类模型库slim的使用、数据集处理，其中vgg预训练模型下载地址：https://github.com/tensorflow/models/tree/master/research/slim/#Pretrained

代码如下：

def retrain():
    '''
    演示一个VGG16网络的例子
    从头开始训练
    '''    
    batch_size = 128
    
    learning_rate = 1e-4
    
    #用于保存微调后的检查点文件和日志文件路径
    train_log_dir = './log/vgg16/slim_retrain'    
    
    #官方下载的检查点文件路径
    checkpoint_file = './log/vgg16/vgg_16.ckpt'
    
    if not tf.gfile.Exists(train_log_dir):
        tf.gfile.MakeDirs(train_log_dir)
    
    #创建一个图，作为当前图
    with tf.Graph().as_default():
        
        #加载数据
        train_images, train_labels = ....


        #创建vgg16网络  如果想冻结所有层，可以指定slim.conv2d中的 trainable=False
        logits,end_points =  vgg.vgg_16(train_images, is_training=True)        
        
        #交叉熵代价函数
        slim.losses.softmax_cross_entropy(logits, onehot_labels=train_labels)
        total_loss = slim.losses.get_total_loss()
      
        #设置写入到summary中的变量
        tf.summary.scalar('losses/total_loss', total_loss)
    
        '''
        设置优化器 这里不能指定成Adam优化器，因为我们的官方模型文件中使用的就是GradientDescentOptimizer优化器，
        因此我们要和官方模型一致，如果想使用AdamOptimizer优化器，我们可以在调用完vgg16()网络后，就执行恢复模型。
        而把执行恢复模型的代码放在后面，会由于我们在当前图中定义了一些检查点中不存在变量，恢复时在检查点文件找不
        到变量，因此会报错。
        '''
        optimizer = tf.train.GradientDescentOptimizer(learning_rate)
        #optimizer = tf.train.AdamOptimizer(learning_rate)
        # create_train_op that ensures that when we evaluate it to get the loss,
        # the update_ops are done and the gradient updates are computed.
        train_tensor = slim.learning.create_train_op(total_loss, optimizer)
        
        # Restore only the convolutional layers: 从检查点载入除了fc8层之外的参数到当前图             
        variables_to_restore = slim.get_variables_to_restore(exclude=['vgg_16/fc8'])        
        init_fn = slim.assign_from_checkpoint_fn(checkpoint_file, variables_to_restore)
        

        print('开始训练！')
        #开始训练网络        
        slim.learning.train(train_tensor,
                            train_log_dir,
                            number_of_steps=100,             #迭代次数 一次迭代batch_size个样本
                            save_summaries_secs=300,         #存summary间隔秒数
                            save_interval_secs=300,          #存模模型间隔秒数                         
                            init_fn=init_fn)

 

六 微调

有时候我们数据集比较少的时候，可能使用已经训练的网络模型。比如我们想对flowers数据集进行分类。该数据集分成了两部分，训练集数据有3320张，校验集数据有350张。我们使用slim库下已经写好的vgg16网络，并下载对应的模型参数文件。由于模型参数是针对ImageNet数据集训练的得到的，而我们Flower数据集只有5类，因此需要把vgg16最后一层分类数改为5。

这里我们仍然先使用TensorFlow的网络架构来实现微调功能，后面我们再演示一个使用slim库简化之后的代码。

1.TensorFlow实现代码

# -*- coding: utf-8 -*-
"""
Created on Wed Jun  6 11:56:58 2018

@author: zy
"""

'''
利用已经训练好的vgg16网络对flowers数据集进行微调
把最后一层分类由2000->5 然后重新训练，我们也可以冻结其它所有层，只训练最后一层
'''

from nets import vgg
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
import input_data
import os

slim = tf.contrib.slim

DATA_DIR = './datasets/data/flowers'
#输出类别
NUM_CLASSES = 5
    
#获取图片大小
IMAGE_SIZE = vgg.vgg_16.default_image_size



def flowers_fine_tuning():
    '''
    演示一个VGG16的例子 
    微调 这里只调整VGG16最后一层全连接层，把1000类改为5类 
    对网络进行训练
    '''
        
    '''
    1.设置参数，并加载数据
    '''
    #用于保存微调后的检查点文件和日志文件路径
    train_log_dir = './log/vgg16/fine_tune'
    train_log_file = 'flowers_fine_tune.ckpt'
    
    #官方下载的检查点文件路径
    checkpoint_file = './log/vgg16/vgg_16.ckpt'
    
    #设置batch_size
    batch_size  = 256
    
    learning_rate = 1e-4
    
    #训练集数据长度
    n_train = 3320
    #测试集数据长度
    #n_test = 350
    #迭代轮数
    training_epochs = 3
    
    display_epoch = 1
    
    if not tf.gfile.Exists(train_log_dir):
        tf.gfile.MakeDirs(train_log_dir)
                        
    #加载数据
    train_images, train_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,True,IMAGE_SIZE,IMAGE_SIZE)          
    test_images, test_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,False,IMAGE_SIZE,IMAGE_SIZE)          

    #获取模型参数的命名空间
    arg_scope = vgg.vgg_arg_scope()

    #创建网络
    with  slim.arg_scope(arg_scope):
        
        '''
        2.定义占位符和网络结构
        '''        
        #输入图片
        input_images = tf.placeholder(dtype=tf.float32,shape = [None,IMAGE_SIZE,IMAGE_SIZE,3])
        #图片标签
        input_labels = tf.placeholder(dtype=tf.float32,shape = [None,NUM_CLASSES])        
        #训练还是测试？测试的时候弃权参数会设置为1.0
        is_training = tf.placeholder(dtype = tf.bool)
        
        #创建vgg16网络  如果想冻结所有层，可以指定slim.conv2d中的 trainable=False
        logits,end_points =  vgg.vgg_16(input_images, is_training=is_training,num_classes = NUM_CLASSES)
        #print(end_points)  每个元素都是以vgg_16/xx命名
            
        
        '''
        #从当前图中搜索指定scope的变量，然后从检查点文件中恢复这些变量(即vgg_16网络中定义的部分变量)  
        #如果指定了恢复检查点文件中不存在的变量，则会报错 如果不知道检查点文件有哪些变量，我们可以打印检查点文件查看变量名
        params = []
        conv1 = slim.get_variables(scope="vgg_16/conv1")
        params.extend(conv1)            
        conv2 = slim.get_variables(scope="vgg_16/conv2")
        params.extend(conv2)
        conv3 = slim.get_variables(scope="vgg_16/conv3")
        params.extend(conv3)
        conv4 = slim.get_variables(scope="vgg_16/conv4")
        params.extend(conv4)
        conv5 = slim.get_variables(scope="vgg_16/conv5")
        params.extend(conv5)
        fc6 = slim.get_variables(scope="vgg_16/fc6")
        params.extend(fc6)
        fc7 = slim.get_variables(scope="vgg_16/fc7")
        params.extend(fc7)          
        '''

        # Restore only the convolutional layers: 从检查点载入当前图除了fc8层之外所有变量的参数
        params = slim.get_variables_to_restore(exclude=['vgg_16/fc8'])
        #用于恢复模型  如果使用这个保存或者恢复的话，只会保存或者恢复指定的变量
        restorer = tf.train.Saver(params) 
        
        #预测标签
        pred = tf.argmax(logits,axis=1)

        '''
        3 定义代价函数和优化器
        '''                
        #代价函数
        cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=input_labels,logits=logits))
        
        #设置优化器
        optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
        
        #预测结果评估        
        correct = tf.equal(pred,tf.argmax(input_labels,1))                    #返回一个数组 表示统计预测正确或者错误 
        accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))                #求准确率
                            
        num_batch = int(np.ceil(n_train / batch_size))
        
        #用于保存检查点文件 
        save = tf.train.Saver(max_to_keep=1) 

        #恢复模型
        with tf.Session() as sess:      
            sess.run(tf.global_variables_initializer())
                    
            #检查最近的检查点文件
            ckpt = tf.train.latest_checkpoint(train_log_dir)
            if ckpt != None:
                save.restore(sess,ckpt)
                print('从上次训练保存后的模型继续训练！')
            else:
                restorer.restore(sess, checkpoint_file)                
                print('从官方模型加载训练！')

                                   
            #创建一个协调器，管理线程
            coord = tf.train.Coordinator()  
            
            #启动QueueRunner, 此时文件名才开始进队。
            threads = tf.train.start_queue_runners(sess=sess,coord=coord)                      

            '''
            4 查看预处理之后的图片
            '''            
            imgs, labs = sess.run([train_images, train_labels])                  
            print('原始训练图片信息：',imgs.shape,labs.shape)
            show_img = np.array(imgs[0],dtype=np.uint8)
            plt.imshow(show_img)                                
            plt.title('Original train image')   
            plt.show()

                                    
            imgs, labs = sess.run([test_images, test_labels])                  
            print('原始测试图片信息：',imgs.shape,labs.shape)
            show_img = np.array(imgs[0],dtype=np.uint8)
            plt.imshow(show_img)                                
            plt.title('Original test image')   
            plt.show()
            
                        
            print('开始训练！')
            for epoch in range(training_epochs):                
                total_cost = 0.0                
                for i in range(num_batch):
                    imgs, labs = sess.run([train_images, train_labels])                                                
                    _,loss = sess.run([optimizer,cost],feed_dict={input_images:imgs,input_labels:labs,is_training:True})
                    total_cost += loss
            
                #打印信息
                if epoch % display_epoch == 0:
                    print('Epoch {}/{}  average cost {:.9f}'.format(epoch+1,training_epochs,total_cost/num_batch))
                    
                #进行预测处理
                imgs, labs = sess.run([test_images, test_labels])                                                                    
                cost_values,accuracy_value = sess.run([cost,accuracy],feed_dict = {input_images:imgs,input_labels:labs,is_training:False})
                print('Epoch {}/{}  Test cost {:.9f}'.format(epoch+1,training_epochs,cost_values))
                print('准确率:',accuracy_value)
                
                
                #保存模型
                save.save(sess,os.path.join(train_log_dir,train_log_file),global_step = epoch)
                print('Epoch {}/{}  模型保存成功'.format(epoch+1,training_epochs))
                
            print('训练完成')
                    
            #终止线程
            coord.request_stop()
            coord.join(threads)  
            
def flowers_test():
    '''
    使用微调好的网络进行测试
    '''          
    '''
    1.设置参数，并加载数据
    '''
    #微调后的检查点文件和日志文件路径
    save_dir = './log/vgg16/fine_tune'
    
    #设置batch_size
    batch_size  = 128
    
                        
    #加载数据
    train_images, train_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,True,IMAGE_SIZE,IMAGE_SIZE)          
    test_images, test_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,False,IMAGE_SIZE,IMAGE_SIZE)          

    #获取模型参数的命名空间
    arg_scope = vgg.vgg_arg_scope()

    #创建网络
    with  slim.arg_scope(arg_scope):
        
        '''
        2.定义占位符和网络结构
        '''        
        #输入图片
        input_images = tf.placeholder(dtype=tf.float32,shape = [None,IMAGE_SIZE,IMAGE_SIZE,3])     
        #训练还是测试？测试的时候弃权参数会设置为1.0
        is_training = tf.placeholder(dtype = tf.bool)
        
        #创建vgg16网络
        logits,end_points =  vgg.vgg_16(input_images, is_training=is_training,num_classes = NUM_CLASSES)
         
        #预测标签
        pred = tf.argmax(logits,axis=1)             
        
        restorer = tf.train.Saver() 
        
        #恢复模型
        with tf.Session() as sess:      
            sess.run(tf.global_variables_initializer())
            ckpt = tf.train.latest_checkpoint(save_dir)
            if ckpt != None:
                #恢复模型
                restorer.restore(sess,ckpt)
                print("Model restored.")
                                   
            #创建一个协调器，管理线程
            coord = tf.train.Coordinator()  
            
            #启动QueueRunner, 此时文件名才开始进队。
            threads = tf.train.start_queue_runners(sess=sess,coord=coord)                      

            '''
            查看预处理之后的图片
            '''            
            imgs, labs = sess.run([test_images, test_labels])                  
            print('原始测试图片信息：',imgs.shape,labs.shape)
            show_img = np.array(imgs[0],dtype=np.uint8)
            plt.imshow(show_img)                                
            plt.title('Original test image')   
            plt.show()
                         
            pred_value = sess.run(pred,feed_dict = {input_images:imgs,is_training:False})
            print('预测结果为：',pred_value)
            print('实际结果为：',np.argmax(labs,1))
            correct = np.equal(pred_value,np.argmax(labs,1))
            print('准确率为:',  np.mean(correct))
                
            #终止线程
            coord.request_stop()
            coord.join(threads)  
            
            
            
    
if __name__ == '__main__':
    tf.reset_default_graph()    
    flowers_fine_tuning()
    flowers_test()

 这里我在训练的时候，冻结了出输出层之外的所有层，运行结果如下：

 

三轮之后，我们可以看到准确率大概在60%。

 如果我们不冻结其它层，(训练所有层，速度慢)，3轮下来，准确率可以达到90%左右。

 

2.Slim库实现代码

使用slim库简化上面的代码：

           
def flowers_simple_fine_tuning():
    '''
    演示一个VGG16的例子 
    微调 这里只调整VGG16最后一层全连接层，把1000类改为5类 
    对网络进行训练   使用slim库简化代码
    '''    
    batch_size = 128
    
    learning_rate = 1e-4
    
    #用于保存微调后的检查点文件和日志文件路径
    train_log_dir = './log/vgg16/slim_fine_tune'    
    
    #官方下载的检查点文件路径
    checkpoint_file = './log/vgg16/vgg_16.ckpt'
    
    if not tf.gfile.Exists(train_log_dir):
        tf.gfile.MakeDirs(train_log_dir)
    
    #创建一个图，作为当前图
    with tf.Graph().as_default():
        
        #加载数据
        train_images, train_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,True,IMAGE_SIZE,IMAGE_SIZE)          


        #创建vgg16网络  如果想冻结所有层，可以指定slim.conv2d中的 trainable=False
        logits,end_points =  vgg.vgg_16(train_images, is_training=True,num_classes = NUM_CLASSES)        
        
        #交叉熵代价函数
        slim.losses.softmax_cross_entropy(logits, onehot_labels=train_labels)
        total_loss = slim.losses.get_total_loss()
      
        #设置写入到summary中的变量
        tf.summary.scalar('losses/total_loss', total_loss)
    
        '''
        设置优化器 这里不能指定成Adam优化器，因为我们的官方模型文件中使用的就是GradientDescentOptimizer优化器，
        因此我们要和官方模型一致，如果想使用AdamOptimizer优化器，我们可以在调用完vgg16()网络后，就执行恢复模型。
        而把执行恢复模型的代码放在后面，会由于我们在当前图中定义了一些检查点中不存在变量，恢复时在检查点文件找不
        到变量，因此会报错。
        '''
        optimizer = tf.train.GradientDescentOptimizer(learning_rate)
        #optimizer = tf.train.AdamOptimizer(learning_rate)
        # create_train_op that ensures that when we evaluate it to get the loss,
        # the update_ops are done and the gradient updates are computed.
        train_tensor = slim.learning.create_train_op(total_loss, optimizer)
        
        #检查最近的检查点文件
        ckpt = tf.train.latest_checkpoint(train_log_dir)
        if ckpt != None:
            variables_to_restore = slim.get_model_variables()
            init_fn = slim.assign_from_checkpoint_fn(ckpt,variables_to_restore)
            print('从上次训练保存后的模型继续训练！')
        else:
            # Restore only the convolutional layers: 从检查点载入除了fc8层之外的参数到当前图             
            variables_to_restore = slim.get_variables_to_restore(exclude=['vgg_16/fc8']) 
            init_fn = slim.assign_from_checkpoint_fn(checkpoint_file, variables_to_restore)
            print('从官方模型加载训练！')
        

        print('开始训练！')
        #开始训练网络        
        slim.learning.train(train_tensor,
                            train_log_dir,
                            number_of_steps=100,             #迭代次数 一次迭代batch_size个样本
                            save_summaries_secs=300,         #存summary间隔秒数
                            save_interval_secs=300,          #存模模型间隔秒数                         
                            init_fn=init_fn)

 

上面的代码中我们用到了input_data.py文件，主要负责加载数据集，程序如下：

# -*- coding: utf-8 -*-
"""
Created on Fri Jun  8 08:52:30 2018

@author: zy
"""

'''
导入flowers数据集
'''

from datasets import download_and_convert_flowers
from preprocessing import vgg_preprocessing
from datasets import flowers
import tensorflow as tf


slim = tf.contrib.slim


def read_flower_image_and_label(dataset_dir,is_training=False):
    '''
    下载flower_photos.tgz数据集  
    切分训练集和验证集
    并将数据转换成TFRecord格式  5个训练数据文件(3320)，5个验证数据文件(350)，还有一个标签文件(存放每个数字标签对应的类名)
            
    args:
        dataset_dir:数据集所在的目录
        is_training：设置为TRue，表示加载训练数据集，否则加载验证集
    return:
        image,label:返回随机读取的一张图片，和对应的标签
    '''    
    download_and_convert_flowers.run(dataset_dir)    
    '''
    利用slim读取TFRecord中的数据
    '''
    #选择数据集train
    if is_training:        
        dataset = flowers.get_split(split_name = 'train',dataset_dir=dataset_dir)
    else:
        dataset = flowers.get_split(split_name = 'validation',dataset_dir=dataset_dir)
    
    #创建一个数据provider
    provider = slim.dataset_data_provider.DatasetDataProvider(dataset)
    
    #通过provider的get随机获取一条样本数据 返回的是两个张量
    [image,label] = provider.get(['image','label'])

    return image,label



def get_batch_images_and_label(dataset_dir,batch_size,num_classes,is_training=False,output_height=224, output_width=224,num_threads=10):
    '''
    每次取出batch_size个样本
    
    注意：这里预处理调用的是slim库图片预处理的函数，例如：如果你使用的vgg网络，就调用vgg网络的图像预处理函数
          如果你使用的是自己定义的网络，则可以自己写适合自己图像的预处理函数，比如归一化处理也可以使用其他网络已经写好的预处理函数
    
    args:
         dataset_dir:数据集所在的目录
         batch_size:一次取出的样本数量
         num_classes：输出的类别 用于对标签one_hot编码
         is_training：设置为TRue，表示加载训练数据集，否则加载验证集
         output_height：输出图片高度
         output_width：输出图片宽
         
     return:
        images,labels:返回随机读取的batch_size张图片，和对应的标签one_hot编码
    '''
    #获取单张图像和标签
    image,label = read_flower_image_and_label(dataset_dir,is_training)   
    # 图像预处理 这里要求图片数据是tf.float32类型的
    image = vgg_preprocessing.preprocess_image(image, output_height, output_width,is_training=is_training)
    
    #缩放处理
    #image = tf.image.convert_image_dtype(image, dtype=tf.float32)  
    #image = tf.image.resize_image_with_crop_or_pad(image, output_height, output_width)
    
    #  shuffle_batch 函数会将数据顺序打乱
    #  bacth 函数不会将数据顺序打乱    
    images, labels = tf.train.batch(
                [image, label],
                batch_size = batch_size,
                capacity=5 * batch_size, 
                num_threads = num_threads)    
        
    #one-hot编码
    labels = slim.one_hot_encoding(labels,num_classes)
    
    return images,labels

3.CNN网络代码，与vgg16微调效果对比

我们这里使用三层的cnn网络对flower数据集进行分类，测试一下其效果如何：

# -*- coding: utf-8 -*-
"""
Created on Fri Jun  8 08:51:45 2018

@author: zy
"""

'''
使用卷积神经网络训练flowers数据集
用来和微调后的VGG网络对比
'''

import tensorflow as tf
import input_data
import numpy as np

slim = tf.contrib.slim


def cnn(inputs,num_classes=5):
    '''
    定义一个cnn网络结构
    
    args:
        inputs:输入形状为[batch_size,in_height,in_width,in_channel]    
        输入图片大小为224 x 224 x3
        num_classes：类别数
    
    '''
    with tf.variable_scope('cnn'):
        with slim.arg_scope([slim.conv2d,slim.fully_connected,slim.max_pool2d,slim.avg_pool2d],
                            padding='SAME',  
                            ):
            net = slim.conv2d(inputs,64,[5,5],4,weights_initializer=tf.truncated_normal_initializer(stddev=0.01),scope='conv1')    #batch_size x 56 x 56 x64
            net = slim.max_pool2d(net,[2,2],scope='pool1')        #batch_size x 28 x 28 x64
            net = slim.conv2d(net,64,[3,3],2,weights_initializer=tf.truncated_normal_initializer(stddev=0.01),scope='conv2')    #batch_size x 14 x 14 x64
            net = slim.max_pool2d(net,[2,2],scope='pool2')        #batch_size x 7 x 7 x64            
            #net = slim.conv2d(net,num_classes,[7,7],7,weights_initializer=tf.truncated_normal_initializer(stddev=0.01),scope='conv3')    #batch_size x 1 x 1 x num_classes
            net = slim.conv2d(net,num_classes,[1,1],1,weights_initializer=tf.truncated_normal_initializer(stddev=0.01),scope='conv3')    #batch_size x7 x 7 xnum_classes
            net = slim.avg_pool2d(net,[7,7],7,scope='pool3')                     #全局平均池化层            
            net = tf.squeeze(net,[1,2])                            #batch_size x num_classes            
            return net
        
                
DATA_DIR = './datasets/data/flowers'
#输出类别
NUM_CLASSES = 5
IMAGE_SIZE = 224


def flower_cnn():
    '''
    使用CNN网络训练flower数据集
    '''
    #设置batch_size
    batch_size  = 128
    
    learning_rate = 1e-4
    
    #训练集数据长度
    n_train = 3320
    #测试集数据长度
    #n_test = 350
    #迭代轮数
    training_epochs = 20
    
    display_epoch = 1

    #加载数据
    train_images, train_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,True,IMAGE_SIZE,IMAGE_SIZE)          
    test_images, test_labels = input_data.get_batch_images_and_label(DATA_DIR,batch_size,NUM_CLASSES,True,IMAGE_SIZE,IMAGE_SIZE)          
    
        
    #定义占位符
    input_images = tf.placeholder(dtype=tf.float32,shape = [None,IMAGE_SIZE,IMAGE_SIZE,3])
    input_labels = tf.placeholder(dtype=tf.float32,shape = [None,NUM_CLASSES])
    is_training = tf.placeholder(dtype = tf.bool)
        
    #创建cnn网络
    logits =  cnn(input_images,num_classes = NUM_CLASSES)
     
    #预测标签
    pred = tf.argmax(logits,axis=1)
     
    #代价函数
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=input_labels,logits=logits))
   
    #设置优化器
    optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
    
    #预测结果评估        
    correct = tf.equal(pred,tf.argmax(input_labels,1))                    #返回一个数组 表示统计预测正确或者错误 
    accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))                #求准确率
                        
    num_batch = int(np.ceil(n_train / batch_size))
    
    '''
    启动会话，开始训练
    '''
    with tf.Session() as sess:      
        sess.run(tf.global_variables_initializer())
                
        #创建一个协调器，管理线程
        coord = tf.train.Coordinator()  
        
        #启动QueueRunner, 此时文件名才开始进队。
        threads=tf.train.start_queue_runners(sess=sess,coord=coord)                      
                                
        print('开始训练!')
        for epoch in range(training_epochs):
            total_cost = 0.0
            for i in range(num_batch):
                imgs, labs = sess.run([train_images, train_labels])                                                
                _,loss = sess.run([optimizer,cost],feed_dict={input_images:imgs,input_labels:labs,is_training:True})
                total_cost += loss
        
            #打印信息
            if epoch % display_epoch == 0:
                print('Epoch {}/{}  Train average cost {:.9f}'.format(epoch+1,training_epochs,total_cost/num_batch))
                #进行预测处理
                imgs, labs = sess.run([test_images, test_labels])                                                
                cost_values,accuracy_value = sess.run([cost,accuracy],feed_dict = {input_images:imgs,input_labels:labs,is_training:False})
                print('Epoch {}/{}  Test cost {:.9f}'.format(epoch+1,training_epochs,cost_values))
                print('准确率:',accuracy_value)

        print('训练完成')                
        #终止线程
        coord.request_stop()
        coord.join(threads)  
            
                
if __name__ == '__main__':
    tf.reset_default_graph()    
    flower_cnn()

 

我们可以看到20轮下来准确率大概在55%，效果并不是很好。而使用vgg16微调的效果明显更高。

参考文章

[1]【Tensorflow】辅助工具篇——tensorflow slim(TF-Slim)介绍

[2]TF-Slim简介