T 2

---

tf.nn.relu

max(features, 0)

tf.nn.relu(
    features,
    name=None
)

---

tf.clip_by_value

Clips tensor values to a specified min and max.

tf.clip_by_value(
    t,
    clip_value_min,
    clip_value_max,
    name=None
)

---

class tf.train.ExponentialMovingAverage

__init__(
    decay,
    num_updates=None,
    zero_debias=False,
    name='ExponentialMovingAverage'
)

decay： 决定影子变量(shadow_variable)的更新速度，其中影子变量的初始值就是相应变量的初始值；

num_updates： 动态设置衰减率(decay)的大小；

• 方法

apply()： 将滑动平均模型应用于训练变量；
average()： 提供访问阴影变量的值；
average_name()： 提供访问阴影变量的名称；
variables_to_restore： 返回变量对应的影子变量；

• 代码示例

import tensorflow as tf 

v1 = tf.Variable(0, dtype=tf.float32)

ema = tf.train.ExponentialMovingAverage(0.99, 0)
maintain_average_op = ema.apply([v1])

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print(sess.run([v1, ema.average(v1)]))  #[0.0, 0.0]

    sess.run(tf.assign(v1, 5))
    sess.run(maintain_average_op)
    print(sess.run([v1, ema.average(v1)]))  #[5.0, 4.5]

#variables_to_restore
v = tf.Variable(1.,name="v")  
ema = tf.train.ExponentialMovingAverage(0.99)  
print(ema.variables_to_restore())  
#{'v/ExponentialMovingAverage': <tf.Variable 'v:0' shape=() dtype=float32_ref>}  

saver = tf.train.Saver(ema.variables_to_restore()) 
with tf.Session()  as sess:
    saver.restore(sess,"./model.ckpt")  
    print(sess.run(v))      #0.0999999  

---

tf.nn.softmax_cross_entropy_with_logits_v2

tf.nn.softmax_cross_entropy_with_logits -- f1
tf.nn.sparse_softmax_cross_entropy_with_logits -- f2
tf.nn.softmax_cross_entropy_with_logits_v2 -- f3
f1 和 f3 的 labels 格式不同，f1为未处理的，比如[0,0,1,0]。f3 为真值的索引，比如2。可用 tf.argmax() 来从[0,0,1,0]中取得真值的索引。
f2 同时会对 labels 进行反向传播，比如GAN网络。

tf.nn.softmax_cross_entropy_with_logits_v2(
    _sentinel=None,
    labels=None,
    logits=None,
    dim=-1,
    name=None
)

labels： 为样本 真实 值；
logits： 为样本 预测 值；

• 代码示例

cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
    logits=y, labels=tf.argmax(y_, 1)
cross_entropy_mean = tf.reduce_mean(cross_entropy)
)

• tf.argmax()

test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])
np.argmax(test, 0)　　　＃输出：array([3, 3, 1]
np.argmax(test, 1)　　　＃输出：array([2, 2, 0, 0]

---

tf.reduce_mean

• 函数形式

reduce_mean(input_tensor,
                axis=None,
                keep_dims=False,
                name=None)

input_tensor： 输入的待降维的tensor;
axis： 指定的轴，如果不指定，则计算所有元素的均值;
keep_dims：是否降维度，设置为True，输出的结果保持输入tensor的形状，设置为False，输出结果会降低维度;
name： 操作的名称;

• 代码示例

import tensorflow as tf
 
x = [[1,2,3],
     [1,2,3]]
 
xx = tf.cast(x,tf.float32)
 
mean_all = tf.reduce_mean(xx, keep_dims=False)
mean_0 = tf.reduce_mean(xx, axis=0, keep_dims=False)
mean_1 = tf.reduce_mean(xx, axis=1, keep_dims=False)
 
with tf.Session() as sess:
    m_a,m_0,m_1 = sess.run([mean_all, mean_0, mean_1])
 
print m_a    # output: 2.0
print m_0    # output: [ 1.  2.  3.]
print m_1    # output:  [ 2.  2.]

#keep_dims=True

print m_a    # output: [[ 2.]]
print m_0    # output: [[ 1.  2.  3.]]
print m_1    # output: [[ 2.], [ 2.]]

---

tf.square

计算x元素的平方。

tf.math.square(
    x,
    name=None
)

---

tf.train.exponential_decay

• 函数形式

tf.train.exponential_decay(
    learning_rate,
    global_step,
    decay_steps,
    decay_rate,
    staircase=False,
    name=None
)

learning_rate： 基础学习率；
global_step： 当前迭代轮数；
decay_steps： 代表过一遍训练数据的迭代轮数；
decay_rate： 衰减系数；
staircase： 衰减方式，当为True时，衰减率为阶梯函数；

decayed_learning_rate = learning_rate *
                        decay_rate ^ (global_step / decay_steps)

• 代码示例

...
global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.1
learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
                                           100000, 0.96, staircase=True)
# Passing global_step to minimize() will increment it at each step.
learning_step = (
    tf.train.GradientDescentOptimizer(learning_rate)
    .minimize(...my loss..., global_step=global_step)
)

---

tf.contrib.layers.l2_regularizer

tf.contrib.layers.l2_regularizer(
    scale,
    scope=None
)

scale：标量，0.0禁用正则化。

loss = tf.reduce_mean(tf.square(y_ - y)) +
    tf.contrib.layers.l2_regularizer(lambda)(w)
    
weights = tf.constant([[1.0, -2.0], [-3.0, 4.0]])
with tf.Session() as sess:
    print(sess.run(tf.contrib.layers.l2_regularizer(.5)(weights)))
    #(1^2+(-2)^2+(-3)^2+4^2)/2*0.5=7.5

---

class tf.train.GradientDescentOptimizer

• __init__

__init__(
    learning_rate,
    use_locking=False,
    name='GradientDescent'
)

learning_rate: 学习率；
use_locking: 如果是True，锁定更新操作；

• minimize

minimize(
    loss,
    global_step=None,
    var_list=None,
    gate_gradients=GATE_OP,
    aggregation_method=None,
    colocate_gradients_with_ops=False,
    name=None,
    grad_loss=None
)

loss： 最小化损失的值；
global_step： 变量更新后递增1；

train_step = tf.train.GradientDescentOptimizer(learning_rate)\
                .minimize(loss)