深度學習（六）基Tensorflow、Theano的keras常用函式學習

摘要： 原文作者：aircraft 原文連結：https://www.cnblogs.com/DOMLX/p/9769301.html Keras是什麼？ Keras:基於Theano和TensorFlow的深度學習庫 Keras是一個高層神經網路API，K...

原文作者：aircraft

原文連結：https://www.cnblogs.com/DOMLX/p/9769301.html

Keras是什麼？

Keras:基於Theano和TensorFlow的深度學習庫

Keras是一個高層神經網路API，Keras由純Python編寫而成並基ofollow,noindex">Tensorflow 、Theano以及CNTK後端。Keras 為支援快速實驗而生，能夠把你的idea迅速轉換為結果，如果你有如下需求，請選擇Keras：

• 簡易和快速的原型設計（keras具有高度模組化，極簡，和可擴充特性）

• 支援CNN和RNN，或二者的結合

• 無縫CPU和GPU切換

如果還沒有配置keras可以這個部落格配置：

2018最新win10 安裝tensorflow1.4（GPU/CPU）+cuda8.0+cudnn8.0-v6 + keras 安裝CUDA失敗 匯入tensorflow失敗報錯問題解決

kearsDense ()函式--全連線層

keras.layers.core.Dense ( units, activation=None, 
　　　　　　　　　　　　　　　use_bias=True, 
　　　　　　　　　　　　　　　kernel_initializer='glorot_uniform', 
　　　　　　　　　　　　　　　bias_initializer='zeros', 
　　　　　　　　　　　　　　　kernel_regularizer=None, 
　　　　　　　　　　　　　　　bias_regularizer=None, 
　　　　　　　　　　　　　　　activity_regularizer=None, 
　　　　　　　　　　　　　　　kernel_constraint=None, 
　　　　　　　　　　　　　　　bias_constraint=None  )

引數 ：

units： 大於0的整數，代表該層的輸出維度。

activation： 啟用函式，為預定義的啟用函式名（參考啟用函式），或逐元素（element-wise）的Theano函式。如果不指定該引數，將不會使用任何啟用函式（即使用線性啟用函式：a(x)=x）

use_bias: 布林值，是否使用偏置項

kernel_initializer： 權值初始化方法，為預定義初始化方法名的字串，或用於初始化權重的初始化器。參考initializers

bias_initializer： 權值初始化方法，為預定義初始化方法名的字串，或用於初始化權重的初始化器。參考initializers

kernel_regularizer： 施加在權重上的正則項，為Regularizer物件

bias_regularizer： 施加在偏置向量上的正則項，為Regularizer物件

activity_regularizer： 施加在輸出上的正則項，為Regularizer物件

kernel_constraints： 施加在權重上的約束項，為Constraints物件

bias_constraints： 施加在偏置上的約束項，為Constraints物件

input_dim: 可以指定輸入資料的維度

kears Conv2D（）函式--卷積層

若不懂卷積概念可看： 深度學習（二）神經網路中的卷積和反捲積原理

keras.layers.Conv2D(filters, kernel_size, 
　　　　　　　　　　strides=(1, 1), 
　　　　　　　　　　padding='valid',
　　　　　　　　　　data_format=None, 
　　　　　　　　　　dilation_rate=(1, 1), 
　　　　　　　　　　activation=None, use_bias=True, 
　　　　　　　　　　kernel_initializer='glorot_uniform', 
　　　　　　　　　　bias_initializer='zeros', 
　　　　　　　　　　kernel_regularizer=None, 
　　　　　　　　　　bias_regularizer=None, 
　　　　　　　　　　activity_regularizer=None, 
　　　　　　　　　　kernel_constraint=None, 
　　　　　　　　　　bias_constraint=None)

2D 卷積層 (例如對影象的空間卷積)。

該層建立了一個卷積核， 該卷積核對層輸入進行卷積， 以生成輸出張量。 如果use_bias 為 True， 則會建立一個偏置向量並將其新增到輸出中。 最後，如果activation 不是None ，它也會應用於輸出。

當使用該層作為模型第一層時，需要提供input_shape 引數 （整數元組，不包含樣本表示的軸），例如，input_shape=(128, 128, 3) 表示 128x128 RGB 影象， 在data_format="channels_last" 時。

