Keras官方中文文檔：keras後端Backend

時間 2019-11-10

標籤 keras 官方中文文檔後端 backend 简体版

原文原文鏈接

所屬分類： Keras

Keras後端

什麼是「後端」

Keras是一個模型級的庫，提供了快速構建深度學習網絡的模塊。Keras並不處理如張量乘法、卷積等底層操做。這些操做依賴於某種特定的、優化良好的張量操做庫。Keras依賴於處理張量的庫就稱爲「後端引擎」。Keras提供了三種後端引擎Theano/Tensorflow/CNTK，並將其函數統一封裝，使得用戶能夠以同一個接口調用不一樣後端引擎的函數php

Theano是一個開源的符號主義張量操做框架，由蒙特利爾大學LISA/MILA實驗室開發。
TensorFlow是一個符號主義的張量操做框架，由Google開發。
CNTK是一個由微軟開發的商業級工具包。

在將來，咱們有可能要添加更多的後端選項。python

切換後端

注意：Windows用戶請把$Home改成%USERPROFILE%git

若是你至少運行過一次Keras，你將在下面的目錄下找到Keras的配置文件：算法

$HOME/.keras/keras.jsonexpress

若是該目錄下沒有該文件，你能夠手動建立一個json

文件的默認配置以下：後端

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "tensorflow"
}

將backend字段的值改寫爲你須要使用的後端：theano或tensorflow或者CNTK，便可完成後端的切換網絡

咱們也能夠經過定義環境變量KERAS_BACKEND來覆蓋上面配置文件中定義的後端：session

KERAS_BACKEND=tensorflow python -c "from keras import backend;"
Using TensorFlow backend.

keras.json 細節

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "tensorflow"
}

你能夠更改以上~/.keras/keras.json中的配置框架

iamge_data_format：字符串，"channels_last"或"channels_first"，該選項指定了Keras將要使用的維度順序，可經過keras.backend.image_data_format()來獲取當前的維度順序。對2D數據來講，"channels_last"假定維度順序爲(rows,cols,channels)而"channels_first"假定維度順序爲(channels, rows, cols)。對3D數據而言，"channels_last"假定(conv_dim1, conv_dim2, conv_dim3, channels)，"channels_first"則是(channels, conv_dim1, conv_dim2, conv_dim3)
epsilon：浮點數，防止除0錯誤的小數字
floatx：字符串，"float16", "float32", "float64"之一，爲浮點數精度
backend：字符串，所使用的後端，爲"tensorflow"或"theano"

使用抽象的Keras後端來編寫代碼

若是你但願你編寫的Keras模塊可以同時在Theano和TensorFlow兩個後端上使用，你能夠經過Keras後端接口來編寫代碼，這裏是一個簡介：

from keras import backend as K

下面的代碼實例化了一個輸入佔位符，等價於tf.placeholder() ，T.matrix()，T.tensor3()等

input = K.placeholder(shape=(2, 4, 5))
# also works:
input = K.placeholder(shape=(None, 4, 5))
# also works:
input = K.placeholder(ndim=3)

下面的代碼實例化了一個共享變量（shared），等價於tf.variable()或 theano.shared()

val = np.random.random((3, 4, 5))
var = K.variable(value=val)

# all-zeros variable:
var = K.zeros(shape=(3, 4, 5))
# all-ones:
var = K.ones(shape=(3, 4, 5))

大多數你須要的張量操做均可以經過統一的Keras後端接口完成，而不關心具體執行這些操做的是Theano仍是TensorFlow

a = b + c * K.abs(d)
c = K.dot(a, K.transpose(b))
a = K.sum(b, axis=2)
a = K.softmax(b)
a = concatenate([b, c], axis=-1)
# etc...

Kera後端函數

backend

backend()

返回當先後端

epsilon

epsilon()

以數值形式返回一個（通常來講很小的）數，用以防止除0錯誤

set_epsilon

set_epsilon(e)

設置在數值表達式中使用的fuzz factor，用於防止除0錯誤，該值應該是一個較小的浮點數，示例：

>>> from keras import backend as K
>>> K.epsilon()
1e-08
>>> K.set_epsilon(1e-05)
>>> K.epsilon()
1e-05

floatx

floatx()

返回默認的浮點數數據類型，爲字符串，如 'float16', 'float32', 'float64'

set_floatx(floatx)

floatx()

設置默認的浮點數數據類型，爲字符串，如 'float16', 'float32', 'float64',示例：

