深度學習（六）keras常用函數學習 2018最新win10 安裝tensorflow1.4（GPU/CPU）+cuda8.0+cudnn8.0-v6 + keras 安裝CUDA失敗 導入ten

原創 徐飛機 2018-10-11 16:07

原文作者：aircraft

原文鏈接：https://www.cnblogs.com/DOMLX/p/9769301.html

Keras是什麼？

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

Keras是一個高層神經網絡API，Keras由純Python編寫而成並基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失敗報錯問題解決

kears Dense()函數--全連接層

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：整數，使用的隨機數種子

參考文獻

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/














發表評論














所有評論



還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.







相關文章








圖神經網絡將成AI下一拐點！MIT斯坦福一文綜述GNN到底有多強






MIT、斯坦福大学 Keyulu Xu等

2019-02-24 14:03:55









HTTP狀態碼






Charles0914

2019-02-23 13:48:07









HTTP原理






elegant2008

2019-02-22 23:56:16









HTML基礎及應用視頻教程






xyduan

2019-02-23 00:39:39









純CSS動畫打造~會動的小球






狐狸菌

2019-02-22 23:53:35









JavaScript強化教程——Bootstrap 包的內容






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——Bootstrap






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——Bootstrap






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——AngularJS 指令






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——使用誤區






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——保留關鍵字






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——canvas






zhanyingwang

2019-02-22 23:39:04









JavaScript強化教程——函數參數






zhanyingwang

2019-02-22 23:38:47









JavaScript強化教程——語句






zhanyingwang

2019-02-22 23:38:42









JavaScript強化教程——AngularJS 表達式






zhanyingwang

2019-02-22 23:38:42