引數

• filters : 整數，輸出空間的維度 （即卷積中濾波器的輸出數量）。
• kernel_size : 一個整數，或者 2 個整數表示的元組或列表， 指明 2D 卷積視窗的寬度和高度。 可以是一個整數，為所有空間維度指定相同的值。
• strides : 一個整數，或者 2 個整數表示的元組或列表， 指明卷積沿寬度和高度方向的步長。 可以是一個整數，為所有空間維度指定相同的值。 指定任何 stride 值 != 1 與指定dilation_rate 值 != 1 兩者不相容。
• padding :"valid" 或"same" (大小寫敏感)。
• data_format : 字串，channels_last (預設) 或channels_first 之一，表示輸入中維度的順序。channels_last 對應輸入尺寸為(batch, height, width, channels) ，channels_first 對應輸入尺寸為(batch, channels, height, width) 。 它預設為從 Keras 配置檔案~/.keras/keras.json 中 找到的image_data_format 值。 如果你從未設定它，將使用 "channels_last"。
• dilation_rate : 一個整數或 2 個整數的元組或列表， 指定膨脹卷積的膨脹率。 可以是一個整數，為所有空間維度指定相同的值。 當前，指定任何dilation_rate 值 != 1 與 指定 stride 值 != 1 兩者不相容。
• activation : 要使用的啟用函式 (詳見activations )。 如果你不指定，則不使用啟用函式 (即線性啟用：a(x) = x )。
• use_bias : 布林值，該層是否使用偏置向量。
• kernel_initializer :kernel 權值矩陣的初始化器 (詳見initializers )。
• bias_initializer : 偏置向量的初始化器 (詳見initializers )。
• kernel_regularizer : 運用到kernel 權值矩陣的正則化函式 (詳見regularizer )。
• bias_regularizer : 運用到偏置向量的正則化函式 (詳見regularizer )。
• activity_regularizer : 運用到層輸出（它的啟用值）的正則化函式 (詳見regularizer )。
• kernel_constraint : 運用到kernel 權值矩陣的約束函式 (詳見constraints )。
• bias_constraint : 運用到偏置向量的約束函式 (詳見constraints )。

輸入尺寸

• 如果 data_format='channels_first'， 輸入 4D 張量，尺寸為(samples, channels, rows, cols) 。
• 如果 data_format='channels_last'， 輸入 4D 張量，尺寸為(samples, rows, cols, channels) 。

輸出尺寸

• 如果 data_format='channels_first'， 輸出 4D 張量，尺寸為(samples, filters, new_rows, new_cols) 。
• 如果 data_format='channels_last'， 輸出 4D 張量，尺寸為(samples, new_rows, new_cols, filters) 。

別看上面的引數一堆嚇死人，其實我們在實際運用的時候用的就只有幾個而已：

inputs = Input(shape=(n_ch,patch_height,patch_width))
conv1 = Conv2D(32, (3, 3), activation='relu', padding='same',data_format='channels_first')(inputs)　　#這個小括號填inputs是代表這層模型連線在inputs之後

當然還可以用kears內建的序貫模型add新增構成模型圖：

model = Sequential()
# Dense(64) is a fully-connected layer with 64 hidden units.
# in the first layer, you must specify the expected input data shape:
# here, 20-dimensional vectors.
model.add(Dense(64, activation='relu', input_dim=20))

kears MaxPooling2D ()函式--池化層

若不懂池化概念可看： 深度學習（一）神經網路中的池化與反池化原理

keras.layers.pooling.MaxPooling2D( pool_size=(2, 2), strides=None, padding='valid', data_format=None )

引數：

pool_size： 整數或長為2的整數tuple，代表在兩個方向（豎直，水平）上的下采樣因子，如取（2，2）將使圖片在兩個維度上均變為原長的一半。為整數意為各個維度值相同且為該數字。

strides： 整數或長為2的整數tuple，或者None，步長值。

padding： ‘valid’或者‘same’

data_format： 字串，“channels_first”或“channels_last”之一，代表影象的通道維的位置。該引數是Keras 1.x中的image_dim_ordering，“channels_last”對應原本的“tf”，“channels_first”對應原本的“th”。以128x128的RGB影象為例，“channels_first”應將資料組織為（3,128,128），而“channels_last”應將資料組織為（128,128,3）。該引數的預設值是~/.keras/keras.json中設定的值，若從未設定過，則為“channels_last”。