>>> from keras import backend as K
>>> K.floatx()
'float32'
>>> K.set_floatx('float16')
>>> K.floatx()
'float16'

cast_to_floatx

cast_to_floatx(x)

將numpy array轉換爲默認的Keras floatx類型，x爲numpy array，返回值也爲numpy array但其數據類型變爲floatx。示例：

>>> from keras import backend as K
>>> K.floatx()
'float32'
>>> arr = numpy.array([1.0, 2.0], dtype='float64')
>>> arr.dtype
dtype('float64')
>>> new_arr = K.cast_to_floatx(arr)
>>> new_arr
array([ 1.,  2.], dtype=float32)
>>> new_arr.dtype
dtype('float32')

image_data_format

image_data_format()

返回默認的圖像的維度順序（‘channels_last’或‘channels_first’）

set_image_data_format

set_image_data_format(data_format)

設置圖像的維度順序（‘tf’或‘th’）,示例：

from keras import backend as K
K.image_data_format()
'channels_first'
K.set_image_data_format('channels_last')
K.image_data_format()
'channels_last'

### is_keras_tensor()
```python
is_keras_tensor(x)

判斷x是不是keras tensor對象的謂詞函數

>>> from keras import backend as K
>>> np_var = numpy.array([1, 2])
>>> K.is_keras_tensor(np_var)
False
>>> keras_var = K.variable(np_var)
>>> K.is_keras_tensor(keras_var)  # A variable is not a Tensor.
False
>>> keras_placeholder = K.placeholder(shape=(2, 4, 5))
>>> K.is_keras_tensor(keras_placeholder)  # A placeholder is a Tensor.
True

get_uid

get_uid(prefix='')

得到默認計算圖的uid，依據給定的前綴提供一個惟一的UID，參數爲表示前綴的字符串，返回值爲整數.

reset_uids

reset_uids()

重置圖的標識符

is_keras_tensor

is_keras_tensor(x)

判斷x是不是一個Keras tensor，返回一個布爾值，示例

>>> from keras import backend as K
>>> np_var = numpy.array([1, 2])
>>> K.is_keras_tensor(np_var)
False
>>> keras_var = K.variable(np_var)
>>> K.is_keras_tensor(keras_var)  # A variable is not a Tensor.
False
>>> keras_placeholder = K.placeholder(shape=(2, 4, 5))
>>> K.is_keras_tensor(keras_placeholder)  # A placeholder is a Tensor.
True

clear_session

clear_session()

結束當前的TF計算圖，並新建一個。有效的避免模型/層的混亂

manual_variable_initialization

manual_variable_initialization(value)

指出變量應該以其默認值被初始化仍是由用戶手動初始化，參數value爲布爾值，默認False表明變量由其默認值初始化

learning_phase

learning_phase()

返回訓練模式/測試模式的flag，該flag是一個用以傳入Keras模型的標記，以決定當前模型執行於訓練模式下仍是測試模式下

set_learning_phase

set_learning_phase()

設置訓練模式/測試模式0或1

is_sparse

is_sparse(tensor)

判斷一個tensor是否是一個稀疏的tensor(稀不稀疏由tensor的類型決定，而不是tensor實際上有多稀疏)，返回值是一個布爾值，示例：

>>> from keras import backend as K
>>> a = K.placeholder((2, 2), sparse=False)
>>> print(K.is_sparse(a))
False
>>> b = K.placeholder((2, 2), sparse=True)
>>> print(K.is_sparse(b))
True

to_dense

to_dense(tensor)

將一個稀疏tensor轉換一個不稀疏的tensor並返回之，示例：

>>> from keras import backend as K
>>> b = K.placeholder((2, 2), sparse=True)
>>> print(K.is_sparse(b))
True
>>> c = K.to_dense(b)
>>> print(K.is_sparse(c))
False

variable

variable(value, dtype='float32', name=None)

實例化一個張量，返回之

參數：

value：用來初始化張量的值
dtype：張量數據類型
name：張量的名字（可選）

示例：

>>> from keras import backend as K
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val, dtype='float64', name='example_var')
>>> K.dtype(kvar)
'float64'
>>> print(kvar)
example_var
>>> kvar.eval()
array([[ 1.,  2.],
   [ 3.,  4.]])

placeholder

placeholder(shape=None, ndim=None, dtype='float32', name=None)

實例化一個佔位符，返回之

參數：

shape：佔位符的shape（整數tuple，可能包含None）
ndim: 佔位符張量的階數，要初始化一個佔位符，至少指定shape和ndim之一，若是都指定則使用shape
dtype: 佔位符數據類型
name: 佔位符名稱（可選）

示例：

>>> from keras import backend as K
>>> input_ph = K.placeholder(shape=(2, 4, 5))
>>> input_ph._keras_shape
(2, 4, 5)
>>> input_ph
<tf.Tensor 'Placeholder_4:0' shape=(2, 4, 5) dtype=float32>

shape

shape(x)

返回一個張量的符號shape，符號shape的意思是返回值自己也是一個tensor，示例：

>>> from keras import backend as K
>>> tf_session = K.get_session()
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val)
>>> input = keras.backend.placeholder(shape=(2, 4, 5))
>>> K.shape(kvar)
<tf.Tensor 'Shape_8:0' shape=(2,) dtype=int32>
>>> K.shape(input)
<tf.Tensor 'Shape_9:0' shape=(3,) dtype=int32>
__To get integer shape (Instead, you can use K.int_shape(x))__

>>> K.shape(kvar).eval(session=tf_session)
array([2, 2], dtype=int32)
>>> K.shape(input).eval(session=tf_session)
array([2, 4, 5], dtype=int32)

int_shape

int_shape(x)

以整數Tuple或None的形式返回張量shape，示例：

>>> from keras import backend as K
>>> input = K.placeholder(shape=(2, 4, 5))
>>> K.int_shape(input)
(2, 4, 5)
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val)
>>> K.int_shape(kvar)
(2, 2)

ndim

ndim(x)

返回張量的階數，爲整數，示例：

>>> from keras import backend as K
>>> input = K.placeholder(shape=(2, 4, 5))
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val)
>>> K.ndim(input)
3
>>> K.ndim(kvar)
2

dtype

dtype(x)

返回張量的數據類型，爲字符串，示例：

>>> from keras import backend as K
>>> K.dtype(K.placeholder(shape=(2,4,5)))
'float32'
>>> K.dtype(K.placeholder(shape=(2,4,5), dtype='float32'))
'float32'
>>> K.dtype(K.placeholder(shape=(2,4,5), dtype='float64'))
'float64'
__Keras variable__

>>> kvar = K.variable(np.array([[1, 2], [3, 4]]))
>>> K.dtype(kvar)
'float32_ref'
>>> kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
>>> K.dtype(kvar)
'float32_ref'

eval

eval(x)

求得張量的值，返回一個Numpy array，示例：

>>> from keras import backend as K
>>> kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
>>> K.eval(kvar)
array([[ 1.,  2.],
   [ 3.,  4.]], dtype=float32)

zeros

zeros(shape, dtype='float32', name=None)

生成一個全0張量，示例：

>>> from keras import backend as K
>>> kvar = K.zeros((3,4))
>>> K.eval(kvar)
array([[ 0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.]], dtype=float32)

ones

ones(shape, dtype='float32', name=None)

生成一個全1張量，示例

>>> from keras import backend as K
>>> kvar = K.ones((3,4))
>>> K.eval(kvar)
array([[ 1.,  1.,  1.,  1.],
   [ 1.,  1.,  1.,  1.],
   [ 1.,  1.,  1.,  1.]], dtype=float32)

eye

eye(size, dtype='float32', name=None)

生成一個單位矩陣，示例：

>>> from keras import backend as K
>>> kvar = K.eye(3)
>>> K.eval(kvar)
array([[ 1.,  0.,  0.],
   [ 0.,  1.,  0.],
   [ 0.,  0.,  1.]], dtype=float32)

zeros_like

zeros_like(x, name=None)

生成與另外一個張量x的shape相同的全0張量，示例：

>>> from keras import backend as K
>>> kvar = K.variable(np.random.random((2,3)))
>>> kvar_zeros = K.zeros_like(kvar)
>>> K.eval(kvar_zeros)
array([[ 0.,  0.,  0.],
   [ 0.,  0.,  0.]], dtype=float32)

ones_like

ones_like(x, name=None)

生成與另外一個張量shape相同的全1張量，示例：

>>> from keras import backend as K
>>> kvar = K.variable(np.random.random((2,3)))
>>> kvar_ones = K.ones_like(kvar)
>>> K.eval(kvar_ones)
array([[ 1.,  1.,  1.],
   [ 1.,  1.,  1.]], dtype=float32)

random_uniform_variable

random_uniform_variable(shape, low, high, dtype=None, name=None, seed=None)

初始化一個Keras變量，其數值爲從一個均勻分佈中採樣的樣本，返回之。

參數：

shape：張量shape
low：浮點數，均勻分佈之下界
high：浮點數，均勻分佈之上界
dtype：數據類型
name：張量名
seed：隨機數種子

示例：

>>> kvar = K.random_uniform_variable((2,3), 0, 1)
>>> kvar
<tensorflow.python.ops.variables.Variable object at 0x10ab40b10>
>>> K.eval(kvar)
array([[ 0.10940075,  0.10047495,  0.476143  ],
   [ 0.66137183,  0.00869417,  0.89220798]], dtype=float32)

count_params

count_params(x)

返回張量中標量的個數，示例：

>>> kvar = K.zeros((2,3))
>>> K.count_params(kvar)
6
>>> K.eval(kvar)
array([[ 0.,  0.,  0.],
   [ 0.,  0.,  0.]], dtype=float32)

cast

cast(x, dtype)

改變張量的數據類型，dtype只能是float16, float32或float64之一，示例：

>>> from keras import backend as K
>>> input = K.placeholder((2, 3), dtype='float32')
>>> input
<tf.Tensor 'Placeholder_2:0' shape=(2, 3) dtype=float32>
__It doesn't work in-place as below.__

>>> K.cast(input, dtype='float16')
<tf.Tensor 'Cast_1:0' shape=(2, 3) dtype=float16>
>>> input
<tf.Tensor 'Placeholder_2:0' shape=(2, 3) dtype=float32>
__you need to assign it.__

>>> input = K.cast(input, dtype='float16')
>>> input
<tf.Tensor 'Cast_2:0' shape=(2, 3) dtype=float16>```

