此文为TensorFlow-Slim文档的翻译，转载自tensorflow中slim模块api介绍，原文README
TF-Slim is a lightweight library for defining, training and evaluating complex models in TensorFlow. Components of tf-slim can be freely mixed with native tensorflow, as well as other frameworks, such as tf.contrib.learn.
TF-Slim是TensorFlow中定义、训练和评估复杂模型的轻量级库。tf-slim的组件可以轻易地和原生Tensorflow框架及其他框架（如tf.contrib.learn）进行整合。
Usage
1 | import tensorflow.contrib.slim as slim |
Why TF-Slim?
TF-Slim is a library that makes building, training and evaluation neural networks simple:
TF-Slim使创建、训练及评估神经网络变得简单：
Allows the user to define models much more compactly by eliminating boilerplate code. This is accomplished through the use of argument scopingand numerous high level layers and variables. These tools increase readability and maintainability, reduce the likelihood of an error from copy-and pasting hyperparameter values and simplifies hyperparameter tuning.
允许用户通过消除样板代码来更加紧凑地定义模型，这是通过使用argument scoping和许多高等级的layers和variables来完成的。这些工具提高了可读性和可维护性，减少了因为复制粘贴超参数值而产生错误的可能性，并简化了超参数调整。Makes developing models simple by providing commonly used regularizers.
提供常用的regularizers，使开发模型变得简单。Several widely used computer vision models (e.g., VGG, AlexNet) have been developed in slim, and are available to users. These can either be used as black boxes, or can be extended in various ways, e.g., by adding “multiple heads” to different internal layers.
几种广泛使用的计算机视觉模型（如VGG、AlexNet）在slim中已经开发出来，可供用户使用。这些可以用作黑盒子，或者以各种方式扩展，比如向不同的内部层添加”multiple heads”。Slim makes it easy to extend complex models, and to warm start training algorithms by using pieces of pre-existing model checkpoints.
Slim使得扩展复杂模型变得很容易，并且可以通过使用预先存在的模型checkpoints来启动训练算法。
What are the various components of TF-Slim?
TF-Slim is composed of several parts which were design to exist independently. These include the following main pieces (explained in detail below).
TF-Slim由独立存在的几个部分组成，包括如下几个部分（详细解释如下）。
- arg_scope: provides a new scope named
arg_scopethat allows a user to define default arguments for specific operations within that scope. - data: contains TF-slim’s dataset definition, data providers, parallel_reader, and decoding utilities.
- evaluation: contains routines for evaluating models.
- layers:
contains high level layers for building models using tensorflow. - learning: contains routines for training models.
- losses: contains commonly used loss functions.
- metrics: contains popular evaluation metrics.
- nets: contains popular network definitions such as VGG and AlexNet models.
- 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.
- arg_scope：提供了一个新的scope名为arg_scope，它允许用户在scope内为特定操作定义默认参数。
- data:包含TF-Slim的dataset定义、data providers、parallel_reader及decoding用法。
- evaluation：包含评估模型的例程。
- layers：包含使lear用tensorflow构建模型的高层次图层。
- learning：包含训练模型的例程。
- losses：包含经常使用的loss函数。
- metrics：包含流行的评估指标。
- nets：包含流行的网络定义，如VGG、AlexNet模型。
- queues：提供了一个上下文管理器，可以轻松安全地启动和关闭QueueRunners。
- regularizers：包含权重regularizers。
- variables：为变量的创建和操作提供便利的wrappers。
Defining Models
Models can be succinctly defined using TF-Slim by combining its variables, layers and scopes. Each of these elements are defined below.
利用TF-Slim合并variables、layers及scopes可以简洁地定义模型。各元素定义如下。
Variables
Creating Variables in native tensorflow requires either a predefined value or an initialization mechanism (e.g. randomly sampled from a Gaussian). Furthermore, if a variable needs to be created on a specific device, such as a GPU, the specification must be made explicit. To alleviate the code required for variable creation, TF-Slim provides a set of thin wrapper functions in variables.py which allow callers to easily define variables.
想在原生tensorflow中创建variables，要么需要一个预定义值，要么需要一种初始化机制（比如从Gaussian中随机采样）。此外，如果变量需要在特定的设备上创建，比如GPU上，则需要显式指定。为了简化变量创建的代码，TF-Slim在variables.py中提供了一批轻量级的函数封装，从而使调用者可以更加容易地定义变量。
For example, to create a weight variable, initialize it using a truncated normal distribution, regularize it with an l2_loss and place it on the CPU, one need only declare the following:
例如，创建一个权值变量weight，用truncated normal分布进行初始化，用L2损失正则化，并放置于CPU中，我们只需要定义如下：
1 | weights = slim.variable('weights', |
Note that in native TensorFlow, there are two types of variables: regular variables and local (transient) variables. The vast majority of variables are regular variables: once created, they can be saved to disk using a saver. Local variables are those variables that only exist for the duration of a session and are not saved to disk.
在原生tensorflow中，有两种类型的变量：常规变量和局部（临时）变量。绝大部分都是常规变量，它们一旦创建，可以用Saver保存在磁盘上。局部变量则只在一个session期间存在，且不会保存在磁盘上。
TF-Slim further differentiates variables by defining model variables, which are variables that represent parameters of a model. Model variables are trained or fine-tuned during learning and are loaded from a checkpoint during evaluation or inference. Examples include the variables created by a slim.fully_connected or slim.conv2d layer. Non-model variables are all other variables that are used during learning or evaluation but are not required for actually performing inference. For example, the global_step is a variable using during learning and evaluation but it is not actually part of the model. Similarly, moving average variables might mirror model variables, but the moving averages are not themselves model variables.
TF-Slim通过定义model variables可以进一步区分变量，这种变量代表一个模型的参数。模型变量在学习阶段被训练或微调，在评估和预测阶段从checkpoint中加载，比如通过slim.fully_connected或slim.conv2d创建的变量。非模型变量是在学习或评估阶段使用，但不会在预测阶段起作用的变量。例如global_step，它在学习和评估阶段使用，但不是模型的一部分。类似地，移动均值可以mirror模型参数，但是它们本身不是模型变量。
Both model variables and regular variables can be easily created and retrieved via TF-Slim:
通过TF-Slim，模型变量和常规变量都可以很容易地创建和获取：
1 | # Model Variables |
How does this work? When you create a model variable via TF-Slim’s layers or directly via the slim.model_variable function, TF-Slim adds the variable to the tf.GraphKeys.MODEL_VARIABLES collection. What if you have your own custom layers or variable creation routine but still want TF-Slim to manage or be aware of your model variables? TF-Slim provides a convenience function for adding the model variable to its collection:
这是怎么起作用的呢？当你通过TF-Slim’s layers或者直接通过slim.model_variable函数创建一个模型变量，TF-Slim会把这个变量添加到tf.GraphKeys.MODEL_VARIABLES这个集合中。那我们自己的网络层变量怎么让TF-Slim管理呢？TF-Slim提供了一个很方便的函数可以将模型的变量添加到集合中：
1 | my_model_variable = CreateViaCustomCode() |
Layers
While the set of TensorFlow operations is quite extensive, developers of neural networks typically think of models in terms of higher level concepts like “layers”, “losses”, “metrics”, and “networks”. A layer, such as a Convolutional Layer, a Fully Connected Layer or a BatchNorm Layer are more abstract than a single TensorFlow operation and typically involve several operations. Furthermore, a layer usually (but not always) has variables (tunable parameters) associated with it, unlike more primitive operations. For example, a Convolutional Layer in a neural network is composed of several low level operations:
tensorflow的操作符集合是十分广泛的，神经网络开发者通常会以更高层的概念，比如”layers”、”losses”、”metrics”及”networks”去考虑模型。一个层，比如卷积层、全连接层或bn层，要比一个单独的tensorflow操作符更抽象，并且通常会包含若干操作符。此外，和原始操作符不同，一个层经常（不总是）有一些与自己相关的变量（可调参数）。例如，在神经网络中，一个卷积层由许多底层操作符组成：
- Creating the weight and bias variables
- Convolving the weights with the input from the previous layer
- Adding the biases to the result of the convolution.
- Applying an activation function.
1. 创建权重、偏置变量
2. 将来自上一层的数据和权值进行卷积
3. 在卷积结果上加上偏置
4. 应用激活函数
Using only plain TensorFlow code, this can be rather laborious:
如果只用普通的tensorflow代码，干这个事是相当的费事：
1 | input = ... |
To alleviate the need to duplicate this code repeatedly, TF-Slim provides a number of convenient operations defined at the more abstract level of neural network layers. For example, compare the code above to an invocation of the corresponding TF-Slim code:
为了缓解重复这些代码，TF-Slim在更抽象的神经网络层的层面上提供了大量方便使用的操作符。比如，将上面的代码和TF-Slim响应的代码调用进行比较：
1 | input = ... |
TF-Slim provides standard implementations for numerous components for building neural networks. These include:
TF-Slim提供了标准接口用于组建神经网络，包括：
| Layer | TF-Slim |
|---|---|
| BiasAdd | slim.bias_add |
| BatchNorm | slim.batch_norm |
| Conv2d | slim.conv2d |
| Conv2dInPlane | slim.conv2d_in_plane |
| Conv2dTranspose (Deconv) | slim.conv2d_transpose |
| FullyConnected | slim.fully_connected |
| AvgPool2D | slim.avg_pool2d |
| Dropout | slim.dropout |
| Flatten | slim.flatten |
| MaxPool2D | slim.max_pool2d |
| OneHotEncoding | slim.one_hot_encoding |
| SeparableConv2 | slim.separable_conv2d |
| UnitNorm | slim.unit_norm |
TF-Slim also provides two meta-operations called repeat and stack that allow users to repeatedly perform the same operation. For example, consider the following snippet from the VGG network whose layers perform several convolutions in a row between pooling layers:
TF-Slim也提供了两个元运算符——repeat和stack，允许用户可以重复地使用相同的运算符。例如，VGG网络的一个片段，这个网络在两个池化层之间就有许多卷积层的堆叠：
1 | net = ... |
One way to reduce this code duplication would be via a for loop:
一种减少这种代码重复的方法是使用for循环：
1 | net = ... |
This can be made even cleaner by using TF-Slim’s repeat operation:
若使用TF-Slim的repeat操作符，代码看起来会更简洁：
1 | net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3') |
Notice that the slim.repeat not only applies the same argument in-line, it also is smart enough to unroll the scopes such that the scopes assigned to each subsequent call of slim.conv2d are appended with an underscore and iteration number. More concretely, the scopes in the example above would be named ‘conv3/conv3_1’, ‘conv3/conv3_2’ and ‘conv3/conv3_3’.
slim.repeat不但可以在一行中使用相同的参数，而且还能智能地展开scope，即每个后续的slim.conv2d调用所对应的scope都会追加下划线及迭代数字。更具体地讲，上面代码的scope分别命名为’conv3/conv3_1’, ‘conv3/conv3_2’ and ‘conv3/conv3_3’.
Furthermore, TF-Slim’s slim.stack operator allows a caller to repeatedly apply the same operation with different arguments to create a stack or tower of layers. slim.stack also creates a new tf.variable_scope for each operation created. For example, a simple way to create a Multi-Layer Perceptron(MLP):
除此之外，TF-Slim的slim.stack操作符允许调用者用不同的参数重复使用相同的操作符来创建一个stack或网络层塔。slim.stack也会为每个创建的操作符生成一个新的tf.variable_scope。例如，下面是一个简单的方法去创建Multi-Layer Perceptron（MLP）：
1 | # Verbose way: |
In this example, slim.stack calls slim.fully_connected three times passing the output of one invocation of the function to the next. However, the number of hidden units in each invocation changes from 32 to 64 to 128. Similarly, one can use stack to simplify a tower of multiple convolutions:
在这个例子中，slim.stack调用slim.fully_connected三次，前一个层的输出是下一层的输入。而每个网络层的输出通道数从32变到64，再到128。同样，我们可以用stack简化一个多卷积层塔：
1 | # Verbose way: |
Scopes
In addition to the types of scope mechanisms in TensorFlow (name_scope,
variable_scope, TF-Slim adds a new scoping mechanism called arg_scope, This new scope allows a user to specify one or more operations and a set of arguments which will be passed to each of the operations defined in the arg_scope. This functionality is best illustrated by example. Consider the following code snippet:
除了tensorflow中自带的scope机制类型（name_scope, variable_scope）外, TF-Slim添加了一种叫做arg_scope的scope机制。这种scope允许用户在arg_scope中指定若干操作符以及一批参数，这些参数会传给前面所有的操作符中。参见以下代码：
1 | net = slim.conv2d(inputs, 64, [11, 11], 4, padding='SAME', |
It should be clear that these three convolution layers share many of the same hyperparameters. Two have the same padding, all three have the same weights_initializer and weight_regularizer. This code is hard to read and contains a lot of repeated values that should be factored out. One solution would be to specify default values using variables:
很明显这三个卷积层有很多超参数都是相同的。有两个卷积层有相同的padding设置，而且这三个卷积层都有相同的weights_initializer（权值初始化器）和weight_regularizer（权值正则化器）。这段代码很难读，且包含了很多重复的参数值。一种解决办法是用变量指定默认值：
1 | padding = 'SAME' |
This solution ensures that all three convolutions share the exact same parameter values but doesn’t reduce completely the code clutter. By using an arg_scope, we can both ensure that each layer uses the same values and simplify the code:
这种方式可以确保这三个卷积层共享相同的参数值，但是仍然没有减少代码规模。通过使用arg_scope，我们既能确保每层共享参数值，又能精简代码：
1 | with slim.arg_scope([slim.conv2d], padding='SAME', |
As the example illustrates, the use of arg_scope makes the code cleaner, simpler and easier to maintain. Notice that while argument values are specified in the arg_scope, they can be overwritten locally. In particular, while the padding argument has been set to ‘SAME’, the second convolution overrides it with the value of ‘VALID’.
如例所示，arg_scope使代码更简洁且易于维护。注意，在arg_scope中被指定的参数值，也可以在局部位置进行覆盖。比如，padding参数设置为’SAME’, 而第二个卷积层仍然可以通过把它设为’VALID’而覆盖掉arg_scope中的默认设置。
One can also nest arg_scopes and use multiple operations in the same scope. For example:
我们可以嵌套arg_scope, 也可以在一个scope中指定多个操作符，例如：
1 | with slim.arg_scope([slim.conv2d, slim.fully_connected], |
In this example, the first arg_scope applies the same weights_initializer and weights_regularizer arguments to the conv2d and fully_connected layers in its scope. In the second arg_scope, additional default arguments to conv2d only are specified.
在这个例子中，第一个arg_scope对处于它的scope中的conv2d和fully_connected操作层应用相同的weights_initializer andweights_regularizer参数。在第二个arg_scope中，默认参数只是在conv2d中指定。
Working Example: Specifying the VGG16 Layers
By combining TF-Slim Variables, Operations and scopes, we can write a normally very complex network with very few lines of code. For example, the entire VGG architecture can be defined with just the following snippet:
通过整合TF-Slim的变量、操作符和scope，我们可以用寥寥几行代码写一个通常非常复杂的网络。例如，完整的VGG结构只需要用下面的一小段代码定义：
1 | def vgg16(inputs): |
Training Models
Training Tensorflow models requires a model, a loss function, the gradient computation and a training routine that iteratively computes the gradients of the model weights relative to the loss and updates the weights accordingly. TF-Slim provides both common loss functions and a set of helper functions that run the training and evaluation routines.
训练一个tensorflow模型，需要一个网络模型、一个损失函数、梯度计算方式和用于迭代计算模型权重的训练过程。TF-Slim提供了损失函数，同时也提供了一批运行训练和评估模型的帮助函数。
Losses
The loss function defines a quantity that we want to minimize. For classification problems, this is typically the cross entropy between the true distribution and the predicted probability distribution across classes. For regression problems, this is often the sum-of-squares differences between the predicted and true values.
损失函数定义了我们想最小化的量。对于分类问题，它通常是真实分布和预测概率分布的交叉熵。对于回归问题，它通常是真实值和预测值的平方和。
Certain models, such as multi-task learning models, require the use of multiple loss functions simultaneously. In other words, the loss function ultimately being minimized is the sum of various other loss functions. For example, consider a model that predicts both the type of scene in an image as well as the depth from the camera of each pixel. This model’s loss function would be the sum of the classification loss and depth prediction loss.
对于特定的模型，比如多任务学习模型，可能需要同时使用多个损失函数。换句话说，正在最小化的损失函数是其他一些损失函数的和。例如，有一个模型既要预测图像中场景的类型，又要预测每个像素的深度。那这个模型的损失函数就是分类损失和深度预测损失的和。
TF-Slim provides an easy-to-use mechanism for defining and keeping track of loss functions via the losses module. Consider the simple case where we want to train the VGG network:
TF-Slim通过losses模块，提供了一种易用的机制去定义和跟踪损失函数。看一个简单的例子，我们想训练VGG网络：
1 | import tensorflow as tf |
In this example, we start by creating the model (using TF-Slim’s VGG implementation), and add the standard classification loss. Now, lets turn to the case where we have a multi-task model that produces multiple outputs:
在上面的例子中，我们首先创建了模型（用TF-Slim的VGG接口实现），并添加了标准的分类损失。现在，我们再看一个产生多输出的多任务模型：
1 | # Load the images and labels. |
In this example, we have two losses which we add by calling slim.losses.softmax_cross_entropy and slim.losses.sum_of_squares. We can obtain the total loss by adding them together (total_loss) or by calling slim.losses.get_total_loss(). How did this work? When you create a loss function via TF-Slim, TF-Slim adds the loss to a special TensorFlow collection of loss functions. This enables you to either manage the total loss manually, or allow TF-Slim to manage them for you.
在这个例子中，我们有两个损失，分别是通过slim.losses.softmax_cross_entropy和 slim.losses.sum_of_squares得到的。我们既可以通过相加得到total_loss，也可以通过slim.losses.get_total_loss()得到total_loss。这是怎么做到的呢？当你通过TF-Slim创建一个损失函数时，TF-Slim会把损失加入到一个特殊的Tensorflow的损失函数集合中。这样你既可以手动管理损失函数，也可以托管给TF-Slim。
What if you want to let TF-Slim manage the losses for you but have a custom loss function? loss_ops.py also has a function that adds this loss to TF-Slims collection. For example:
如果我们有一个自定义的损失函数，现在也想托管给TF-Slim，该怎么做呢？loss_ops.py也有一个函数可以将这个损失函数加入到TF-Slim集合中。例如：
1 | # Load the images and labels. |
In this example, we can again either produce the total loss function manually or let TF-Slim know about the additional loss and let TF-Slim handle the losses.
这个例子中，我们同样既可以手动管理损失函数，也可以让TF-Slim知晓这个自定义损失函数，然后托管给TF-Slim。
Training Loop
TF-Slim provides a simple but powerful set of tools for training models found in learning.py. These include a Train function that repeatedly measures the loss, computes gradients and saves the model to disk, as well as several convenience functions for manipulating gradients. For example, once we’vespecified the model, the loss function and the optimization scheme, we can call slim.learning.create_train_op and slim.learning.train to perform the optimization:
在learning.py中，TF-Slim提供了简单却非常强大的训练模型的工具集。包括Train函数，可以重复地测量损失、计算梯度以及保存模型到磁盘中，还有一些方便的函数用于操作梯度。例如，当我们定义好了模型、损失函数以及优化方式，我们就可以调用slim.learning.create_train_op和 slim.learning.train 去执行优化：
1 | g = tf.Graph() |
In this example, slim.learning.train is provided with the train_op which is used to (a) compute the loss and (b) apply the gradient step. logdir specifies the directory where the checkpoints and event files are stored. We can limit the number of gradient steps taken to any number. In this case, we’ve asked for 1000 steps to be taken. Finally, save_summaries_secs=300 indicates that we’ll compute summaries every 5 minutes and save_interval_secs=600 indicates that we’ll save a model checkpoint every 10 minutes.
在该例中，slim.learning.train根据train_op计算损失、应用梯度step。logdir指定了checkpoints和event文件的存储路径。我们可以限制梯度step到任何数值。这里我们采用1000步。最后，save_summaries_secs=300表示每5分钟计算一次summaries，save_interval_secs=600表示每10分钟保存一次模型的checkpoint。
Working Example: Training the VGG16 Model
To illustrate this, lets examine the following sample of training the VGG network:
为了说明，让我们测试以下训练VGG的例子：
1 | import tensorflow as tf |
Fine-Tuning Existing Models
Brief Recap on Restoring Variables from a Checkpoint
After a model has been trained, it can be restored using tf.train.Saver() which restores Variables from a given checkpoint. For many cases, tf.train.Saver() provides a simple mechanism to restore all or just a few variables.
在一个模型训练完成后，我们可以用tf.train.Saver()通过指定checkpoing加载variables的方式加载这个模型。对于很多情况，tf.train.Saver()提供了一种简单的机制去加载所有或一些varialbes变量。
1 | # Create some variables. |
See Restoring Variables and Choosing which Variables to Save and Restore sections of the Variables page for more details.
参阅Variables章中Restoring Variables和Choosing which Variables to Save and Restor 相关部分，获取更多细节。
Partially Restoring Models
It is often desirable to fine-tune a pre-trained model on an entirely new dataset or even a new task. In these situations, one can use TF-Slim’s helper functions to select a subset of variables to restore:
有时我们希望在一个全新的数据集上或面对一个信息任务方向去微调预训练模型。在这些情况下，我们可以使用TF-Slim’s的帮助函数去加载模型中变量的一个子集：
1 | # Create some variables. |
Restoring models with different variable names
When restoring variables from a checkpoint, the Saver locates the variable names in a checkpoint file and maps them to variables in the current graph. Above, we created a saver by passing to it a list of variables. In this case, the names of the variables to locate in the checkpoint file were implicitly obtained from each provided variable’s var.op.name.
当从checkpoint加载变量时，Saver先在checkpoint中定位变量名，然后映射到当前图的变量中。我们也可以通过向saver传递一个变量列表来创建saver，这时，在checkpoint文件中用于定位的变量名可以隐式地从各自的var.op.name中获得。
This works well when the variable names in the checkpoint file match those in the graph. However, sometimes, we want to restore a model from a checkpoint whose variables have different names to those in the current graph. In this case, we must provide the Saver a dictionary that maps from each checkpoint variable name to each graph variable. Consider the following example where the checkpoint variables names are obtained via a simple function:
当checkpoint文件中的变量名与当前图中的变量名完全匹配时，这会运行得很好。但是，有时我们想从一个变量名与与当前图的变量名不同的checkpoint文件中装载一个模型。这时，我们必须提供一个saver字典，这个字典对checkpoint中的每个变量和每个图变量进行了一一映射。请看下面这个例子，checkpoint的变量名是通过一个简单的函数获得的：
1 | # Assuming than 'conv1/weights' should be restored from 'vgg16/conv1/weights' |
Fine-Tuning a Model on a different task
Consider the case where we have a pre-trained VGG16 model. The model was trained on the ImageNet dataset, which has 1000 classes. However, we would like to apply it to the Pascal VOC dataset which has only 20 classes. To do so, we can initialize our new model using the values of the pre-trained model excluding the final layer:
假设我们有一个已经预训练好的VGG16的模型。这个模型是在拥有1000分类的ImageNet数据集上进行训练的。但是，现在我们想把它应用在只具有20个分类的Pascal VOC数据集上。为了能这样做，我们可以通过利用除最后一些全连接层的其他预训练模型值来初始化新模型达到目的：
1 | # Load the Pascal VOC data |
Evaluating Models.
Once we’ve trained a model (or even while the model is busy training) we’d like to see how well the model performs in practice. This is accomplished by picking a set of evaluation metrics, which will grade the models performance, and the evaluation code which actually loads the data, performs inference, compares the results to the ground truth and records the evaluation scores. This step may be performed once or repeated periodically.
一旦我们训练好了一个模型（或者模型还在训练中），我们想看一下模型在实际中性能如何。这可以通过获取一系列表征模型性能的评估指标来实现，评估代码一般会加载数据，执行前向传播，和ground truth进行比较并记录评估分数。这个步骤可能执行一次，也可能周期性地执行。
Metrics
We define a metric to be a performance measure that is not a loss function (losses are directly optimized during training), but which we are still interested in for the purpose of evaluating our model. For example, we might want to minimize log loss, but our metrics of interest might be F1 score (test accuracy), or Intersection Over Union score (which are not differentiable, and therefore cannot be used as losses).
比如我们定义了一个不是损失函数的性能度量指标（损失在训练过程中进行直接优化），而这个指标出于评估模型的目的我们还非常感兴趣。比如说我们想最小化log损失，但是我们感兴趣的指标可能是F1 score（测试准确率），或者Intersection Over Union score 这个指标不可微，因此不能作为损失）。
TF-Slim provides a set of metric operations that makes evaluating models easy. Abstractly, computing the value of a metric can be divided into three parts:
TF-Slim提供了一系列指标操作符，它们可以使模型评估更简单。抽象来讲，计算一个指标值可以分为3步：
- Initialization: initialize the variables used to compute the metrics.
- Aggregation: perform operations (sums, etc) used to compute the metrics.
- Finalization: (optionally) perform any final operation to compute metric values. For example, computing means, mins, maxes, etc.
1. 初始化：初始化用于计算指标的变量。
2. 聚合：执行用于计算指标的运算流程（比如sum）。
3. 收尾：（可选）执行其他用于计算指标值的操作。例如，计算mean、min、max等。
For example, to compute mean_absolute_error, two variables, a count and total variable are initialized to zero. During aggregation, we observed some set of predictions and labels, compute their absolute differences and add the total to total. Each time we observe another value, count is incremented. Finally, during finalization, total is divided by count to obtain the mean.
例如，为了计算mean_absolute_error，一个count变量和一个total变量需要初始化为0. 在聚合阶段，我们可以观察到一系列预测值及标签，计算他们差的绝对值，并加到total中。每次循环，count变量自加1。最后，在收尾阶段，total除以count就得到了mean。
The following example demonstrates the API for declaring metrics. Because metrics are often evaluated on a test set which is different from the training set (upon which the loss is computed), we’ll assume we’re using test data:
下面的例子演示了定义指标的API。因为指标通常是在测试集上计算，而不是训练集（训练集上是用于计算loss的），我们假设我们在使用测试集：
1 | images, labels = LoadTestData(...) |
As the example illustrates, the creation of a metric returns two values: a value_op and an update_op. The value_op is an idempotent operation that returns the current value of the metric. The update_op is an operation that performs the aggregation step mentioned above as well as returning the value of the metric.
如上例所示，指标的创建会返回两个值，一个value_op和一个update_op。value_op表示和当前指标值相等的操作，update_op是上文提到的执行聚合步骤并返回指标值的操作符。
Keeping track of each value_op and update_op can be laborious. To deal with this, TF-Slim provides two convenience functions:
跟踪每个value_op和update_op是非常费劲的。为了解决这个问题，TF-Slim提供了两个方便的函数：
1 |
|
Working example: Tracking Multiple Metrics
Putting it all together:
1 | import tensorflow as tf |
Note that metric_ops.py can be used in isolation without using either layers.py or loss_ops.py
注意，metric_ops.py可以在没有layers.py和loss_ops.py的情况下独立使用。
Evaluation Loop
TF-Slim provides an evaluation module (evaluation.py), which contains helper functions for writing model evaluation scripts using metrics fromthe metric_ops.py module. These include a function for periodically running evaluations, evaluating metrics over batches of data and printing and summarizing metric results. For example:
TF-Slim提供了一个评估模块（evaluation.py），这个模块包含了一些利用metric_ops.py模块的指标写模型评估脚本的帮助函数。其中包含一个可以周期运行评估，评估数据batch之间的指标、打印并总结指标结果的函数。例如：
1 | import tensorflow as tf |
Authors
Sergio Guadarrama and Nathan Silberman