還是一樣的好多東西預設就行了，下面就是一個2*2的池化層：

pool1 = MaxPooling2D((2, 2))(conv1)

kears model.compile ()函式--配置模型

model.compile(optimizer, loss, metrics=None, sample_weight_mode=None)

編譯用來配置模型的學習過程，其引數有

optimizer： 字串（預定義優化器名）或優化器物件，參考優化器 

loss： 字串（預定義損失函式名）或目標函式，參考損失函式

metrics： 列表，包含評估模型在訓練和測試時的網路效能的指標，典型用法是metrics=['accuracy']

sample_weight_mode： 如果你需要按時間步為樣本賦權（2D權矩陣），將該值設為“temporal”。預設為“None”，代表按樣本賦權（1D權）。在下面fit函式的解釋中有相關的參考內容。

kwargs： 使用TensorFlow作為後端請忽略該引數，若使用Theano作為後端，kwargs的值將會傳遞給 K.function

示例程式碼：

model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])

kears model .fit ()函式--模型執行函式

fit(self, x, y, batch_size=32, epochs=10, verbose=1, callbacks=None, validation_split=0.0,
　　validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0 )

x： 輸入資料。如果模型只有一個輸入，那麼x的型別是numpy array，如果模型有多個輸入，那麼x的型別應當為list，list的元素是對應於各個輸入的numpy array

y： 標籤，numpy array

batch_size： 整數，指定進行梯度下降時每個batch包含的樣本數。訓練時一個batch的樣本會被計算一次梯度下降，使目標函式優化一步。

epochs： 整數，訓練的輪數，每個epoch會把訓練集輪一遍。

verbose： 日誌顯示，0為不在標準輸出流輸出日誌資訊，1為輸出進度條記錄，2為每個epoch輸出一行記錄

callbacks： list，其中的元素是keras.callbacks.Callback的物件。這個list中的回撥函式將會在訓練過程中的適當時機被呼叫，參考回撥函式

validation_split： 0~1之間的浮點數，用來指定訓練集的一定比例資料作為驗證集。驗證集將不參與訓練，並在每個epoch結束後測試的模型的指標，如損失函式、精確度等。注意，validation_split的劃分在shuffle之前，因此如果你的資料本身是有序的，需要先手工打亂再指定validation_split，否則可能會出現驗證集樣本不均勻。

validation_data： 形式為（X，y）的tuple，是指定的驗證集。此引數將覆蓋validation_spilt。

shuffle： 布林值或字串，一般為布林值，表示是否在訓練過程中隨機打亂輸入樣本的順序。若為字串“batch”，則是用來處理HDF5資料的特殊情況，它將在batch內部將資料打亂。

class_weight： 字典，將不同的類別對映為不同的權值，該引數用來在訓練過程中調整損失函式（只能用於訓練）

sample_weight： 權值的numpy array，用於在訓練時調整損失函式（僅用於訓練）。可以傳遞一個1D的與樣本等長的向量用於對樣本進行1對1的加權，或者在面對時序資料時，傳遞一個的形式為（samples，sequence_length）的矩陣來為每個時間步上的樣本賦不同的權。這種情況下請確定在編譯模型時添加了sample_weight_mode='temporal'。

initial_epoch: 從該引數指定的epoch開始訓練，在繼續之前的訓練時有用。

引數雖多，但是很多都可以省略看程式碼示例：

model.fit(patches_imgs_train, patches_masks_train, epochs=N_epochs, batch_size=batch_size, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpointer])

kears  predict()函式--測試資料

predictions = model.predict(patches_imgs_test, batch_size=32, verbose=2)
print("predicted images size :")
print(predictions.shape)

kears  load_weights()函式--直接匯入訓練好的模型

# 載入訓練好的模型
model.load_weights('./weights.h5')

kears  Dropout()函式--拋棄一些引數防止過擬合

Dropout（x）

X可以取0--1之間，代表百分比拋棄資料

Dropout（0.5）隨機拋棄百分之五十的資料

kears UpSampling2D()函式--上取樣函式

UpSampling2D(size=(2, 2))