update

update(x, new_x)

用new_x更新x

update_add

update_add(x, increment)

經過將x增長increment更新x

update_sub

update_sub(x, decrement)

經過將x減小decrement更新x

moving_average_update

moving_average_update(x, value, momentum)

含義暫不明確

dot

dot(x, y)

求兩個張量的乘積。當試圖計算兩個N階張量的乘積時，與Theano行爲相同，如(2, 3).(4, 3, 5) = (2, 4, 5))，示例：

>>> x = K.placeholder(shape=(2, 3))
>>> y = K.placeholder(shape=(3, 4))
>>> xy = K.dot(x, y)
>>> xy
<tf.Tensor 'MatMul_9:0' shape=(2, 4) dtype=float32>

>>> x = K.placeholder(shape=(32, 28, 3))
>>> y = K.placeholder(shape=(3, 4))
>>> xy = K.dot(x, y)
>>> xy
<tf.Tensor 'MatMul_9:0' shape=(32, 28, 4) dtype=float32>

Theano-like的行爲示例：

>>> x = K.random_uniform_variable(shape=(2, 3), low=0, high=1)
>>> y = K.ones((4, 3, 5))
>>> xy = K.dot(x, y)
>>> K.int_shape(xy)
(2, 4, 5)

batch_dot

batch_dot(x, y, axes=None)

