摘要：表示元素是否放電的概率。更加具體的表示細節為注意，必須有。數據維度是四維。在大部分處理過程中，卷積核的水平移動步數和垂直移動步數是相同的，即。

作者：chen_h
微信號 & QQ：862251340
微信公眾號：coderpai
簡書地址：https://www.jianshu.com/p/e3a...

計劃現將 tensorflow 中的 Python API 做一個學習，這樣方便以后的學習。
原文鏈接

激活函數表示

在神經網絡中，我們有很多的非線性函數來作為激活函數，比如連續的平滑非線性函數（sigmoid，tanh和softplus），連續但不平滑的非線性函數（relu，relu6和relu_x）和隨機正則化函數（dropout）。

所有的激活函數都是多帶帶應用在每個元素上面的，并且輸出張量的維度和輸入張量的維度一樣。

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

解釋：這個函數的作用是計算激活函數relu，即max(features, 0)。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf

a = tf.constant([-1.0, 2.0])
with tf.Session() as sess:
    b = tf.nn.relu(a)
    print sess.run(b)

輸入參數：

features: 一個Tensor。數據類型必須是：float32，float64，int32，int64，uint8，int16，int8。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型和features相同。

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

解釋：這個函數的作用是計算激活函數relu6，即min(max(features, 0), 6)。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf

a = tf.constant([-1.0, 12.0])
with tf.Session() as sess:
    b = tf.nn.relu6(a)
    print sess.run(b)

輸入參數：

features: 一個Tensor。數據類型必須是：float，double，int32，int64，uint8，int16或者int8。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型和features相同。

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

解釋：這個函數的作用是計算激活函數softplus，即log( exp( features ) + 1)。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf

a = tf.constant([-1.0, 12.0])
with tf.Session() as sess:
    b = tf.nn.softplus(a)
    print sess.run(b)

輸入參數：

features: 一個Tensor。數據類型必須是：float32，float64，int32，int64，uint8，int16或者int8。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型和features相同。

tf.nn.dropout(x, keep_prob, noise_shape = None, seed = None, name = None)

解釋：這個函數的作用是計算神經網絡層的dropout。

一個神經元將以概率keep_prob決定是否放電，如果不放電，那么該神經元的輸出將是0，如果該神經元放電，那么該神經元的輸出值將被放大到原來的1/keep_prob倍。這里的放大操作是為了保持神經元輸出總個數不變。比如，神經元的值為[1, 2]，keep_prob的值是0.5，并且是第一個神經元是放電的，第二個神經元不放電，那么神經元輸出的結果是[2, 0]，也就是相當于，第一個神經元被當做了1/keep_prob個輸出，即2個。這樣保證了總和2個神經元保持不變。

默認情況下，每個神經元是否放電是相互獨立的。但是，如果noise_shape被修改了，那么他對于變量x就是一個廣播形式，而且當且僅當 noise_shape[i] == shape(x)[i] ，x中的元素是相互獨立的。比如，如果 shape(x) = [k, l, m, n], noise_shape = [k, 1, 1, n] ，那么每個批和通道都是相互獨立的，但是每行和每列的數據都是關聯的，即要不都為0，要不都還是原來的值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf

a = tf.constant([[-1.0, 2.0, 3.0, 4.0]])
with tf.Session() as sess:
    b = tf.nn.dropout(a, 0.5, noise_shape = [1,4])
    print sess.run(b)
    b = tf.nn.dropout(a, 0.5, noise_shape = [1,1])
    print sess.run(b)

輸入參數：

x: 一個Tensor。

keep_prob: 一個 Python 的 float 類型。表示元素是否放電的概率。

noise_shape: 一個一維的Tensor，數據類型是int32。代表元素是否獨立的標志。

seed: 一個Python的整數類型。設置隨機種子。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據維度和x相同。

異常：

輸入異常: 如果 keep_prob 不是在 (0, 1]區間，那么會提示錯誤。

tf.nn.bias_add(value, bias, name = None)