size(x,y)

x代表行放大倍數  這裡取2的話代表原來的一行變成了兩行 （就是一行那麼粗，變成了兩行那麼粗）

y 代表列放大倍數  這裡取2的話代表原來的一列 變成了兩行 （就是一列 那麼粗，變成了兩列 那麼粗）

size(2,2)其實就等於將原圖放大四倍（水平兩倍，垂直兩倍） 32*32 變成 62*64的影象

kears Model()函式--代表模型圖

inputs = Input((n_ch, patch_height, patch_width))
conv1 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(inputs)
conv1 = Dropout(0.2)(conv1)
conv1 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv1)
up1 = UpSampling2D(size=(2, 2))(conv1)
#
conv2 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(up1)
conv2 = Dropout(0.2)(conv2)
conv2 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(conv2)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv2)
#
conv3 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(pool1)
conv3 = Dropout(0.2)(conv3)
conv3 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv3)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv3)
#
conv4 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(pool2)
conv4 = Dropout(0.2)(conv4)
conv4 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(conv4)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv4)
#
conv5 = Convolution2D(128, 3, 3, activation='relu', border_mode='same')(pool3)
conv5 = Dropout(0.2)(conv5)
conv5 = Convolution2D(128, 3, 3, activation='relu', border_mode='same')(conv5)
#
up2 = merge([UpSampling2D(size=(2, 2))(conv5), conv4], mode='concat', concat_axis=1)
conv6 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(up2)
conv6 = Dropout(0.2)(conv6)
conv6 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(conv6)
#
up3 = merge([UpSampling2D(size=(2, 2))(conv6), conv3], mode='concat', concat_axis=1)
conv7 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(up3)
conv7 = Dropout(0.2)(conv7)
conv7 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv7)
#
up4 = merge([UpSampling2D(size=(2, 2))(conv7), conv2], mode='concat', concat_axis=1)
conv8 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(up4)
conv8 = Dropout(0.2)(conv8)
conv8 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(conv8)
#
pool4 = MaxPooling2D(pool_size=(2, 2))(conv8)
conv9 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(pool4)
conv9 = Dropout(0.2)(conv9)
conv9 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv9)
#
conv10 = Convolution2D(2, 1, 1, activation='relu', border_mode='same')(conv9)
conv10 = core.Reshape((2,patch_height*patch_width))(conv10)
conv10 = core.Permute((2,1))(conv10)
############
conv10 = core.Activation('softmax')(conv10)

model = Model(input=inputs, output=conv10)

將模型的輸入和輸出給model函式就會自己組建模型執行圖結構

kears Embedding()函式--嵌入層

keras.layers.embeddings.Embedding( input_dim, output_dim, embeddings_initializer='uniform', 
　　　　　　　　　　　　　　　　　　　　embeddings_regularizer=None, activity_regularizer=None, embeddings_constraint=None, mask_zero=False, input_length=None)

作用：嵌入層將正整數（下標）轉換為具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]。Embedding層只能作為模型的第一層。

input_dim： 大或等於0的整數，字典長度，即輸入資料最大下標+1，就是矩陣中的最大值

output_dim： 大於0的整數，代表全連線嵌入的維度

embeddings_initializer: 嵌入矩陣的初始化方法，為預定義初始化方法名的字串，或用於初始化權重的初始化器。參考initializers

embeddings_regularizer: 嵌入矩陣的正則項，為Regularizer物件

embeddings_constraint: 嵌入矩陣的約束項，為Constraints物件

mask_zero： 布林值，確定是否將輸入中的‘0’看作是應該被忽略的‘填充’（padding）值，該引數在使用遞迴層處理變長輸入時有用。設定為True的話，模型中後續的層必須都支援masking，否則會丟擲異常。如果該值為True，則下標0在字典中不可用，input_dim應設定為|vocabulary| + 2。

input_length： 當輸入序列的長度固定時，該值為其長度。如果要在該層後接Flatten層，然後接Dense層，則必須指定該引數，否則Dense層的輸出維度無法自動推斷。

關於embeding作用的詳細介紹：http://spaces.ac.cn/archives/4122/

kears normalization()函式--標準化

keras.layers.normalization.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, 
scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros',
 moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None,
 beta_constraint=None, gamma_constraint=None)