按批進行張量乘法，該函數用於計算x和y的點積，其中x和y都是成batch出現的數據。即它的數據shape形如(batch_size,:)。batch_dot將產生比輸入張量維度低的張量，若是張量的維度被減至1，則經過expand_dims保證其維度至少爲2
例如，假設x = [[1, 2],[3,4]] ， y = [[5, 6],[7, 8]]，則batch_dot(x, y, axes=1) = [[17, 53]]，即x.dot(y.T)的主對角元素，此過程當中咱們沒有計算過反對角元素的值

參數：

x,y：階數大於等於2的張量，在tensorflow下，只支持大於等於3階的張量
axes：目標結果的維度，爲整數或整數列表，axes[0]和axes[1]應相同

示例：
假設x=[[1,2],[3,4]]，y=[[5,6],[7,8]]，則batch_dot(x, y, axes=1)爲[[17, 53]]，剛好爲x.dot(y.T)的主對角元，整個過程沒有計算反對角元的元素。

咱們作一下shape的推導，假設x是一個shape爲(100,20)的tensor，y是一個shape爲(100,30,20)的tensor，假設axes=(1,2)，則輸出tensor的shape經過循環x.shape和y.shape肯定：

x.shape[0]：值爲100，加入到輸入shape裏
x.shape[1]：20，不加入輸出shape裏，由於該維度的值會被求和(dot_axes[0]=1)
y.shape[0]：值爲100，不加入到輸出shape裏，y的第一維老是被忽略
y.shape[1]：30，加入到輸出shape裏
y.shape[2]：20，不加到output shape裏，y的第二個維度會被求和(dot_axes[1]=2)
結果爲(100, 30)