解釋：這個函數的作用是將偏差項 bias 加到 value 上面。

這個操作你可以看做是 tf.add 的一個特例，其中 bias 必須是一維的。該API支持廣播形式，因此 value 可以有任何維度。但是，該API又不像 tf.add ，可以讓 bias 的維度和 value 的最后一維不同。具體看使用例子。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([[1.0, 2.0],[1.0, 2.0],[1.0, 2.0]]) 
b = tf.constant([2.0,1.0])  
c = tf.constant([1.0])
sess = tf.Session()
print sess.run(tf.nn.bias_add(a, b))
# 因為 a 最后一維的維度是 2 ，但是 c 的維度是 1，所以以下語句將發生錯誤
print sess.run(tf.nn.bias_add(a, c))
# 但是 tf.add() 可以正確運行
print sess.run(tf.add(a, c))

輸入參數：

value: 一個Tensor。數據類型必須是float，double，int64，int32，uint8，int16，int8或者complex64。

bias: 一個一維的Tensor，數據維度和 value 的最后一維相同。數據類型必須和value相同。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型和value相同。

tf.sigmoid(x, name = None)

解釋：這個函數的作用是計算 x 的 sigmoid 函數。具體計算公式為 y = 1 / (1 + exp(-x))。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([[1.0, 2.0], [1.0, 2.0], [1.0, 2.0]])
sess = tf.Session()
print sess.run(tf.sigmoid(a))

輸入參數：

x: 一個Tensor。數據類型必須是float，double，int32，complex64，int64或者qint32。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，如果 x.dtype != qint32 ，那么返回的數據類型和x相同，否則返回的數據類型是 quint8 。

tf.tanh(x, name = None)

解釋：這個函數的作用是計算 x 的 tanh 函數。具體計算公式為 ( exp(x) - exp(-x) ) / ( exp(x) + exp(-x) )。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([[1.0, 2.0],[1.0, 2.0],[1.0, 2.0]])
sess = tf.Session()
print sess.run(tf.tanh(a))

輸入參數：

x: 一個Tensor。數據類型必須是float，double，int32，complex64，int64或者qint32。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，如果 x.dtype != qint32 ，那么返回的數據類型和x相同，否則返回的數據類型是 quint8 。

卷積層

卷積操作是使用一個二維的卷積核在一個批處理的圖片上進行不斷掃描。具體操作是將一個卷積核在每張圖片上按照一個合適的尺寸在每個通道上面進行掃描。為了達到好的卷積效率，需要在不同的通道和不同的卷積核之間進行權衡。

conv2d: 任意的卷積核，能同時在不同的通道上面進行卷積操作。

depthwise_conv2d: 卷積核能相互獨立的在自己的通道上面進行卷積操作。

separable_conv2d: 在縱深卷積 depthwise filter 之后進行逐點卷積 separable filter 。

注意，雖然這些操作被稱之為“卷積”操作，但是嚴格的說，他們只是互相關，因為卷積核沒有做一個逆向的卷積過程。

卷積核的卷積過程是按照 strides 參數來確定的，比如 strides = [1, 1, 1, 1] 表示卷積核對每個像素點進行卷積，即在二維屏幕上面，兩個軸方向的步長都是1。strides = [1, 2, 2, 1] 表示卷積核對每隔一個像素點進行卷積，即在二維屏幕上面，兩個軸方向的步長都是2。

如果我們先暫且不考慮通道這個因素，那么卷積操作的空間含義定義如下：如果輸入數據是一個四維的 input ，數據維度是 [batch, in_height, in_width, ...]，卷積核也是一個四維的卷積核，數據維度是 [filter_height, filter_width, ...] ，那么：

shape(output) = [batch,
                (in_height - filter_height + 1) / strides[1],
                (in_width - filter_width + 1) / strides[2],
                ...]
output[b, i, j, :] = 
          sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, ...] * 
                   filter[di, dj, ...]