該層在每個batch上將前一層的啟用值重新規範化，即使得其輸出資料的均值接近0，其標準差接近1

引數

• axis: 整數，指定要規範化的軸，通常為特徵軸。例如在進行data_format="channels_first 的2D卷積後，一般會設axis=1。
• momentum: 動態均值的動量
• epsilon：大於0的小浮點數，用於防止除0錯誤
• center: 若設為True，將會將beta作為偏置加上去，否則忽略引數beta
• scale: 若設為True，則會乘以gamma，否則不使用gamma。當下一層是線性的時，可以設False，因為scaling的操作將被下一層執行。
• beta_initializer：beta權重的初始方法
• gamma_initializer: gamma的初始化方法
• moving_mean_initializer: 動態均值的初始化方法
• moving_variance_initializer: 動態方差的初始化方法
• beta_regularizer: 可選的beta正則
• gamma_regularizer: 可選的gamma正則
• beta_constraint: 可選的beta約束
• gamma_constraint: 可選的gamma約束

輸入shape

任意，當使用本層為模型首層時，指定input_shape 引數時有意義。

輸出shape

與輸入shape相同

kears plot()函式--畫出模型圖

plot(model, to_file='./'+name_experiment+'/'+name_experiment + '_model.png')

kears中可以將自己建立的模型圖畫出來，傳進去一個模型，指定畫出檔案的路徑和名字即可

kears ModelCheckpoint()函式--儲存模型引數

checkpointer = ModelCheckpoint(filepath='./'+name_experiment+'/'+name_experiment +'_best_weights.h5', verbose=1, monitor='val_loss', mode='auto', save_best_only=True)

model.fit(patches_imgs_train, patches_masks_train, epochs=N_epochs, batch_size=batch_size, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpointer])

ModelCheckpoint函式可以指定一定訓練次數後儲存中間訓練的最佳引數

ModelCheckpoint函式作為model.fit（）函式中回撥函式使用

kears merge()函式--融合層

Merge層提供了一系列用於融合兩個層或兩個張量的層物件和方法。以大寫首字母開頭的是Layer類，以小寫字母開頭的是張量的函式。小寫字母開頭的張量函式在內部實際上是呼叫了大寫字母開頭的層。

Add

keras.layers.Add()

新增輸入列表的圖層。

該層接收一個相同shape列表張量，並返回它們的和，shape不變。

Example

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
added = keras.layers.Add()([x1, x2])# equivalent to added = keras.layers.add([x1, x2])

out = keras.layers.Dense(4)(added)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

SubStract

keras.layers.Subtract()

兩個輸入的層相減。

它將大小至少為2，相同Shape的列表張量作為輸入，並返回一個張量（輸入[0] - 輸入[1]），也是相同的Shape。

Example

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
# Equivalent to subtracted = keras.layers.subtract([x1, x2])
subtracted = keras.layers.Subtract()([x1, x2])

out = keras.layers.Dense(4)(subtracted)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

Multiply

keras.layers.Multiply()

該層接收一個列表的同shape張量，並返回它們的逐元素積的張量，shape不變。

Average

keras.layers.Average()

該層接收一個列表的同shape張量，並返回它們的逐元素均值，shape不變。

Maximum

keras.layers.Maximum()

該層接收一個列表的同shape張量，並返回它們的逐元素最大值，shape不變。

Concatenate

keras.layers.Concatenate(axis=-1)

該層接收一個列表的同shape張量，並返回它們的按照給定軸相接構成的向量。

引數

• axis: 想接的軸
• **kwargs: 普通的Layer關鍵字引數

Dot

keras.layers.Dot(axes, normalize=False)

計算兩個tensor中樣本的張量乘積。例如，如果兩個張量a 和b 的shape都為（batch_size, n），則輸出為形如（batch_size,1）的張量，結果張量每個batch的資料都是a[i,:]和b[i,:]的矩陣（向量）點積。

引數

• axes: 整數或整數的tuple，執行乘法的軸。
• normalize: 布林值，是否沿執行成績的軸做L2規範化，如果設為True，那麼乘積的輸出是兩個樣本的餘弦相似性。
• **kwargs: 普通的Layer關鍵字引數

add

keras.layers.add(inputs)

Add層的函式式包裝