>>> x_batch = K.ones(shape=(32, 20, 1))
>>> y_batch = K.ones(shape=(32, 30, 20))
>>> xy_batch_dot = K.batch_dot(x_batch, y_batch, axes=[1, 2])
>>> K.int_shape(xy_batch_dot)
(32, 1, 30)

transpose

transpose(x)

張量轉置，返回轉置後的tensor，示例：

>>> var = K.variable([[1, 2, 3], [4, 5, 6]])
>>> K.eval(var)
array([[ 1.,  2.,  3.],
   [ 4.,  5.,  6.]], dtype=float32)
>>> var_transposed = K.transpose(var)
>>> K.eval(var_transposed)
array([[ 1.,  4.],
   [ 2.,  5.],
   [ 3.,  6.]], dtype=float32)

>>> input = K.placeholder((2, 3))
>>> input
<tf.Tensor 'Placeholder_11:0' shape=(2, 3) dtype=float32>
>>> input_transposed = K.transpose(input)
>>> input_transposed
<tf.Tensor 'transpose_4:0' shape=(3, 2) dtype=float32>

gather

gather(reference, indices)

在給定的張量中檢索給定下標的向量

參數：

reference：張量
indices：整數張量，其元素爲要查詢的下標

返回值：一個與reference數據類型相同的張量

max

max(x, axis=None, keepdims=False)

求張量中的最大值

min

min(x, axis=None, keepdims=False)

求張量中的最小值

sum

sum(x, axis=None, keepdims=False)

在給定軸上計算張量中元素之和

prod

prod(x, axis=None, keepdims=False)

在給定軸上計算張量中元素之積

cumsum

cumsum(x, axis=0)

在給定軸上求張量的累積和

cumprod

cumprod(x, axis=0)

在給定軸上求張量的累積積

var

var(x, axis=None, keepdims=False)

在給定軸上計算張量方差

std

std(x, axis=None, keepdims=False)

在給定軸上求張量元素之標準差

mean

mean(x, axis=None, keepdims=False)

在給定軸上求張量元素之均值

any

any(x, axis=None, keepdims=False)

按位或，返回數據類型爲uint8的張量（元素爲0或1）

all

any(x, axis=None, keepdims=False)

按位與，返回類型爲uint8de tensor

argmax

argmax(x, axis=-1)

在給定軸上求張量之最大元素下標

argmin

argmin(x, axis=-1)

在給定軸上求張量之最小元素下標

square

square(x)

逐元素平方

abs

abs(x)

逐元素絕對值

sqrt

sqrt(x)

逐元素開方

exp

exp(x)

逐元素求天然指數

log

log(x)

逐元素求天然對數

logsumexp

logsumexp(x, axis=None, keepdims=False)

在給定軸上計算log(sum(exp()))，該函數在數值穩定性上超過直接計算log(sum(exp()))，能夠避免由exp和log致使的上溢和下溢

round

round(x)

逐元素四捨五入

sign

sign(x)

逐元素求元素的符號（+1或-1）

pow

pow(x, a)

逐元素求x的a次方

clip

clip(x, min_value, max_value)

逐元素clip（將超出指定範圍的數強制變爲邊界值）

equal

equal(x, y)

逐元素判相等關係，返回布爾張量

not_equal

not_equal(x, y)

逐元素判不等關係，返回布爾張量

greater

greater(x,y)

逐元素判斷x>y關係，返回布爾張量

greater_equal

greater_equal(x,y)

逐元素判斷x>=y關係，返回布爾張量

lesser

lesser(x,y)

逐元素判斷x<y關係，返回布爾張量

lesser_equal

lesser_equal(x,y)

逐元素判斷x<=y關係，返回布爾張量

maximum

maximum(x, y)

逐元素取兩個張量的最大值

minimum

minimum(x, y)

逐元素取兩個張量的最小值

sin

sin(x)

逐元素求正弦值

cos

cos(x)

逐元素求餘弦值

normalize_batch_in_training

normalize_batch_in_training(x, gamma, beta, reduction_axes, epsilon=0.0001)

對一個batch數據先計算其均值和方差，而後再進行batch_normalization

batch_normalization

batch_normalization(x, mean, var, beta, gamma, epsilon=0.0001)

對一個batch的數據進行batch_normalization，計算公式爲：
output = (x-mean)/(sqrt(var)+epsilon)*gamma+beta