因為，input 數據是一個四維的，每一個通道上面是一個向量 input[b, i, j, :] 。對于 conv2d ，這些向量將會被卷積核 filter[di, dj, :, :] 相乘而產生一個新的向量。對于 depthwise_conv_2d ，每個標量分量 input[b, i, j, k] 將在 k 個通道上面獨立的被卷積核 filter[di, dj, k] 進行卷積操作，然后把所有得到的向量進行連接組合成一個新的向量。

對于輸出數據的維度 shape(output)，這取決于填充參數 padding 的設置：

padding = "SAME": 向下取舍，僅適用于全尺寸操作，即輸入數據維度和輸出數據維度相同。

padding = "VALID: 向上取舍，適用于部分窗口，即輸入數據維度和輸出數據維度不同。

tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)

解釋：這個函數的作用是對一個四維的輸入數據 input 和四維的卷積核 filter 進行操作，然后對輸入數據進行一個二維的卷積操作，最后得到卷積之后的結果。

給定的輸入張量的維度是 [batch, in_height, in_width, in_channels] ，卷積核張量的維度是 [filter_height, filter_width, in_channels, out_channels] ，具體卷積操作如下：

將卷積核的維度轉換成一個二維的矩陣形狀 [filter_height * filter_width * in_channels, output_channels]

對于每個批處理的圖片，我們將輸入張量轉換成一個臨時的數據維度 [batch, out_height, out_width, filter_height * filter_width * in_channels] 。

對于每個批處理的圖片，我們右乘以卷積核，得到最后的輸出結果。

更加具體的表示細節為：

output[b, i, j, k] = 
           sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * 
                     filter[di, dj, q, k]

注意，必須有 strides[0] = strides[3] = 1。在大部分處理過程中，卷積核的水平移動步數和垂直移動步數是相同的，即 strides = [1, stride, stride, 1] 。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 1), dtype = np.float32)

y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = "SAME")

with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(y)
    print sess.run(tf.shape(y))

輸入參數：

input: 一個Tensor。數據類型必須是float32或者float64。

filter: 一個Tensor。數據類型必須是input相同。

strides: 一個長度是4的一維整數類型數組，每一維度對應的是 input 中每一維的對應移動步數，比如，strides[1] 對應 input[1] 的移動步數。

padding: 一個字符串，取值為 SAME 或者 VALID 。

use_cudnn_on_gpu: 一個可選布爾值，默認情況下是 True 。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型是 input 相同。

tf.nn.depthwise_conv2d(input, filter, strides, padding, name=None)

解釋：這個函數也是一個卷積操作。

給定一個輸入張量，數據維度是 [batch, in_height, in_width, in_channels] ，一個卷積核的維度是 [filter_height, filter_width, in_channels, channel_multiplier] ，在通道 in_channels 上面的卷積深度是 1 （我的理解是在每個通道上多帶帶進行卷積），depthwise_conv2d 函數將不同的卷積核獨立的應用在 in_channels 的每個通道上（從通道 1 到通道 channel_multiplier ），然后把所以的結果進行匯總。最后輸出通道的總數是 in_channels * channel_multiplier 。

更加具體公式如下：

output[b, i, j, k * channel_multiplier + q] =
    sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] * 
                  filter[di, dj, k, q]

注意，必須有?strides[0] = strides[3] = 1。在大部分處理過程中，卷積核的水平移動步數和垂直移動步數是相同的，即 strides = [1, stride, stride,1]。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(10, 6, 6, 3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 5), dtype = np.float32)

y = tf.nn.depthwise_conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = "SAME")

with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(y)
    print sess.run(tf.shape(y))

輸入參數：

input: 一個Tensor。數據維度是四維 [batch, in_height, in_width, in_channels]。

filter: 一個Tensor。數據維度是四維 [filter_height, filter_width, in_channels, channel_multiplier]。

strides: 一個長度是4的一維整數類型數組，每一維度對應的是 input 中每一維的對應移動步數，比如，strides[1] 對應 input[1] 的移動步數。

padding: 一個字符串，取值為 SAME 或者 VALID 。

