TensorFlow 之 slim（TF-Slim）介绍

最新推荐文章于 2023-08-26 22:02:27 发布

南淮北安

最新推荐文章于 2023-08-26 22:02:27 发布

阅读量2.8k

点赞数 3

分类专栏： TensorFlow 学习文章标签： tensorflow slim（TF-Slim）介绍

原文链接：https://www.2cto.com/kf/201706/649266.html

版权

TensorFlow 学习专栏收录该内容

56 篇文章 24 订阅

订阅专栏

文章目录

一、简介

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

import tensorflow.contrib.slim as slim
或
import tensorflow as tf
slim = tf.contrib.slim

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

它可以消除原生tensorflow里面很多重复的模板性的代码，让代码更精确，更容易替换性。另外slim提供了很多计算机视觉方面的著名模型（VGG，AlexNet等），我们不仅可以直接使用，甚至能以各种方式进行扩展。

二、slim的子模块及功能介绍

arg_scope：提供了一个名为arg_scope的新范围，该范围允许用户为该范围内的特定操作定义默认参数。
除了基本的 namescope，variabelscope外，又加了argscope，它是用来控制每一层的替代超参数的。

data（数据）：包含TF-slim的数据集定义，数据提供程序，parallel_reader和解码实用程序。

evaluation（评估）：包含评估模型的例程，评估模型的一些方法，用的不多

layers（层）：包含用于使用张量流构建模型的高层。
			 这个比较重要，slim的核心和精髓，一些复杂层的定义

learning（学习）：包含用于训练模型的模型

loss：包含常用的损失函数。

matris（指标）：包含流行的评估指标，评估模型的准则标准

nets（网络）：包含流行的网络定义，例如VGG和AlexNet模型。

queues（队列）：提供上下文管理器，可轻松安全地启动和关闭QueueRunner。

variables（变量）：为变量创建和操作提供方便的包装。

三、slim 定义模型

1. slim中定义一个变量的示例

# Model Variables
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()
 
# Regular variables
my_var = slim.variable('my_var',
                       shape=[20, 1],
                       initializer=tf.zeros_initializer())
regular_variables_and_model_variables = slim.get_variables()

如上，变量分为两类：模型变量和局部变量。
局部变量是不作为模型参数保存的，而模型变量会在保存的时候保存下来。这个玩过tensorflow的人都会明白，诸如global_step之类的就是局部变量。
slim中可以写明变量存放的设备，正则和初始化规则。
还有获取变量的函数也需要注意一下，get_variables是返回所有的变量。

2. slim中实现一个层

首先让我们看看tensorflow怎么实现一个层，例如卷积层：

input = ...
with tf.name_scope('conv1_1') as scope:
  kernel = tf.Variable(tf.truncated_normal([3, 3, 64, 128], dtype=tf.float32,
                                           stddev=1e-1), name='weights')
  conv = tf.nn.conv2d(input, kernel, [1, 1, 1, 1], padding='SAME')
  biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),
                       trainable=True, name='biases')
  bias = tf.nn.bias_add(conv, biases)
  conv1 = tf.nn.relu(bias, name=scope)

然后slim的实现：

input = ...
net = slim.conv2d(input, 128, [3, 3], scope='conv1_1')

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

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

net = ...
net = slim.conv2d(net, 256, [3, 3], scope='conv3_1')
net = slim.conv2d(net, 256, [3, 3], scope='conv3_2')
net = slim.conv2d(net, 256, [3, 3], scope='conv3_3')
net = slim.max_pool2d(net, [2, 2], scope='pool2')

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

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

假设定义三层FC：

# Verbose way:
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操作：

slim.stack(x, slim.fully_connected, [32, 64, 128], scope='fc')

同理卷积层也一样：

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

3. slim 中的 argscope

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

net = slim.conv2d(inputs, 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处理一下：

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(inputs, 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')

是不是一下子就变简洁了？
这里额外说明一点，arg_scope 的作用范围内，是定义了指定层的替代参数，若想特别指定某些层的参数，可以重新赋值（相当于重置），如上倒数第二行代码。
那如果除了卷积层还有其他层呢？那就要如下定义：

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(inputs, 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也就十几行代码的事了

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)

不是超级简单？

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

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

# 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()

五、读取保存模型变量

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

# Create some variables.
v1 = slim.variable(name="v1", ...)
v2 = slim.variable(name="nested/v2", ...)
...
 
# Get list of variables to restore (which contains only 'v2').
variables_to_restore = slim.get_variables_by_name("v2")
 
# 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.")

除了这种部分变量加载的方法外，我们甚至还能加载到不同的名字的变量中。

假设我们定义的网络变量是conv1 / weights，而从VGG加载的变量称为vgg16 / conv1 / weights，正常负载肯定会报错（找不到变量名），但是可以这样：

def name_in_checkpoint(var):
  return 'vgg16/' + var.op.name
 
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")

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

参考：
【1】https://blog.csdn.net/zhoujunr1/article/details/77131605
【2】https://www.2cto.com/kf/201706/649266.html
【3】https://blog.csdn.net/zsWang9/article/details/79965501

南淮北安

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
TensorFlow 之 slim（TF-Slim）介绍

文章目录一、简介二、slim的子模块及功能介绍三、slim 定义模型1. slim中定义一个变量的示例2. slim中实现一个层3. slim 中的 argscope三、训练模型四、读取保存模型变量一、简介slim被放在tensorflow.contrib这个库下面，引入的方法如下：import tensorflow.contrib.slim as slim或import tensor...
复制链接

扫一扫