concatenate

concatenate(tensors, axis=-1)

在給定軸上將一個列表中的張量串聯爲一個張量 specified axis

reshape

reshape(x, shape)

將張量的shape變換爲指定shape

permute_dimensions

permute_dimensions(x, pattern)

按照給定的模式重排一個張量的軸

參數：

pattern：表明維度下標的tuple如(0, 2, 1)

resize_images

resize_images(X, height_factor, width_factor, dim_ordering)

依據給定的縮放因子，改變一個batch圖片的shape，參數中的兩個因子都爲正整數，圖片的排列順序與維度的模式相關，如‘th’和‘tf’

resize_volumes

resize_volumes(X, depth_factor, height_factor, width_factor, dim_ordering)

依據給定的縮放因子，改變一個5D張量數據的shape，參數中的兩個因子都爲正整數，圖片的排列順序與維度的模式相關，如‘th’和‘tf’。5D數據的形式是batch, channels, depth, height, width或batch, depth, height, width, channels

repeat_elements

repeat_elements(x, rep, axis)

在給定軸上重複張量元素rep次，與np.repeat相似。例如，若xshape(s1, s2, s3)而且給定軸爲axis=1`，輸出張量的shape爲`(s1, s2 * rep, s3)

repeat

repeat(x, n)

重複2D張量，例如若xshape是(samples, dim)且n爲2，則輸出張量的shape是(samples, 2, dim)

arange

arange(start, stop=None, step=1, dtype='int32')

生成1D的整數序列張量，該函數的參數與Theano的arange函數含義相同，若是隻有一個參數被提供了，那麼它實際上就是stop參數的值

爲了與tensorflow的默認保持匹配，函數返回張量的默認數據類型是int32

tile

tile(x, n)

將x在各個維度上重複n次，x爲張量，n爲與x維度數目相同的列表

batch_flatten

batch_flatten(x)

將一個n階張量轉變爲2階張量，其第一維度保留不變

expand_dims

expand_dims(x, dim=-1)

在下標爲dim的軸上增長一維

squeeze

squeeze(x, axis)

將下標爲axis的一維從張量中移除

temporal_padding

temporal_padding(x, padding=1)

向3D張量中間的那個維度的左右兩端填充padding個0值

asymmetric_temporal_padding

asymmetric_temporal_padding(x, left_pad=1, right_pad=1)

向3D張量中間的那個維度的一端填充padding個0值

spatial_2d_padding

spatial_2d_padding(x, padding=(1, 1), dim_ordering='th')

向4D張量第二和第三維度的左右兩端填充padding[0]和padding[1]個0值

spatial_3d_padding

spatial_3d_padding(x, padding=(1, 1, 1), dim_ordering='th')

向5D張量深度、高度和寬度三個維度上填充padding[0]，padding[1]和padding[2]個0值

stack

stack(x, axis=0)

將一個列表中維度數目爲R的張量堆積起來造成維度爲R+1的新張量

one-hot

one_hot(indices, nb_classes)

輸入爲n維的整數張量，形如(batch_size, dim1, dim2, ... dim(n-1))，輸出爲(n+1)維的one-hot編碼，形如(batch_size, dim1, dim2, ... dim(n-1), nb_classes)

reverse

reverse(x, axes)

將一個張量在給定軸上反轉

get_value

get_value(x)

以Numpy array的形式返回張量的值

batch_get_value

batch_get_value(x)

以Numpy array list的形式返回多個張量的值

set_value

set_value(x, value)

從numpy array將值載入張量中

batch_set_value

batch_set_value(tuples)

將多個值載入多個張量變量中

參數：

tuples: 列表，其中的元素形如(tensor, value)。value是要載入的Numpy array數據

print_tensor

print_tensor(x, message='')

在求值時打印張量的信息，並返回原張量

function

function(inputs, outputs, updates=[])

實例化一個Keras函數

參數：

inputs:：列表，其元素爲佔位符或張量變量
outputs：輸出張量的列表
updates：列表，其元素是形如<tf.Tensor 'AssignAdd_9:0' shape=() dtype=float32_ref>的張量.

gradients

gradients(loss, variables)

返回loss函數關於variables的梯度，variables爲張量變量的列表

stop_gradient

stop_gradient(variables)

Returns variables but with zero gradient with respect to every other variables.

rnn

rnn(step_function, inputs, initial_states, go_backwards=False, mask=None, constants=None, unroll=False, input_length=None)