use_cudnn_on_gpu: 一個可選布爾值，默認情況下是 True 。

name: （可選）為這個操作取一個名字。

輸出參數：

一個四維的Tensor，數據維度為 [batch, out_height, out_width, in_channels * channel_multiplier]。

tf.nn.separable_conv2d(input, depthwise_filter, pointwise_filter, strides, padding, name=None)

解釋：這個函數的作用是利用幾個分離的卷積核去做卷積，可以參考這個解釋。

比如下圖中，常規卷積和分離卷積的區別：

這個卷積是為了避免卷積核在全通道的情況下進行卷積，這樣非常浪費時間。使用這個API，你將應用一個二維的卷積核，在每個通道上，以深度 channel_multiplier 進行卷積。其實如上圖 Separable Convolution 中，就是先利用 depthwise_filter ，將 ID 的通道數映射到 ID * DM 的通道數上面，之后從 ID * DM 的通道數映射到 OD 的通道數上面，這也就是上面說的深度 channel_multiplier 對應于 DM。

具體公式如下：

output[b, i, j, k] = sum_{di, dj, q, r]
    input[b, strides[1] * i + di, strides[2] * j + dj, q] *
    depthwise_filter[di, dj, q, r] *
    pointwise_filter[0, 0, q * channel_multiplier + r, k]

strides 只是僅僅控制 depthwise convolution 的卷積步長，因為 pointwise convolution 的卷積步長是確定的 [1, 1, 1, 1] 。注意，必須有?strides[0] = strides[3] = 1。在大部分處理過程中，卷積核的水平移動步數和垂直移動步數是相同的，即?strides = [1, stride, stride, 1]。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(10, 6, 6, 3), dtype = np.float32 )
depthwise_filter = tf.Variable( np.random.rand(2, 2, 3, 5), dtype = np.float32)
pointwise_filter = tf.Variable( np.random.rand(1, 1, 15, 20), dtype = np.float32)
# out_channels >= channel_multiplier * in_channels
y = tf.nn.separable_conv2d(input_data, depthwise_filter, pointwise_filter, strides = [1, 1, 1, 1], padding = "SAME")

with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(y)
    print sess.run(tf.shape(y))

輸入參數：

input: 一個Tensor。數據維度是四維 [batch, in_height, in_width, in_channels]。

depthwise_filter: 一個Tensor。數據維度是四維 [filter_height, filter_width, in_channels, channel_multiplier]。其中，in_channels 的卷積深度是 1。

pointwise_filter: 一個Tensor。數據維度是四維 [1, 1, channel_multiplier * in_channels, out_channels]。其中，pointwise_filter 是在 depthwise_filter 卷積之后的混合卷積。

strides: 一個長度是4的一維整數類型數組，每一維度對應的是 input 中每一維的對應移動步數，比如，strides[1] 對應 input[1] 的移動步數。

padding: 一個字符串，取值為 SAME 或者 VALID 。

name: （可選）為這個操作取一個名字。

輸出參數：

一個四維的Tensor，數據維度為 [batch, out_height, out_width, out_channels]。

異常：

數值異常: 如果 channel_multiplier * in_channels > out_channels ，那么將報錯。

池化層

池化操作是利用一個矩陣窗口在輸入張量上進行掃描，并且將每個矩陣窗口中的值通過取最大值，平均值或者XXXX來減少元素個數。每個池化操作的矩陣窗口大小是由 ksize 來指定的，并且根據步長參數 strides 來決定移動步長。比如，如果 strides 中的值都是1，那么每個矩陣窗口都將被使用。如果 strides 中的值都是2，那么每一維度上的矩陣窗口都是每隔一個被使用。以此類推。

更具體的輸出結果是：

output[i] = reduce( value[ strides * i: strides * i + ksize ] )

輸出數據維度是：

shape(output) = (shape(value) - ksize + 1) / strides

其中，取舍方向取決于參數 padding ：