引數：

• inputs: 長度至少為2的張量列表A
• **kwargs: 普通的Layer關鍵字引數

返回值

輸入列表張量之和

Example

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
added = keras.layers.add([x1, x2])

out = keras.layers.Dense(4)(added)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

subtract

keras.layers.subtract(inputs)

Subtract層的函式式包裝

引數：

• inputs: 長度至少為2的張量列表A
• **kwargs: 普通的Layer關鍵字引數

返回值

輸入張量列表的差別

Example

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
subtracted = keras.layers.subtract([x1, x2])

out = keras.layers.Dense(4)(subtracted)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

multiply

keras.layers.multiply(inputs)

Multiply的函式式包裝

引數：

• inputs: 長度至少為2的張量列表
• **kwargs: 普通的Layer關鍵字引數

返回值

輸入列表張量之逐元素積

average

keras.layers.average(inputs)

Average的函式包裝

引數：

• inputs: 長度至少為2的張量列表
• **kwargs: 普通的Layer關鍵字引數

返回值

輸入列表張量之逐元素均值

maximum

keras.layers.maximum(inputs)

Maximum的函式包裝

引數：

• inputs: 長度至少為2的張量列表
• **kwargs: 普通的Layer關鍵字引數

返回值

輸入列表張量之逐元素均值

concatenate

keras.layers.concatenate(inputs, axis=-1)

Concatenate的函式包裝

引數

• inputs: 長度至少為2的張量列
• axis: 相接的軸
• **kwargs: 普通的Layer關鍵字引數

dot

keras.layers.dot(inputs, axes, normalize=False)

Dot的函式包裝

引數

• inputs: 長度至少為2的張量列
• axes: 整數或整數的tuple，執行乘法的軸。
• normalize: 布林值，是否沿執行成績的軸做L2規範化，如果設為True，那麼乘積的輸出是兩個樣本的餘弦相似性。
• **kwargs: 普通的Layer關鍵字引數

kears core()模組函式--常用層

Activation層

keras.layers.core.Activation(activation)

啟用層對一個層的輸出施加啟用函式

引數

• activation：將要使用的啟用函式，為預定義啟用函式名或一個Tensorflow/Theano的函式。參考啟用函式

輸入shape

任意，當使用啟用層作為第一層時，要指定input_shape

輸出shape

與輸入shape相同

Dropout層

keras.layers.core.Dropout(rate, noise_shape=None, seed=None)

為輸入資料施加Dropout。Dropout將在訓練過程中每次更新引數時按一定概率（rate）隨機斷開輸入神經元，Dropout層用於防止過擬合。

引數

• rate：0~1的浮點數，控制需要斷開的神經元的比例

• noise_shape：整數張量，為將要應用在輸入上的二值Dropout mask的shape，例如你的輸入為(batch_size, timesteps, features)，並且你希望在各個時間步上的Dropout mask都相同，則可傳入noise_shape=(batch_size, 1, features)。

• seed：整數，使用的隨機數種子

參考文獻

• Dropout: A Simple Way to Prevent Neural Networks from Overfitting

Flatten層

keras.layers.core.Flatten()

Flatten層用來將輸入“壓平”，即把多維的輸入一維化，常用在從卷積層到全連線層的過渡。Flatten不影響batch的大小。

例子

model = Sequential()
model.add(Convolution2D(64, 3, 3,
border_mode='same',
input_shape=(3, 32, 32)))
# now: model.output_shape == (None, 64, 32, 32)

model.add(Flatten())
# now: model.output_shape == (None, 65536)

Reshape層

keras.layers.core.Reshape(target_shape)

Reshape層用來將輸入shape轉換為特定的shape

引數

• target_shape：目標shape，為整數的tuple，不包含樣本數目的維度（batch大小）

輸入shape

任意，但輸入的shape必須固定。當使用該層為模型首層時，需要指定input_shape 引數

輸出shape

(batch_size,)+target_shape

例子

# as first layer in a Sequential model
model = Sequential()
model.add(Reshape((3, 4), input_shape=(12,)))
# now: model.output_shape == (None, 3, 4)
# note: `None` is the batch dimension

# as intermediate layer in a Sequential model
model.add(Reshape((6, 2)))
# now: model.output_shape == (None, 6, 2)