在張量的時間維上迭代

參數：

inputs：形如(samples, time, ...)的時域信號的張量，階數至少爲3
step_function：每一個時間步要執行的函數
其參數：
input：形如(samples, ...)的張量，不含時間維，表明某個時間步時一個batch的樣本
states：張量列表
其返回值：
output：形如(samples, ...)的張量
- new_states：張量列表，與‘states’的長度相同
initial_states：形如(samples, ...)的張量，包含了step_function狀態的初始值。
go_backwards：布爾值，若設爲True，則逆向迭代序列
mask：形如(samples, time, 1)的二值張量，須要屏蔽的數據元素上值爲1
constants：按時間步傳遞給函數的常數列表
unroll：當使用TensorFlow時，RNN老是展開的。當使用Theano時，設置該值爲True將展開遞歸網絡
input_length：使用TensorFlow時不須要此值，在使用Theano時，若是要展開遞歸網絡，必須指定輸入序列

返回值：形如(last_output, outputs, new_states)的tuple

last_output：rnn最後的輸出，形如(samples, ...)
outputs：形如(samples, time, ...)的張量，每一個在[s,t]點的輸出對應於樣本s在t時間的輸出
new_states: 列表，其元素爲形如(samples, ...)的張量，表明每一個樣本的最後一個狀態

switch

switch(condition, then_expression, else_expression)

依據給定的條件‘condition’（整數或布爾值）在兩個表達式之間切換，注意兩個表達式都應該是具備一樣shape的符號化張量表達式

參數：

condition：標量張量
then_expression：TensorFlow表達式
else_expression: TensorFlow表達式

in_train_phase

in_train_phase(x, alt)

若是處於訓練模式，則選擇x，不然選擇alt，注意alt應該與x的shape相同

in_test_phase

in_test_phase(x, alt)

若是處於測試模式，則選擇x，不然選擇alt，注意alt應該與x的shape相同

relu

relu(x, alpha=0.0, max_value=None)

修正線性單元

參數：

alpha：負半區斜率
max_value: 飽和門限

elu

elu(x, alpha=1.0)

指數線性單元

參數：

x：輸入張量
alpha: 標量

softmax

softmax(x)

返回張量的softmax值

softplus

softplus(x)

返回張量的softplus值

softsign

softsign(x)

返回張量的softsign值

categorical_crossentropy

categorical_crossentropy(output, target, from_logits=False)

計算輸出張量和目標張量的Categorical crossentropy（類別交叉熵），目標張量與輸出張量必須shape相同

sparse_categorical_crossentropy

sparse_categorical_crossentropy(output, target, from_logits=False)

計算輸出張量和目標張量的Categorical crossentropy（類別交叉熵），目標張量必須是整型張量

binary_crossentropy

binary_crossentropy(output, target, from_logits=False)

計算輸出張量和目標張量的交叉熵

sigmoid

sigmoid(x)

逐元素計算sigmoid值

hard_sigmoid

hard_sigmoid(x)

該函數是分段線性近似的sigmoid，計算速度更快

tanh

tanh(x)

逐元素計算sigmoid值

dropout

dropout(x, level, seed=None)

隨機將x中必定比例的值設置爲0，並放縮整個tensor

參數：

x：張量
level：x中設置成0的元素比例
seed：隨機數種子

l2_normalize

l2_normalize(x, axis)

在給定軸上對張量進行L2範數規範化

in_top_k

in_top_k(predictions, targets, k)

判斷目標是否在predictions的前k大值位置

參數：

predictions：預測值張量, shape爲(batch_size, classes), 數據類型float32
targets：真值張量, shape爲(batch_size,),數據類型爲int32或int64
k：整數

conv1d

conv1d(x, kernel, strides=1, border_mode='valid', image_shape=None, filter_shape=None)

1D卷積

參數：

kernel：卷積核張量
strides：步長，整型
border_mode：「same」，「valid」之一的字符串

conv2d

conv2d(x, kernel, strides=(1, 1), border_mode='valid', dim_ordering='th', image_shape=None, filter_shape=None)

2D卷積

參數：

kernel：卷積核張量
strides：步長，長爲2的tuple
border_mode：「same」，「valid」之一的字符串
dim_ordering：「tf」和「th」之一，維度排列順序

deconv2d

deconv2d(x, kernel, output_shape, strides=(1, 1), border_mode='valid', dim_ordering='th', image_shape=None, filter_shape=None)

2D反捲積（轉置卷積）