padding = "SAME": 向下取舍，僅適用于全尺寸操作，即輸入數據維度和輸出數據維度相同。

padding = "VALID: 向上取舍，適用于部分窗口，即輸入數據維度和輸出數據維度不同。

tf.nn.avg_pool(value, ksize, strides, padding, name=None)

解釋：這個函數的作用是計算池化區域中元素的平均值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 10), dtype = np.float32)

y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = "SAME")
output = tf.nn.avg_pool(value = y, ksize = [1, 2, 2, 1], strides = [1, 1, 1, 1], padding = "SAME")

with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

value: 一個四維的Tensor。數據維度是 [batch, height, width, channels]。數據類型是float32，float64，qint8，quint8，qint32。

ksize: 一個長度不小于4的整型數組。每一位上面的值對應于輸入數據張量中每一維的窗口對應值。

strides: 一個長度不小于4的整型數組。該參數指定滑動窗口在輸入數據張量每一維上面的步長。

padding: 一個字符串，取值為 SAME 或者 VALID 。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型和value相同。

tf.nn.max_pool(value, ksize, strides, padding, name=None)

解釋：這個函數的作用是計算池化區域中元素的最大值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 10), dtype = np.float32)

y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = "SAME")
output = tf.nn.max_pool(value = y, ksize = [1, 2, 2, 1], strides = [1, 1, 1, 1], padding = "SAME")

with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

value: 一個四維的Tensor。數據維度是 [batch, height, width, channels]。數據類型是float32，float64，qint8，quint8，qint32。

ksize: 一個長度不小于4的整型數組。每一位上面的值對應于輸入數據張量中每一維的窗口對應值。

strides: 一個長度不小于4的整型數組。該參數指定滑動窗口在輸入數據張量每一維上面的步長。

padding: 一個字符串，取值為 SAME 或者 VALID 。

name: （可選）為這個操作取一個名字。

輸出參數：

一個Tensor，數據類型和value相同。

tf.nn.max_pool_with_argmax(input, ksize, strides, padding, Targmax = None, name=None)

解釋：這個函數的作用是計算池化區域中元素的最大值和該最大值所在的位置。

因為在計算位置 argmax 的時候，我們將 input 鋪平了進行計算，所以，如果 input = [b, y, x, c]，那么索引位置是 ( ( b * height + y ) * width + x ) * channels + c 。

查看源碼，該API只能在GPU環境下使用，所以我沒有測試下面的使用例子，如果你可以測試，請告訴我程序是否可以運行。

源碼展示：

REGISTER_KERNEL_BUILDER(Name("MaxPoolWithArgmax")
                            .Device(DEVICE_GPU)
                            .TypeConstraint("Targmax")
                            .TypeConstraint("T"),
                        MaxPoolingWithArgmaxOp);
REGISTER_KERNEL_BUILDER(Name("MaxPoolWithArgmax")
                            .Device(DEVICE_GPU)
                            .TypeConstraint("Targmax")
                            .TypeConstraint("T"),
                        MaxPoolingWithArgmaxOp);

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = tf.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 10), dtype = np.float32)

y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = "SAME")
output, argmax = tf.nn.max_pool_with_argmax(input = y, ksize = [1, 2, 2, 1], strides = [1, 1, 1, 1], padding = "SAME")

with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

input: 一個四維的Tensor。數據維度是 [batch, height, width, channels]。數據類型是float32。

ksize: 一個長度不小于4的整型數組。每一位上面的值對應于輸入數據張量中每一維的窗口對應值。

strides: 一個長度不小于4的整型數組。該參數指定滑動窗口在輸入數據張量每一維上面的步長。

padding: 一個字符串，取值為 SAME 或者 VALID 。

Targmax: 一個可選的數據類型： tf.int32或者tf.int64。默認情況下是 tf.int64 。

name: （可選）為這個操作取一個名字。

輸出參數：

一個元祖張量 (output, argmax)：

output: 一個Tensor，數據類型是float32。表示池化區域的最大值。