# also supports shape inference using `-1` as dimension
model.add(Reshape((-1, 2, 2)))
# now: model.output_shape == (None, 3, 2, 2)

Permute層

keras.layers.core.Permute(dims)

Permute層將輸入的維度按照給定模式進行重排，例如，當需要將RNN和CNN網路連線時，可能會用到該層。

引數

• dims：整數tuple，指定重排的模式，不包含樣本數的維度。重拍模式的下標從1開始。例如（2，1）代表將輸入的第二個維度重拍到輸出的第一個維度，而將輸入的第一個維度重排到第二個維度

例子

model = Sequential()
model.add(Permute((2, 1), input_shape=(10, 64)))
# now: model.output_shape == (None, 64, 10)
# note: `None` is the batch dimension

輸入shape

任意，當使用啟用層作為第一層時，要指定input_shape

輸出shape

與輸入相同，但是其維度按照指定的模式重新排列

RepeatVector層

keras.layers.core.RepeatVector(n)

RepeatVector層將輸入重複n次

引數

• n：整數，重複的次數

輸入shape

形如（nb_samples, features）的2D張量

輸出shape

形如（nb_samples, n, features）的3D張量

例子

model = Sequential()
model.add(Dense(32, input_dim=32))
# now: model.output_shape == (None, 32)
# note: `None` is the batch dimension

model.add(RepeatVector(3))
# now: model.output_shape == (None, 3, 32)

Lambda層

keras.layers.core.Lambda(function, output_shape=None, mask=None, arguments=None)

本函式用以對上一層的輸出施以任何Theano/TensorFlow表示式

引數

• function：要實現的函式，該函式僅接受一個變數，即上一層的輸出

• output_shape：函式應該返回的值的shape，可以是一個tuple，也可以是一個根據輸入shape計算輸出shape的函式

• mask: 掩膜

• arguments：可選，字典，用來記錄向函式中傳遞的其他關鍵字引數

例子

# add a x -> x^2 layer
model.add(Lambda(lambda x: x ** 2))

# add a layer that returns the concatenation
# of the positive part of the input and
# the opposite of the negative part

def antirectifier(x):
x -= K.mean(x, axis=1, keepdims=True)
x = K.l2_normalize(x, axis=1)
pos = K.relu(x)
neg = K.relu(-x)
return K.concatenate([pos, neg], axis=1)

def antirectifier_output_shape(input_shape):
shape = list(input_shape)
assert len(shape) == 2# only valid for 2D tensors
shape[-1] *= 2
return tuple(shape)

model.add(Lambda(antirectifier,
output_shape=antirectifier_output_shape))

輸入shape

任意，當使用該層作為第一層時，要指定input_shape

輸出shape

由output_shape 引數指定的輸出shape，當使用tensorflow時可自動推斷

ActivityRegularizer層

keras.layers.core.ActivityRegularization(l1=0.0, l2=0.0)

經過本層的資料不會有任何變化，但會基於其啟用值更新損失函式值

引數

• l1：1範數正則因子（正浮點數）

• l2：2範數正則因子（正浮點數）

輸入shape

任意，當使用該層作為第一層時，要指定input_shape

輸出shape

與輸入shape相同

Masking層

keras.layers.core.Masking(mask_value=0.0)

使用給定的值對輸入的序列訊號進行“遮蔽”，用以定位需要跳過的時間步

對於輸入張量的時間步，即輸入張量的第1維度（維度從0開始算，見例子），如果輸入張量在該時間步上都等於mask_value ，則該時間步將在模型接下來的所有層（只要支援masking）被跳過（遮蔽）。

如果模型接下來的一些層不支援masking，卻接受到masking過的資料，則丟擲異常。

例子

考慮輸入資料x 是一個形如(samples,timesteps,features)的張量，現將其送入LSTM層。因為你缺少時間步為3和5的訊號，所以你希望將其掩蓋。這時候應該：

• 賦值x[:,3,:] = 0. ，x[:,5,:] = 0.

• 在LSTM層之前插入mask_value=0. 的Masking 層

model = Sequential()
model.add(Masking(mask_value=0., input_shape=(timesteps, features)))
model.add(LSTM(32))

 參考網址連結：https://keras-cn.readthedocs.io/en/latest/