1、slim.conv2d:二维卷积

函数原型：

convolution(inputs,
          num_outputs,
          kernel_size,
          stride=1,
          padding='SAME',
          data_format=None,
          rate=1,
          activation_fn=nn.relu,
          normalizer_fn=None,
          normalizer_params=None,
          weights_initializer=initializers.xavier_initializer(),
          weights_regularizer=None,
          biases_initializer=init_ops.zeros_initializer(),
          biases_regularizer=None,
          reuse=None,
          variables_collections=None,
          outputs_collections=None,
          trainable=True,
          scope=None):

参数介绍：

inputs：指需要做卷积的输入图像
num_outputs：指定卷积核的个数（就是filter的个数）
kernel_size：N个正整数的序列，指定卷积核的空间维度。可以是单个整数，则所有空间维度具有相同值。
stride：一组N个正整数，指定计算输出的stride。可以是一个整数，则所有空间维具有相同的值。指定任何stride！= 1与指定任何rate！= 1不相容。
padding：为padding的方式选择，VALID或者SAME
data_format：是用于指定输入的input的格式
rate：N个正整数的序列，指定用于萎缩卷积的扩张率。可以是单个整数，以指定所有空间维度的相同值。指定任何rate！= 1与指定任何stride！= 1不兼容。
activation_fn：用于激活函数的指定，默认的为ReLU函数
normalizer_fn：用于指定正则化函数
normalizer_params：用于指定正则化函数的参数
weights_initializer：用于指定权重的初始化程序
weights_regularizer：为权重可选的正则化程序
biases_initializer：用于指定biase的初始化程序
biases_regularizer: biases可选的正则化程序
reuse：指定是否共享层或者和变量
variable_collections：指定变量的集合列表或者字典名，变量（weight、biase）会被添加到这个集合中。
outputs_collections：指定一个列表名，输出（output）会被添加到这个列表。这个(列表名，[output])的键值对位于Graph类的self._collection字典中，如果该字典中没有列表名的关键字，则（列表名，[output]）会被创建。
trainable:：卷积层的参数是否可被训练，如果为True，则同样会将变量添加到计算图集合GraphKeys.TRAINABLE_VARIABLES中
scope:共享变量所指的variable_scope

2、slim.nets.resnet_utils.conv2d_same()：使用“SAME”填充的二维卷积

函数原型：conv2d_same(inputs, num_outputs, kernel_size, stride, rate=1, scope=None)
inputs: 一个4维tensor：[batch, height_in, width_in, channels].
num_outputs:卷积核的个数
kernel_size: 卷积核的尺寸
stride: 输出的stride
rate: 空洞卷积膨胀率
scope: Scope.

net = conv2d_same(inputs, num_outputs, 3, stride=stride)
# 等价于
net = slim.conv2d(inputs, num_outputs, 3, stride=1, padding='SAME')
net = subsample(net, factor=stride)
# 但是和net = slim.conv2d(inputs, num_outputs, 3, stride=stride, padding='SAME')不等价，因为当输入的高度
或宽度是偶数时，它是不同的，这就是我们添加当前函数的原因。

# subsample的源码为：
def subsample(inputs, factor, scope=None):
  """Subsamples the input along the spatial dimensions.
  Args:
    inputs: A `Tensor` of size [batch, height_in, width_in, channels].
    factor: The subsampling factor.
    scope: Optional variable_scope.
  Returns:
    output: A `Tensor` of size [batch, height_out, width_out, channels] with the
      input, either intact (if factor == 1) or subsampled (if factor > 1).
  """
  if factor == 1:
    return inputs
  else:
    return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)

3、 tf.variable_scope()的original_name_scope 和 name的区别：

with tf.variable_scope('a') as a:
    print(a.name)
    print(a.original_name_scope)
    print(a.original_name_scope)

with tf.variable_scope('a') as b:
    print(b.name)
    print(b.original_name_scope)

输出：
a
a/
a/
a
a_1/