argmax: 一個Tensor，數據類型是Targmax。數據維度是四維的。

標準化

標準化是能防止模型過擬合的好方法。特別是在大數據的情況下。

tf.nn.l2_normalize(x, dim, epsilon=1e-12, name=None)

解釋：這個函數的作用是利用 L2 范數對指定維度 dim 進行標準化。

比如，對于一個一維的張量，指定維度 dim = 0，那么計算結果為：

output = x / sqrt( max( sum( x ** 2 ) , epsilon ) )

假設 x 是多維度的，那么標準化只會獨立的對維度 dim 進行，不會影響到別的維度。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(2, 3), dtype = tf.float32 )
output = tf.nn.l2_normalize(input_data, dim = 0)
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

x: 一個Tensor。

dim: 需要標準化的維度。

epsilon: 一個很小的值，確定標準化的下邊界。如果 norm < sqrt(epsilon)，那么我們將使用 sqrt(epsilon) 進行標準化。

name: （可選）為這個操作取一個名字。

輸出參數：

一個 Tensor ，數據維度和 x 相同。

tf.nn.local_response_normalization(input, depth_radius=None, bias=None, alpha=None, beta=None, name=None)

解釋：這個函數的作用是計算局部數據標準化。

輸入的數據 input 是一個四維的張量，但該張量被看做是一個一維的向量（ input 的最后一維作為向量），向量中的每一個元素都是一個三維的數組（對應 input 的前三維）。向量的每一個元素都是獨立的被標準化的。具體數學形式如下：

sqr_sum[a, b, c, d] =
    sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
output = input / (bias + alpha * sqr_sum ** beta)

如果你想更加了解這種標準化，可以參考這篇論文。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(1, 2, 3, 4), dtype = tf.float32 )
output = tf.nn.local_response_normalization(input_data)
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(input_data)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

input: 一個Tensor。數據維度是四維的，數據類型是 float32 。

depth_radius: （可選）一個整型，默認情況下是 5 。

bias: （可選）一個浮點型，默認情況下是 1。一個偏移項，為了避免除0，一般情況下我們取正值。

alpha: （可選）一個浮點型，默認情況下是 1。一個比例因子，一般情況下我們取正值。

beta: （可選）一個浮點型，默認情況下是 0.5。一個指數。

name: （可選）為這個操作取一個名字。

輸出參數：

一個 Tensor ，數據類型是 float32 。

tf.nn.moments(x, axes, name=None)

解釋：這個函數的作用是計算 x 的均值和方差。

沿著 axes 維度，計算 x 的均值和方差。如果 x 是一維的，并且 axes = [0] ，那么就是計算整個向量的均值和方差。

如果，我們取 axes = [0, 1, 2] (batch, height, width)，那么我們就是計算卷積的全局標準化。如果只是計算批處理的標準化，那么我們取 axes = [0] (batch) 。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(2, 3), dtype = tf.float32 )
mean, variance = tf.nn.moments(input_data, [0])
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(input_data)
    print sess.run(mean)
    print sess.run(tf.shape(mean))

輸入參數：

x: 一個Tensor。

axes: 一個整型的數組，確定計算均值和方差的維度 。

name: 為這個操作取個名字。

輸出參數：

兩個 Tensor ，分別是均值 mean 和方差 variance 。

誤差值

度量兩個張量或者一個張量和零之間的損失誤差，這個可用于在一個回歸任務或者用于正則的目的（權重衰減）。

tf.nn.l2_loss(t, name=None)

解釋：這個函數的作用是利用 L2 范數來計算張量的誤差值，但是沒有開方并且只取 L2 范數的值的一半，具體如下：

output = sum(t ** 2) / 2

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(2, 3), dtype = tf.float32 )
output = tf.nn.l2_loss(input_data)
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(input_data)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

t: 一個Tensor。數據類型必須是一下之一：float32，float64，int64，int32，uint8，int16，int8，complex64，qint8，quint8，qint32。雖然一般情況下，數據維度是二維的。但是，數據維度可以取任意維度。