參數：

x：輸入張量
kernel：卷積核張量
output_shape: 輸出shape的1D的整數張量
strides：步長，tuple類型
border_mode：「same」或「valid」
dim_ordering：「tf」或「th」

conv3d

conv3d(x, kernel, strides=(1, 1, 1), border_mode='valid', dim_ordering='th', volume_shape=None, filter_shape=None)

3D卷積

參數：

x：輸入張量
kernel：卷積核張量
strides：步長，tuple類型
border_mode：「same」或「valid」
dim_ordering：「tf」或「th」

pool2d

pool2d(x, pool_size, strides=(1, 1), border_mode='valid', dim_ordering='th', pool_mode='max')

2D池化

參數：

pool_size：含有兩個整數的tuple，池的大小
strides：含有兩個整數的tuple，步長
border_mode：「same」，「valid」之一的字符串
dim_ordering：「tf」和「th」之一，維度排列順序
pool_mode: 「max」，「avg」之一，池化方式

pool3d

pool3d(x, pool_size, strides=(1, 1, 1), border_mode='valid', dim_ordering='th', pool_mode='max')

3D池化

參數：

pool_size：含有3個整數的tuple，池的大小
strides：含有3個整數的tuple，步長
border_mode：「same」，「valid」之一的字符串
dim_ordering：「tf」和「th」之一，維度排列順序
pool_mode: 「max」，「avg」之一，池化方式

bias_add

bias_add(x, bias, data_format=None)

爲張量增長一個偏置項

random_normal

random_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None)

返回具備正態分佈值的張量，mean和stddev爲均值和標準差

random_uniform

random_uniform(shape, minval=0.0, maxval=1.0, dtype=None, seed=None)

返回具備均勻分佈值的張量，minval和maxval是均勻分佈的下上界

random_binomial

random_binomial(shape, p=0.0, dtype=None, seed=None)

返回具備二項分佈值的張量，p是二項分佈參數

truncated_normall

truncated_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None)

返回具備截尾正態分佈值的張量，在距離均值兩個標準差以外的數據將會被截斷並從新生成

ctc_label_dense_to_sparse

ctc_label_dense_to_sparse(labels, label_lengths)

將ctc標籤從稠密形式轉換爲稀疏形式

ctc_batch_cost

ctc_batch_cost(y_true, y_pred, input_length, label_length)

在batch上運行CTC損失算法

參數：

y_true：形如(samples，max_tring_length)的張量，包含標籤的真值
y_pred：形如(samples，time_steps，num_categories)的張量，包含預測值或輸出的softmax值
input_length：形如(samples，1)的張量，包含y_pred中每一個batch的序列長
label_length：形如(samples，1)的張量，包含y_true中每一個batch的序列長

返回值：形如(samoles，1)的tensor，包含了每一個元素的CTC損失

ctc_decode

ctc_decode(y_pred, input_length, greedy=True, beam_width=None, dict_seq_lens=None, dict_values=None)

使用貪婪算法或帶約束的字典搜索算法解碼softmax的輸出

參數：

y_pred：形如(samples，time_steps，num_categories)的張量，包含預測值或輸出的softmax值
input_length：形如(samples，1)的張量，包含y_pred中每一個batch的序列長
greedy：設置爲True使用貪婪算法，速度快
dict_seq_lens：dic_values列表中各元素的長度
dict_values：列表的列表，表明字典

返回值：形如(samples，time_steps，num_catgories)的張量，包含了路徑可能性（以softmax機率的形式）。注意仍然須要一個用來取出argmax和處理空白標籤的函數

map_fn

map_fn(fn, elems, name=None)

元素elems在函數fn上的映射，並返回結果

參數：

fn：函數
elems：張量
name：節點的名字

返回值：返回一個張量，該張量的第一維度等於elems，第二維度取決於fn

foldl

foldl(fn, elems, initializer=None, name=None)

減小elems，用fn從左到右鏈接它們

參數：

fn：函數，例如：lambda acc, x: acc + x
elems：張量
initializer：初始化的值(elems[0])
name：節點名

返回值：與initializer的類型和形狀一致

foldr

foldr(fn, elems, initializer=None, name=None)

減小elems，用fn從右到左鏈接它們

參數：

fn：函數，例如：lambda acc, x: acc + x
elems：張量
initializer：初始化的值（elems[-1]）
name：節點名

返回值：與initializer的類型和形狀一致

艾伯特(http://www.aibbt.com/)國內第一家人工智能門戶

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。