foo.name返回scope的名称（String）。另一方面，foo.original_name_scope返回与foo.name相同的字符串，除非相同的scope被重新创建。在这种情况下，所有子范围都会根据需要附加一个_＃，以便对foo.original_name_scope进行所有调用，为范围的每个实例返回唯一的内容。

4、slim.utils.collect_named_outputs（collections, alias, outputs）：为output的tensor添加别名，并将tensor添加到collections的列表中

如果这个(列表名，列表)键值对存在于Graph的self._collection字典中，则只是在列表上添加，否则会在字典中创建键值对。源码如下：

def collect_named_outputs(collections, alias, outputs):
  if collections:
    append_tensor_alias(outputs, alias)
    # 将outputs添加到collections的列表中，这个(collections,[outputs])位于Graph的self._collection中
    ops.add_to_collections(collections, outputs)
  return outputs

def append_tensor_alias(tensor, alias):
  if alias[-1] == '/':
    alias = alias[:-1]
  if hasattr(tensor, 'aliases'):
    tensor.aliases.append(alias)
  else:
    tensor.aliases = [alias]
  return tensor

5、slim.separable_conv2d()：实现深度可分离卷积

6、slim.learning.train():开始训练

slim.learning.train()的源码如下：

_USE_DEFAULT=0
def 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,
          session_wrapper=None,
          trace_every_n_steps=None,
          ignore_live_threads=False):
  """
  使用TensorFlow 的监督器(supervisor)来运行训练循环。 提供sync_optimizer时，讲同步进行梯度更新，否则将异步进行梯度更新。
  args:
    train_op: 这是一个`Tensor`,当被执行的时候，将进行梯度更新并返回损失值。,
    logdir: 训练损失(trian loss)写入的目录。
    train_step_fn: 为了执行单次梯度跟新操作，这个函数将会被调用。这个函数必须有四个参数：session、train_op、 global step、dictionary.
    train_step_kwargs: 传给train_step_fn的一个dictionary，默认情况下，两个叫做"should_stop" 和"should_log"的布尔值需要提供。
    log_every_n_steps: 多少次迭代保存一次训练损失。
    graph: 传递给监督其supervisor的图，如果为空，则使用默认的graph。
    master: tensorflow master的地址
    is_chief: 指定是否在主要副本上运行training。
    global_step: 代表全局step的tensor，如果为空，那么将会调用training_util.get_or_create_global_step(), 
    number_of_steps: 训练时最大的梯度更新次数，当global step大于这个值时，停止训练。如果这个值为空，则训练不会停止下来。
    init_op: 初始化操作，如果为空，则调用tf.global_variables_initializer()初始化
    init_feed_dict: 当执行初始化操作时的需要feed进去的一个字典
    local_init_op: 局部初始化操作，如果为空，则调用tf.local_variables_initializer()和 tf.tables_initializer()来初始化
    init_fn: 在Init_op被执行后，一个可选的调用函数。这个函数需要接受一个参数，即被初始化的session。
    ready_op: 检查模型是否准备好了的操作，如果为空，将会调用tf.report_uninitialized_variables()。
    summary_op: summary操作。
    save_summaries_secs: 多少秒保存一次summaries。
    summary_writer: 一个SummaryWriter，如果为None，则不会又summary会被写入。如果没有设置该值，将会自动创建一个SummaryWriter。
    startup_delay_steps: 在梯度更新之前需要等待的step数。如果sync_optimizer被提供，则这个值必须为0.
    saver: 保存checkpoint文件的saver，如果为None，一个默认的saver将会被创建。
    save_interval_secs: 多少秒保存一次模型的checkpoint文件到logdir。
    sync_optimizer: tf.train.SyncReplicasOptimizer的一个实例，或者这个实例的一个列表。如果这个参数被更新，则梯度更新操作将同步进行。如果为None，则梯度更新操作将异步进行。
    session_config: tf.ConfigProto的一个实例，用于配置Session，如果为None，则将会创建一个默认值。
    session_wrapper: 会话包装器，它把tf.Session作为唯一的参数传入，返回一个和tf.Session具有相同方法的包装后的session。如果不为None，则包装后的对象将会在训练中使用。
    trace_every_n_steps: 以一种Chrome trace format生成并保存Timeline 保存的频率为trace_every_n_steps，如果为None， 没有任何trace信息将会别保存。
    ignore_live_threads: 如果为True，则忽略那些在停止supervisor之后仍然在运行的线程，而不是引发RuntimeError。
  Returns:
    训练后的损失函数的值

7、slim.get_variables_to_restore(include=None, exclude=None)：

获取所有变量，包括模型变量（如权重和参数）和常规变量(如global step)，可以传入scope进行过滤，源码如下：

def get_variables_to_restore(include=None, exclude=None):
  """Gets the list of the variables to restore.
  Args:
    include:一个可选的scope的列表或者元组，用来过滤来自VARIABLES collection中的变量。如果为None，则包含所有的变量。 
    exclude: 一个可选的scope的列表或者元组，用来用来过滤来自VARIABLES collection中的变量。如果为None，则过滤掉所有的变量。
  Returns:
    变量列表
  """
  if include is None:
    # 包含所有变量，包括model_variable和regular_variable
    vars_to_include = get_variables()
  else:
    if not isinstance(include, (list, tuple)):
      raise TypeError('include is provided but is not a list or a tuple.')
    vars_to_include = []
    for scope in include:
      vars_to_include += get_variables(scope)
  vars_to_exclude = set()
  if exclude is not None:
    if not isinstance(exclude, (list, tuple)):
      raise TypeError('exclude is provided but is not a list or a tuple.')
    for scope in exclude:
      vars_to_exclude |= set(get_variables(scope))
  # Exclude the variables in vars_to_exclude
  return [v for v in vars_to_include if v not in vars_to_exclude]

8、slim.assign_from_checkpoint_fn()：

返回一个函数，它从checkpoint文件读取变量值并分配给给特定变量。如果ignore_missing_vars为True，并且在检查点中找不到变量，则返回None。函数的源码如下

def assign_from_checkpoint_fn(model_path, var_list, ignore_missing_vars=False,
                              reshape_variables=False):
  """
  Args:
    model_path: 模型的checkpoint文件的绝对路径。为了得到最新的checkpoint文件，可以使用：model_path = tf.train.latest_checkpoint(checkpoint_dir)
    var_list: A list of `Variable` objects or a dictionary mapping names in the
        checkpoint to the corresponding variables to initialize. If empty or
        `None`, it would return `no_op(), None`.
    ignore_missing_vars: Bool型，如果为True，它将忽略在checkpoint文件中缺失的那些变量,。
    reshape_variables: Bool型, 如果为真，那么那些与checkpoint文件中的变量有不同形状的变量将会自动被reshape。
  Returns:
    一个只需要一个参数(tf.Session)函数,它作用是进行赋值操作。如果在checkpoint文件中没有找到任何匹配的变量，那么将会返回None

  """
  if not var_list:
    raise ValueError('var_list cannot be empty')
  if ignore_missing_vars:
    reader = pywrap_tensorflow.NewCheckpointReader(model_path)
    if isinstance(var_list, dict):
      var_dict = var_list
    else:
      var_dict = {var.op.name: var for var in var_list}
    available_vars = {}
    for var in var_dict:
      if reader.has_tensor(var):
        available_vars[var] = var_dict[var]
      else:
        logging.warning(
            'Variable %s missing in checkpoint %s', var, model_path)
    var_list = available_vars
  if var_list:
    saver = tf_saver.Saver(var_list, reshape=reshape_variables)
    def callback(session):
      saver.restore(session, model_path)
    return callback
  else:
    logging.warning('No Variables to restore')
    return None

9、

扫描二维码关注公众号，回复： 3310630 查看本文章

Slim下的函数介绍