Tensorflow Python API 翻譯（nn）

時間 2019-12-08

標籤 tensorflow python api 翻譯欄目 Python 简体版

原文原文鏈接

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

計劃現將 tensorflow 中的 Python API 作一個學習，這樣方便之後的學習。
原文連接

該章介紹有關神經網絡構建的API

激活函數表示

在神經網絡中，咱們有不少的非線性函數來做爲激活函數，好比連續的平滑非線性函數（sigmoid，tanh和softplus），連續但不平滑的非線性函數（relu，relu6和relu_x）和隨機正則化函數（dropout）。git

全部的激活函數都是單獨應用在每一個元素上面的，而且輸出張量的維度和輸入張量的維度同樣。github

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

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

使用例子：數組

#!/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)dom

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

使用例子：

#!/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<int64>("Targmax")
                            .TypeConstraint<float>("T"),
                        MaxPoolingWithArgmaxOp<Eigen::GpuDevice, float>);
REGISTER_KERNEL_BUILDER(Name("MaxPoolWithArgmax")
                            .Device(DEVICE_GPU)
                            .TypeConstraint<int64>("Targmax")
                            .TypeConstraint<Eigen::half>("T"),
                        MaxPoolingWithArgmaxOp<Eigen::GpuDevice, Eigen::half>);

使用例子：

#!/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)

輸入參數：