name: 為這個操作取個名字。

輸出參數：

一個 Tensor ，數據類型和 t 相同，是一個標量。

分類操作

Tensorflow提供了操作，能幫助你更好的進行分類操作。

tf.nn.sigmoid_cross_entropy_with_logits(logits, targets, name=None)

解釋：這個函數的作用是計算 logits 經 sigmoid 函數激活之后的交叉熵。

對于一個不相互獨立的離散分類任務，這個函數作用是去度量概率誤差。比如，比如，在一張圖片中，同時包含多個分類目標（大象和狗），那么就可以使用這個函數。

為了描述簡潔，我們規定 x = logits，z = targets，那么 Logistic 損失值為：

x - x * z + log( 1 + exp(-x) )

為了確保計算穩定，避免溢出，真實的計算實現如下：

max(x, 0) - x * z + log(1 + exp(-abs(x)) )

logits 和 targets 必須有相同的數據類型和數據維度。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( np.random.rand(1,3), dtype = tf.float32 )
output = tf.nn.sigmoid_cross_entropy_with_logits(input_data, [[1.0,0.0,0.0]])
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(input_data)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

logits: 一個Tensor。數據類型是以下之一：float32或者float64。

targets: 一個Tensor。數據類型和數據維度都和 logits 相同。

name: 為這個操作取個名字。

輸出參數：

一個 Tensor ，數據維度和 logits 相同。

tf.nn.softmax(logits, name=None)

解釋：這個函數的作用是計算 softmax 激活函數。

對于每個批 i 和 分類 j，我們可以得到：

softmax[i, j] = exp(logits[i, j]) / sum(exp(logits[i]))

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( [[0.2, 0.1, 0.9]] , dtype = tf.float32 )
output = tf.nn.softmax(input_data)
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(input_data)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

logits: 一個Tensor。數據類型是以下之一：float32或者float64。數據維度是二維 [batch_size, num_classes]。

name: 為這個操作取個名字。

輸出參數：

一個 Tensor ，數據維度和數據類型都和 logits 相同。

tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)

解釋：這個函數的作用是計算 logits 經 softmax 函數激活之后的交叉熵。

對于每個獨立的分類任務，這個函數是去度量概率誤差。比如，在 CIFAR-10 數據集上面，每張圖片只有唯一一個分類標簽：一張圖可能是一只狗或者一輛卡車，但絕對不可能兩者都在一張圖中。（這也是和 `tf.nn.sigmoid_cross_entropy_with_logits(logits, targets, name=None)
`這個API的區別）

警告：輸入API的數據 logits 不能進行縮放，因為在這個API的執行中會進行 softmax 計算，如果 logits 進行了縮放，那么會影響計算正確率。不要調用這個API區計算 softmax 的值，因為這個API最終輸出的結果并不是經過 softmax 函數的值。

logits 和 labels 必須有相同的數據維度 [batch_size, num_classes]，和相同的數據類型 float32 或者 float64 。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import tensorflow as tf

input_data = tf.Variable( [[0.2, 0.1, 0.9]] , dtype = tf.float32 )
output = tf.nn.softmax_cross_entropy_with_logits(input_data, [[1,0,0]])
with tf.Session() as sess:
    init = tf.initialize_all_variables()
    sess.run(init)
    print sess.run(input_data)
    print sess.run(output)
    print sess.run(tf.shape(output))

輸入參數：

logits: 一個沒有縮放的對數張量。

labels: 每一行 labels[i] 必須是一個有效的概率分布值。

name: 為這個操作取個名字。

輸出參數：

一個 Tensor ，數據維度是一維的，長度是 batch_size，數據類型都和 logits 相同。

嵌入層

Tensorflow 提供了從張量中嵌入查找的庫。

tf.nn.embedding_lookup(params, ids, name=None)

解釋：這個函數的作用是查詢 params 中索引是 ids 的值。

這個操作是 tf.gather() 的一個泛化，但它可以被并行計算處理，其中 params 被認為是一個大型的張量庫，ids 中的值對應于各個分區。

如果 len(params) > 1，ids 中每個元素 id 對應于 params 中每個分區 p ，即 p = id % len(params)。那么，我們得到的每個切片是 params[p][id // len(params), ...] 。

最后得到的切片結果被重新連接成一個稠密張量，最后返回的張量維度是 shape(ids) + shape(params)[1: ]。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np 

params = tf.constant(np.random.rand(3,4))
ids = tf.constant([0,2])
output = tf.nn.embedding_lookup(params, ids)

with tf.Session() as sess:
    print "params: ", sess.run(params)
    print "-------------------------------"
    print "輸出第0行和第2行: ", sess.run(output)

輸入參數：

params: 一個擁有相同數據維度和數據類型的張量。

ids: 一個張量，數據類型是 int32 。

name: 為這個操作取個名字。

輸出參數：

一個 Tensor ，數據類型和 params 相同。

異常：

數值異常: 如果 params 是空的，那么會拋出這個異常。

評估操作

評估操作對于測量網絡的性能是有用的。 由于它們是不可微分的，所以它們通常只是被用在評估階段。

tf.nn.top_k(input, k, name=None)

解釋：這個函數的作用是返回 input 中每行最大的 k 個數，并且返回它們所在位置的索引。

value(i, j) 表示輸入數據 input(i) 的第 j 大的元素。

indices(i, j) 給出對應元素的列索引，即 input(i, indices(i, j)) = values(i, j) 。如果遇到兩個相等的元素，那么我們先取索引小的值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np 

input = tf.constant(np.random.rand(3,4))
k = 2
output = tf.nn.top_k(input, k)
with tf.Session() as sess:
    print sess.run(input)
    print "--------------------"
    print sess.run(output)

輸入參數：

input: 一個張量，數據類型必須是以下之一：float32、float64、int32、int64、uint8、int16、int8。數據維度是 batch_size 乘上 x 個類別。

k: 一個整型，必須 >= 1。在每行中，查找最大的 k 個值。

name: 為這個操作取個名字。

輸出參數：

一個元組 Tensor ，數據元素是 (values, indices)，具體如下：

values: 一個張量，數據類型和 input 相同。數據維度是 batch_size 乘上 k 個最大值。

indices: 一個張量，數據類型是 int32 。每個最大值在 input 中的索引位置。

tf.nn.in_top_k(predictions, targets, k, name=None)

解釋：這個函數的作用是返回一個布爾向量，說明目標值是否存在于預測值之中。

輸出數據是一個 batch_size 長度的布爾向量，如果目標值存在于預測值之中，那么 out[i] = true。

注意：targets 是predictions中的索引位，并不是 predictions 中具體的值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np 

input = tf.constant(np.random.rand(3,4), tf.float32)
k = 2
output = tf.nn.in_top_k(input, [3,3,3], k)
with tf.Session() as sess:
    print sess.run(input)
    print "--------------------"
    print sess.run(output)

輸入參數：

predictions: 一個張量，數據類型是 float32 。數據維度是 batch_size 乘上 x 個類別。

targets: 一個張量，數據類型是 int32 。一個長度是 batch_size 的向量，里面的元素是目標 class ID 。

k: 一個整型。在每行中，查找最大的 k 個值。

name: 為這個操作取個名字。

輸出參數：

一個張量，數據類型是 bool 。判斷是否預測正確。

Candidate Sampling

這是一些采樣的函數，由于目前不是很理解，暫且不學習......

作者：chen_h
微信號 & QQ：862251340
簡書地址：https://www.jianshu.com/p/e3a...

CoderPai 是一個專注于算法實戰的平臺，從基礎的算法到人工智能算法都有設計。如果你對算法實戰感興趣，請快快關注我們吧。加入AI實戰微信群，AI實戰QQ群，ACM算法微信群，ACM算法QQ群。長按或者掃描如下二維碼，關注 “CoderPai” 微信號（coderpai）