原文鏈接：https://www.cnblogs.com/littlehann/p/6442161.html

catalogue

引言

一些基本概念

Sequential模型

泛型模型

常用層

卷積層

池化層

遞歸層Recurrent

嵌入層 Embedding

1. 引言

Keras是一個高層神經網絡庫，Keras由純Python編寫而成并基Tensorflow或Theano

簡易和快速的原型設計（keras具有高度模塊化，極簡，和可擴充特性）
支持CNN和RNN，或二者的結合
支持任意的鏈接方案（包括多輸入和多輸出訓練）
無縫CPU和GPU切換

0x1: Keras設計原則

模塊性: 模型可理解為一個獨立的序列或圖，完全可配置的模塊以最少的代價自由組合在一起。具體而言，網絡層、損失函數、優化器、初始化策略、激活函數、正則化方法都是獨立的模塊，我們可以使用它們來構建自己的模型

極簡主義: 每個模塊都應該盡量的簡潔。每一段代碼都應該在初次閱讀時都顯得直觀易懂。沒有黑魔法，因為它將給迭代和創新帶來麻煩

易擴展性: 添加新模塊超級簡單的容易，只需要仿照現有的模塊編寫新的類或函數即可。創建新模塊的便利性使得Keras更適合于先進的研究工作

與Python協作: Keras沒有單獨的模型配置文件類型，模型由python代碼描述，使其更緊湊和更易debug，并提供了擴展的便利性

0x2: 快速開始

sudo apt-get install libblas-dev liblapack-dev libatlas-base-dev gfortran pip install scipy

Keras的核心數據結構是“模型”，模型是一種組織網絡層的方式。Keras中主要的模型是Sequential模型，Sequential是一系列網絡層按順序構成的棧

from keras.models import Sequentialmodel = Sequential()

將一些網絡層通過.add()堆疊起來，就構成了一個模型：

from keras.layers import Dense, Activationmodel.add(Dense(output_dim=64, input_dim=100)) model.add(Activation("relu")) model.add(Dense(output_dim=10)) model.add(Activation("softmax"))

完成模型的搭建后，我們需要使用.compile()方法來編譯模型：

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

編譯模型時必須指明損失函數和優化器，如果你需要的話，也可以自己定制損失函數。Keras的一個核心理念就是簡明易用同時，保證用戶對Keras的絕對控制力度，用戶可以根據自己的需要定制自己的模型、網絡層，甚至修改源代碼

from keras.optimizers import SGD model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.01, momentum=0.9, nesterov=True))

完成模型編譯后，我們在訓練數據上按batch進行一定次數的迭代訓練，以擬合網絡

model.fit(X_train, Y_train, nb_epoch=5, batch_size=32)

當然，我們也可以手動將一個個batch的數據送入網絡中訓練，這時候需要使用

model.train_on_batch(X_batch, Y_batch)

隨后，我們可以使用一行代碼對我們的模型進行評估，看看模型的指標是否滿足我們的要求

loss_and_metrics = model.evaluate(X_test, Y_test, batch_size=32)

或者，我們可以使用我們的模型，對新的數據進行預測

classes = model.predict_classes(X_test, batch_size=32) proba = model.predict_proba(X_test, batch_size=32)

Relevant Link:

https://github.com/fchollet/keras
http://playground.tensorflow.org/#activation=tanh&regularization=L1&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&regularizationRate=0.001&noise=45&networkShape=4,5&seed=0.75320&showTestData=true&discretize=true&percTrainData=50&x=true&y=true&xTimesY=true&xSquared=true&ySquared=true&cosX=false&sinX=true&cosY=false&sinY=true&collectStats=false&problem=classification&initZero=false&hideText=false

2. 一些基本概念

0x1: 符號計算

Keras的底層庫使用Theano或TensorFlow，這兩個庫也稱為Keras的后端。無論是Theano還是TensorFlow，都是一個"符號主義"的庫。
因此，這也使得Keras的編程與傳統的Python代碼有所差別。籠統的說，符號主義的計算首先定義各種變量，然后建立一個“計算圖”，計算圖規定了各個變量之間的計算關系。建立好的計算圖需要編譯已確定其內部細節，然而，此時的計算圖還是一個"空殼子"，里面沒有任何實際的數據，只有當你把需要運算的輸入放進去后，才能在整個模型中形成數據流，從而形成輸出值。
Keras的模型搭建形式就是這種方法，在你搭建Keras模型完畢后，你的模型就是一個空殼子，只有實際生成可調用的函數后(K.function)，輸入數據，才會形成真正的數據流

0x2: 張量

使用這個詞匯的目的是為了表述統一，張量可以看作是向量、矩陣的自然推廣，我們用張量來表示廣泛的數據類型
規模最小的張量是0階張量，即標量，也就是一個數
當我們把一些數有序的排列起來，就形成了1階張量，也就是一個向量
如果我們繼續把一組向量有序的排列起來，就形成了2階張量，也就是一個矩陣
把矩陣摞起來，就是3階張量，我們可以稱為一個立方體，具有3個顏色通道的彩色圖片就是一個這樣的立方體
張量的階數有時候也稱為維度，或者軸，軸這個詞翻譯自英文axis。譬如一個矩陣[[1,2],[3,4]]，是一個2階張量，有兩個維度或軸，沿著第0個軸（為了與python的計數方式一致，本文檔維度和軸從0算起）你看到的是[1,2]，[3,4]兩個向量，沿著第1個軸你看到的是[1,3]，[2,4]兩個向量。

import numpy as npa = np.array([[1,2],[3,4]]) sum0 = np.sum(a, axis=0) sum1 = np.sum(a, axis=1)print(sum0) print(sum1)

0x3: 泛型模型

在原本的Keras版本中，模型其實有兩種

一種叫Sequential，稱為序貫模型，也就是單輸入單輸出，一條路通到底，層與層之間只有相鄰關系，跨層連接統統沒有。這種模型編譯速度快，操作上也比較簡單

第二種模型稱為Graph，即圖模型，這個模型支持多輸入多輸出，層與層之間想怎么連怎么連，但是編譯速度慢。可以看到，Sequential其實是Graph的一個特殊情況

在現在這版Keras中，圖模型被移除，而增加了了“functional model API”，這個東西，更加強調了Sequential是特殊情況這一點。一般的模型就稱為Model，然后如果你要用簡單的Sequential，OK，那還有一個快捷方式Sequential。

Relevant Link:

http://keras-cn.readthedocs.io/en/latest/getting_started/concepts/

3. Sequential模型

Sequential是多個網絡層的線性堆疊
可以通過向Sequential模型傳遞一個layer的list來構造該模型

from keras.models import Sequential from keras.layers import Dense, Activationmodel = Sequential([ Dense(32, input_dim=784), Activation('relu'), Dense(10), Activation('softmax'), ])

也可以通過.add()方法一個個的將layer加入模型中：

model = Sequential() model.add(Dense(32, input_dim=784)) model.add(Activation('relu'))

0x1: 指定輸入數據的shape

模型需要知道輸入數據的shape，因此，Sequential的第一層需要接受一個關于輸入數據shape的參數，后面的各個層則可以自動的推導出中間數據的shape，因此不需要為每個層都指定這個參數。有幾種方法來為第一層指定輸入數據的shape

傳遞一個input_shape的關鍵字參數給第一層，input_shape是一個tuple類型的數據，其中也可以填入None，如果填入None則表示此位置可能是任何正整數。數據的batch大小不應包含在其中。

傳遞一個batch_input_shape的關鍵字參數給第一層，該參數包含數據的batch大小。該參數在指定固定大小batch時比較有用，例如在stateful RNNs中。事實上，Keras在內部會通過添加一個None將input_shape轉化為batch_input_shape

有些2D層，如Dense，支持通過指定其輸入維度input_dim來隱含的指定輸入數據shape。一些3D的時域層支持通過參數input_dim和input_length來指定輸入shape

下面的三個指定輸入數據shape的方法是嚴格等價的

model = Sequential() model.add(Dense(32, input_shape=(784,)))model = Sequential() model.add(Dense(32, batch_input_shape=(None, 784))) # note that batch dimension is "None" here, # so the model will be able to process batches of any size.</pre>model = Sequential() model.add(Dense(32, input_dim=784))

下面三種方法也是嚴格等價的：

model = Sequential() model.add(LSTM(32, input_shape=(10, 64)))model = Sequential() model.add(LSTM(32, batch_input_shape=(None, 10, 64)))model = Sequential() model.add(LSTM(32, input_length=10, input_dim=64))

0x2: Merge層

多個Sequential可經由一個Merge層合并到一個輸出。Merge層的輸出是一個可以被添加到新 Sequential的層對象。下面這個例子將兩個Sequential合并到一起(activation得到最終結果矩陣)

from keras.layers import Mergeleft_branch = Sequential() left_branch.add(Dense(32, input_dim=784))right_branch = Sequential() right_branch.add(Dense(32, input_dim=784))merged = Merge([left_branch, right_branch], mode='concat')final_model = Sequential() final_model.add(merged) final_model.add(Dense(10, activation='softmax'))

Merge層支持一些預定義的合并模式，包括：

sum(defualt):逐元素相加
concat:張量串聯，可以通過提供concat_axis的關鍵字參數指定按照哪個軸進行串聯
mul：逐元素相乘
ave：張量平均
dot：張量相乘，可以通過dot_axis關鍵字參數來指定要消去的軸
cos：計算2D張量（即矩陣）中各個向量的余弦距離

這個兩個分支的模型可以通過下面的代碼訓練:

final_model.compile(optimizer='rmsprop', loss='categorical_crossentropy') final_model.fit([input_data_1, input_data_2], targets) # we pass one data array per model input

也可以為Merge層提供關鍵字參數mode，以實現任意的變換，例如：

merged = Merge([left_branch, right_branch], mode=lambda x: x[0] - x[1])

對于不能通過Sequential和Merge組合生成的復雜模型，可以參考泛型模型API

0x3: 編譯

在訓練模型之前，我們需要通過compile來對學習過程進行配置。compile接收三個參數：

優化器optimizer：該參數可指定為已預定義的優化器名，如rmsprop、adagrad，或一個Optimizer類的對象

損失函數loss：該參數為模型試圖最小化的目標函數，它可為預定義的損失函數名，如categorical_crossentropy、mse，也可以為一個損失函數

指標列表metrics：對分類問題，我們一般將該列表設置為metrics=[‘accuracy’]。指標可以是一個預定義指標的名字,也可以是一個用戶定制的函數.指標函數應該返回單個張量,或一個完成metric_name - > metric_value映射的字典

指標列表就是用來生成最后的判斷結果的：

# for a multi-class classification problem model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])# for a binary classification problem model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])# for a mean squared error regression problem model.compile(optimizer='rmsprop', loss='mse')# for custom metrics import keras.backend as Kdef mean_pred(y_true, y_pred):return K.mean(y_pred)def false_rates(y_true, y_pred):false_neg = ...false_pos = ...return {'false_neg': false_neg,'false_pos': false_pos,}model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy', mean_pred, false_rates])

0x4: 訓練

Keras以Numpy數組作為輸入數據和標簽的數據類型。訓練模型一般使用fit函數：

# for a single-input model with 2 classes (binary): model = Sequential() model.add(Dense(1, input_dim=784, activation='sigmoid')) model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy'])# generate dummy data import numpy as np data = np.random.random((1000, 784)) labels = np.random.randint(2, size=(1000, 1))# train the model, iterating on the data in batches # of 32 samples model.fit(data, labels, nb_epoch=10, batch_size=32)

另一個栗子：

# for a multi-input model with 10 classes:left_branch = Sequential() left_branch.add(Dense(32, input_dim=784))right_branch = Sequential() right_branch.add(Dense(32, input_dim=784))merged = Merge([left_branch, right_branch], mode='concat')model = Sequential() model.add(merged) model.add(Dense(10, activation='softmax'))model.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['accuracy'])# generate dummy data import numpy as np from keras.utils.np_utils import to_categorical data_1 = np.random.random((1000, 784)) data_2 = np.random.random((1000, 784))# these are integers between 0 and 9 labels = np.random.randint(10, size=(1000, 1)) # we convert the labels to a binary matrix of size (1000, 10) # for use with categorical_crossentropy labels = to_categorical(labels, 10)# train the model # note that we are passing a list of Numpy arrays as training data # since the model has 2 inputs model.fit([data_1, data_2], labels, nb_epoch=10, batch_size=32)

0x5: 一些栗子

1. 基于多層感知器的softmax多分類

from keras.models import Sequential from keras.layers import Dense, Dropout, Activation from keras.optimizers import SGDmodel = 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, input_dim=20, init='uniform')) model.add(Activation('tanh')) model.add(Dropout(0.5)) model.add(Dense(64, init='uniform')) model.add(Activation('tanh')) model.add(Dropout(0.5)) model.add(Dense(10, init='uniform')) model.add(Activation('softmax'))sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy',optimizer=sgd,metrics=['accuracy'])model.fit(X_train, y_train,nb_epoch=20,batch_size=16) score = model.evaluate(X_test, y_test, batch_size=16)

2. 相似MLP的另一種實現

model = Sequential() model.add(Dense(64, input_dim=20, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax'))model.compile(loss='categorical_crossentropy',optimizer='adadelta',metrics=['accuracy'])

3. 用于二分類的多層感知器

model = Sequential() model.add(Dense(64, input_dim=20, init='uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy',optimizer='rmsprop',metrics=['accuracy'])

4. 類似VGG的卷積神經網絡

from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D from keras.optimizers import SGDmodel = Sequential() # input: 100x100 images with 3 channels -> (3, 100, 100) tensors. # this applies 32 convolution filters of size 3x3 each. model.add(Convolution2D(32, 3, 3, border_mode='valid', input_shape=(3, 100, 100))) model.add(Activation('relu')) model.add(Convolution2D(32, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25))model.add(Convolution2D(64, 3, 3, border_mode='valid')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25))model.add(Flatten()) # Note: Keras does automatic shape inference. model.add(Dense(256)) model.add(Activation('relu')) model.add(Dropout(0.5))model.add(Dense(10)) model.add(Activation('softmax'))sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd)model.fit(X_train, Y_train, batch_size=32, nb_epoch=1)

5. 使用LSTM的序列分類

from keras.models import Sequential from keras.layers import Dense, Dropout, Activation from keras.layers import Embedding from keras.layers import LSTMmodel = Sequential() model.add(Embedding(max_features, 256, input_length=maxlen)) model.add(LSTM(output_dim=128, activation='sigmoid', inner_activation='hard_sigmoid')) model.add(Dropout(0.5)) model.add(Dense(1)) model.add(Activation('sigmoid'))model.compile(loss='binary_crossentropy',optimizer='rmsprop',metrics=['accuracy'])model.fit(X_train, Y_train, batch_size=16, nb_epoch=10) score = model.evaluate(X_test, Y_test, batch_size=16)

6. 用于序列分類的棧式LSTM

在該模型中，我們將三個LSTM堆疊在一起，是該模型能夠學習更高層次的時域特征表示。
開始的兩層LSTM返回其全部輸出序列，而第三層LSTM只返回其輸出序列的最后一步結果，從而其時域維度降低（即將輸入序列轉換為單個向量）

from keras.models import Sequential from keras.layers import LSTM, Dense import numpy as npdata_dim = 16 timesteps = 8 nb_classes = 10# expected input data shape: (batch_size, timesteps, data_dim) model = Sequential() model.add(LSTM(32, return_sequences=True,input_shape=(timesteps, data_dim))) # returns a sequence of vectors of dimension 32 model.add(LSTM(32, return_sequences=True)) # returns a sequence of vectors of dimension 32 model.add(LSTM(32)) # return a single vector of dimension 32 model.add(Dense(10, activation='softmax'))model.compile(loss='categorical_crossentropy',optimizer='rmsprop',metrics=['accuracy'])# generate dummy training data x_train = np.random.random((1000, timesteps, data_dim)) y_train = np.random.random((1000, nb_classes))# generate dummy validation data x_val = np.random.random((100, timesteps, data_dim)) y_val = np.random.random((100, nb_classes))model.fit(x_train, y_train,batch_size=64, nb_epoch=5,validation_data=(x_val, y_val))

7. 采用狀態LSTM的相同模型

狀態（stateful）LSTM的特點是，在處理過一個batch的訓練數據后，其內部狀態（記憶）會被作為下一個batch的訓練數據的初始狀態。狀態LSTM使得我們可以在合理的計算復雜度內處理較長序列

from keras.models import Sequential from keras.layers import LSTM, Dense import numpy as npdata_dim = 16 timesteps = 8 nb_classes = 10 batch_size = 32# expected input batch shape: (batch_size, timesteps, data_dim) # note that we have to provide the full batch_input_shape since the network is stateful. # the sample of index i in batch k is the follow-up for the sample i in batch k-1. model = Sequential() model.add(LSTM(32, return_sequences=True, stateful=True,batch_input_shape=(batch_size, timesteps, data_dim))) model.add(LSTM(32, return_sequences=True, stateful=True)) model.add(LSTM(32, stateful=True)) model.add(Dense(10, activation='softmax'))model.compile(loss='categorical_crossentropy',optimizer='rmsprop',metrics=['accuracy'])# generate dummy training data x_train = np.random.random((batch_size * 10, timesteps, data_dim)) y_train = np.random.random((batch_size * 10, nb_classes))# generate dummy validation data x_val = np.random.random((batch_size * 3, timesteps, data_dim)) y_val = np.random.random((batch_size * 3, nb_classes))model.fit(x_train, y_train,batch_size=batch_size, nb_epoch=5,validation_data=(x_val, y_val))

8. 將兩個LSTM合并作為編碼端來處理兩路序列的分類

兩路輸入序列通過兩個LSTM被編碼為特征向量
兩路特征向量被串連在一起，然后通過一個全連接網絡得到結果

from keras.models import Sequential from keras.layers import Merge, LSTM, Dense import numpy as npdata_dim = 16 timesteps = 8 nb_classes = 10encoder_a = Sequential() encoder_a.add(LSTM(32, input_shape=(timesteps, data_dim)))encoder_b = Sequential() encoder_b.add(LSTM(32, input_shape=(timesteps, data_dim)))decoder = Sequential() decoder.add(Merge([encoder_a, encoder_b], mode='concat')) decoder.add(Dense(32, activation='relu')) decoder.add(Dense(nb_classes, activation='softmax'))decoder.compile(loss='categorical_crossentropy',optimizer='rmsprop',metrics=['accuracy'])# generate dummy training data x_train_a = np.random.random((1000, timesteps, data_dim)) x_train_b = np.random.random((1000, timesteps, data_dim)) y_train = np.random.random((1000, nb_classes))# generate dummy validation data x_val_a = np.random.random((100, timesteps, data_dim)) x_val_b = np.random.random((100, timesteps, data_dim)) y_val = np.random.random((100, nb_classes))decoder.fit([x_train_a, x_train_b], y_train,batch_size=64, nb_epoch=5,validation_data=([x_val_a, x_val_b], y_val))

Relevant Link:

http://www.jianshu.com/p/9dc9f41f0b29
http://keras-cn.readthedocs.io/en/latest/getting_started/sequential_model/

4. 泛型模型

Keras泛型模型接口是用戶定義多輸出模型、非循環有向模型或具有共享層的模型等復雜模型的途徑

層對象接受張量為參數，返回一個張量。張量在數學上只是數據結構的擴充，一階張量就是向量，二階張量就是矩陣，三階張量就是立方體。在這里張量只是廣義的表達一種數據結構，例如一張彩色圖像其實就是一個三階張量(每一階都是one-hot向量)，它由三個通道的像素值堆疊而成。而10000張彩色圖構成的一個數據集合則是四階張量。

輸入是張量，輸出也是張量的一個框架就是一個模型

這樣的模型可以被像Keras的Sequential一樣被訓練

例如這個全連接網絡：

from keras.layers import Input, Dense from keras.models import Model# this returns a tensor inputs = Input(shape=(784,))# a layer instance is callable on a tensor, and returns a tensor x = Dense(64, activation='relu')(inputs) x = Dense(64, activation='relu')(x) predictions = Dense(10, activation='softmax')(x)# this creates a model that includes # the Input layer and three Dense layers model = Model(input=inputs, output=predictions) model.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['accuracy']) model.fit(data, labels) # starts training

0x1: 所有的模型都是可調用的，就像層一樣

利用泛型模型的接口，我們可以很容易的重用已經訓練好的模型：你可以把模型當作一個層一樣，通過提供一個tensor來調用它。注意當你調用一個模型時，你不僅僅重用了它的結構，也重用了它的權重

x = Input(shape=(784,)) # this works, and returns the 10-way softmax we defined above. y = model(x)

這種方式可以允許你快速的創建能處理序列信號的模型，你可以很快將一個圖像分類的模型變為一個對視頻分類的模型，只需要一行代碼：

from keras.layers import TimeDistributed# input tensor for sequences of 20 timesteps, # each containing a 784-dimensional vector input_sequences = Input(shape=(20, 784))# this applies our previous model to every timestep in the input sequences. # the output of the previous model was a 10-way softmax, # so the output of the layer below will be a sequence of 20 vectors of size 10. processed_sequences = TimeDistributed(model)(input_sequences)

0x2: 多輸入和多輸出模型

使用泛型模型的一個典型場景是搭建多輸入、多輸出的模型。
考慮這樣一個模型。我們希望預測Twitter上一條新聞會被轉發和點贊多少次。模型的主要輸入是新聞本身，也就是一個詞語的序列。但我們還可以擁有額外的輸入，如新聞發布的日期等。這個模型的損失函數將由兩部分組成，輔助的損失函數評估僅僅基于新聞本身做出預測的情況，主損失函數評估基于新聞和額外信息的預測的情況，即使來自主損失函數的梯度發生彌散，來自輔助損失函數的信息也能夠訓練Embeddding和LSTM層。在模型中早點使用主要的損失函數是對于深度網絡的一個良好的正則方法。總而言之，該模型框圖如下：

讓我們用泛型模型來實現這個框圖
主要的輸入接收新聞本身，即一個整數的序列（每個整數編碼了一個詞）。這些整數位于1到10，000之間（即我們的字典有10，000個詞）。這個序列有100個單詞

from keras.layers import Input, Embedding, LSTM, Dense, merge from keras.models import Model# headline input: meant to receive sequences of 100 integers, between 1 and 10000. # note that we can name any layer by passing it a "name" argument. main_input = Input(shape=(100,), dtype='int32', name='main_input')# this embedding layer will encode the input sequence # into a sequence of dense 512-dimensional vectors. x = Embedding(output_dim=512, input_dim=10000, input_length=100)(main_input)# a LSTM will transform the vector sequence into a single vector, # containing information about the entire sequence lstm_out = LSTM(32)(x)

然后，我們插入一個額外的損失，使得即使在主損失很高的情況下，LSTM和Embedding層也可以平滑的訓練

auxiliary_output = Dense(1, activation='sigmoid', name='aux_output')(lstm_out)

再然后，我們將LSTM與額外的輸入數據串聯起來組成輸入，送入模型中

auxiliary_input = Input(shape=(5,), name='aux_input') x = merge([lstm_out, auxiliary_input], mode='concat')# we stack a deep fully-connected network on top x = Dense(64, activation='relu')(x) x = Dense(64, activation='relu')(x) x = Dense(64, activation='relu')(x)# and finally we add the main logistic regression layer main_output = Dense(1, activation='sigmoid', name='main_output')(x)

最后，我們定義整個2輸入，2輸出的模型：

model = Model(input=[main_input, auxiliary_input], output=[main_output, auxiliary_output])

模型定義完畢，下一步編譯模型。我們給額外的損失賦0.2的權重。我們可以通過關鍵字參數loss_weights或loss來為不同的輸出設置不同的損失函數或權值。這兩個參數均可為Python的列表或字典。這里我們給loss傳遞單個損失函數，這個損失函數會被應用于所有輸出上

model.compile(optimizer='rmsprop', loss='binary_crossentropy',loss_weights=[1., 0.2])

編譯完成后，我們通過傳遞訓練數據和目標值訓練該模型：

model.fit([headline_data, additional_data], [labels, labels],nb_epoch=50, batch_size=32)

因為我們輸入和輸出是被命名過的（在定義時傳遞了“name”參數），我們也可以用下面的方式編譯和訓練模型：

model.compile(optimizer='rmsprop',loss={'main_output': 'binary_crossentropy', 'aux_output': 'binary_crossentropy'},loss_weights={'main_output': 1., 'aux_output': 0.2})# and trained it via: model.fit({'main_input': headline_data, 'aux_input': additional_data},{'main_output': labels, 'aux_output': labels},nb_epoch=50, batch_size=32)

0x3: 共享層

另一個使用泛型模型的場合是使用共享層的時候
考慮微博數據，我們希望建立模型來判別兩條微博是否是來自同一個用戶，這個需求同樣可以用來判斷一個用戶的兩條微博的相似性。
一種實現方式是，我們建立一個模型，它分別將兩條微博的數據映射到兩個特征向量上，然后將特征向量串聯并加一個logistic回歸層，輸出它們來自同一個用戶的概率。這種模型的訓練數據是一對對的微博。
因為這個問題是對稱的，所以處理第一條微博的模型當然也能重用于處理第二條微博。所以這里我們使用一個共享的LSTM層來進行映射。
首先，我們將微博的數據轉為（140，256）的矩陣，即每條微博有140個字符，每個單詞的特征由一個256維的詞向量表示，向量的每個元素為1表示某個字符出現，為0表示不出現，這是一個one-hot編碼

from keras.layers import Input, LSTM, Dense, merge from keras.models import Modeltweet_a = Input(shape=(140, 256)) tweet_b = Input(shape=(140, 256))

若要對不同的輸入共享同一層，就初始化該層一次，然后多次調用它

# this layer can take as input a matrix and will return a vector of size 64 shared_lstm = LSTM(64)# when we reuse the same layer instance # multiple times, the weights of the layer # are also being reused # (it is effectively *the same* layer) encoded_a = shared_lstm(tweet_a) encoded_b = shared_lstm(tweet_b)# we can then concatenate the two vectors: merged_vector = merge([encoded_a, encoded_b], mode='concat', concat_axis=-1)# and add a logistic regression on top predictions = Dense(1, activation='sigmoid')(merged_vector)# we define a trainable model linking the # tweet inputs to the predictions model = Model(input=[tweet_a, tweet_b], output=predictions)model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy']) model.fit([data_a, data_b], labels, nb_epoch=10)

0x4: 層“節點”的概念

無論何時，當你在某個輸入上調用層時，你就創建了一個新的張量（即該層的輸出），同時你也在為這個層增加一個“（計算）節點”。這個節點將輸入張量映射為輸出張量。當你多次調用該層時，這個層就有了多個節點，其下標分別為0，1，2…

0x5: 依舊是一些栗子

1. inception模型

from keras.layers import merge, Convolution2D, MaxPooling2D, Inputinput_img = Input(shape=(3, 256, 256))tower_1 = Convolution2D(64, 1, 1, border_mode='same', activation='relu')(input_img) tower_1 = Convolution2D(64, 3, 3, border_mode='same', activation='relu')(tower_1)tower_2 = Convolution2D(64, 1, 1, border_mode='same', activation='relu')(input_img) tower_2 = Convolution2D(64, 5, 5, border_mode='same', activation='relu')(tower_2)tower_3 = MaxPooling2D((3, 3), strides=(1, 1), border_mode='same')(input_img) tower_3 = Convolution2D(64, 1, 1, border_mode='same', activation='relu')(tower_3)output = merge([tower_1, tower_2, tower_3], mode='concat', concat_axis=1)

2. 卷積層的殘差連接(Residual Network)

from keras.layers import merge, Convolution2D, Input# input tensor for a 3-channel 256x256 image x = Input(shape=(3, 256, 256)) # 3x3 conv with 3 output channels(same as input channels) y = Convolution2D(3, 3, 3, border_mode='same')(x) # this returns x + y. z = merge([x, y], mode='sum')

3. 共享視覺模型

該模型在兩個輸入上重用了圖像處理的模型，用來判別兩個MNIST數字是否是相同的數字

from keras.layers import merge, Convolution2D, MaxPooling2D, Input, Dense, Flatten from keras.models import Model# first, define the vision modules digit_input = Input(shape=(1, 27, 27)) x = Convolution2D(64, 3, 3)(digit_input) x = Convolution2D(64, 3, 3)(x) x = MaxPooling2D((2, 2))(x) out = Flatten()(x)vision_model = Model(digit_input, out)# then define the tell-digits-apart model digit_a = Input(shape=(1, 27, 27)) digit_b = Input(shape=(1, 27, 27))# the vision model will be shared, weights and all out_a = vision_model(digit_a) out_b = vision_model(digit_b)concatenated = merge([out_a, out_b], mode='concat') out = Dense(1, activation='sigmoid')(concatenated)classification_model = Model([digit_a, digit_b], out)

4. 視覺問答模型(問題性圖像驗證碼)

在針對一幅圖片使用自然語言進行提問時，該模型能夠提供關于該圖片的一個單詞的答案
這個模型將自然語言的問題和圖片分別映射為特征向量，將二者合并后訓練一個logistic回歸層，從一系列可能的回答中挑選一個。

from keras.layers import Convolution2D, MaxPooling2D, Flatten from keras.layers import Input, LSTM, Embedding, Dense, merge from keras.models import Model, Sequential# first, let's define a vision model using a Sequential model. # this model will encode an image into a vector. vision_model = Sequential() vision_model.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same', input_shape=(3, 224, 224))) vision_model.add(Convolution2D(64, 3, 3, activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same')) vision_model.add(Convolution2D(128, 3, 3, activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same')) vision_model.add(Convolution2D(256, 3, 3, activation='relu')) vision_model.add(Convolution2D(256, 3, 3, activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Flatten())# now let's get a tensor with the output of our vision model: image_input = Input(shape=(3, 224, 224)) encoded_image = vision_model(image_input)# next, let's define a language model to encode the question into a vector. # each question will be at most 100 word long, # and we will index words as integers from 1 to 9999. question_input = Input(shape=(100,), dtype='int32') embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input) encoded_question = LSTM(256)(embedded_question)# let's concatenate the question vector and the image vector: merged = merge([encoded_question, encoded_image], mode='concat')# and let's train a logistic regression over 1000 words on top: output = Dense(1000, activation='softmax')(merged)# this is our final model: vqa_model = Model(input=[image_input, question_input], output=output)# the next stage would be training this model on actual data.

5. 視頻問答模型

在做完圖片問答模型后，我們可以快速將其轉為視頻問答的模型。在適當的訓練下，你可以為模型提供一個短視頻（如100幀）然后向模型提問一個關于該視頻的問題，如“what sport is the boy playing？”->“football”

from keras.layers import TimeDistributedvideo_input = Input(shape=(100, 3, 224, 224)) # this is our video encoded via the previously trained vision_model (weights are reused) encoded_frame_sequence = TimeDistributed(vision_model)(video_input) # the output will be a sequence of vectors encoded_video = LSTM(256)(encoded_frame_sequence) # the output will be a vector# this is a model-level representation of the question encoder, reusing the same weights as before: question_encoder = Model(input=question_input, output=encoded_question)# let's use it to encode the question: video_question_input = Input(shape=(100,), dtype='int32') encoded_video_question = question_encoder(video_question_input)# and this is our video question answering model: merged = merge([encoded_video, encoded_video_question], mode='concat') output = Dense(1000, activation='softmax')(merged) video_qa_model = Model(input=[video_input, video_question_input], output=output)

Relevant Link:

http://wiki.jikexueyuan.com/project/tensorflow-zh/resources/dims_types.html

5. 常用層

0x1: Dense層

Dense就是常用的全連接層

keras.layers.core.Dense(output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True, input_dim=None )

output_dim：大于0的整數，代表該層的輸出維度。模型中非首層的全連接層其輸入維度可以自動推斷，因此非首層的全連接定義時不需要指定輸入維度。

init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。該參數僅在不傳遞weights參數時才有意義。

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

weights：權值，為numpy array的list。該list應含有一個形如（input_dim,output_dim）的權重矩陣和一個形如(output_dim,)的偏置向量。

W_regularizer：施加在權重上的正則項，為WeightRegularizer對象

b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象

activity_regularizer：施加在輸出上的正則項，為ActivityRegularizer對象

W_constraints：施加在權重上的約束項，為Constraints對象

b_constraints：施加在偏置上的約束項，為Constraints對象

bias：布爾值，是否包含偏置向量（即層對輸入做線性變換還是仿射變換）

input_dim：整數，輸入數據的維度。當Dense層作為網絡的第一層時，必須指定該參數或input_shape參數。

after the first layer, you don’t need to specify the size of the input anymore

0x2: Activation層

激活層對一個層的輸出施加激活函數

keras.layers.core.Activation(activation) activation：將要使用的激活函數，為預定義激活函數名或一個Tensorflow/Theano的函數

0x3: Dropout層

為輸入數據施加Dropout。Dropout將在訓練過程中每次更新參數時隨機斷開一定百分比（p）的輸入神經元連接，Dropout層用于防止過擬合

keras.layers.core.Dropout(p) p：0~1的浮點數，控制需要斷開的鏈接的比例

0x4: Flatten層

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

keras.layers.core.Flatten() 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)

0x5: Reshape層

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

keras.layers.core.Reshape(target_shape) target_shape：目標shape，為整數的tuple，不包含樣本數目的維度（batch大小） # 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)

0x6: Permute層

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

keras.layers.core.Permute(dims)

• 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

0x7: RepeatVector層

RepeatVector層將輸入重復n次

keras.layers.core.RepeatVector(n) n：整數，重復的次數 model = Sequential() model.add(Dense(32, input_dim=32)) # now: model.output_shape == (None, 32) # note: `None` is the batch dimensionmodel.add(RepeatVector(3)) # now: model.output_shape == (None, 3, 32)

0x8: Merge層

Merge層根據給定的模式，將一個張量列表中的若干張量合并為一個單獨的張量

keras.engine.topology.Merge(layers=None, mode='sum', concat_axis=-1, dot_axes=-1, output_shape=None, node_indices=None, tensor_indices=None, name=None )

layers：該參數為Keras張量的列表，或Keras層對象的列表。該列表的元素數目必須大于1。

mode：合并模式，為預定義合并模式名的字符串或lambda函數或普通函數，如果為lambda函數或普通函數，則該函數必須接受一個張量的list作為輸入，并返回一個張量。如果為字符串，則必須是下列值之一：
“sum”，“mul”，“concat”，“ave”，“cos”，“dot”

concat_axis：整數，當mode=concat時指定需要串聯的軸

dot_axes：整數或整數tuple，當mode=dot時，指定要消去的軸

output_shape：整數tuple或lambda函數/普通函數（當mode為函數時）。如果output_shape是函數時，該函數的輸入值應為一一對應于輸入shape的list，并返回輸出張量的shape。

node_indices：可選，為整數list，如果有些層具有多個輸出節點（node）的話，該參數可以指定需要merge的那些節點的下標。如果沒有提供，該參數的默認值為全0向量，即合并輸入層0號節點的輸出值。

tensor_indices：可選，為整數list，如果有些層返回多個輸出張量的話，該參數用以指定需要合并的那些張量

在進行merge的時候需要仔細思考采用哪種連接方式，以及將哪個軸進行merge，因為這會很大程度上影響神經網絡的訓練過程

0x9: Lambda層

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

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

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

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

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

0x10: ActivityRegularizer層

經過本層的數據不會有任何變化，但會基于其激活值更新損失函數值

keras.layers.core.ActivityRegularization(l1=0.0, l2=0.0) l1：1范數正則因子（正浮點數） l2：2范數正則因子（正浮點數）

0x11: Masking層

使用給定的值對輸入的序列信號進行“屏蔽”，用以定位需要跳過的時間步
對于輸入張量的時間步，即輸入張量的第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))

0x12: Highway層

Highway層建立全連接的Highway網絡，這是LSTM在前饋神經網絡中的推廣

keras.layers.core.Highway(init='glorot_uniform', transform_bias=-2, activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True, input_dim=None )

output_dim：大于0的整數，代表該層的輸出維度。模型中非首層的全連接層其輸入維度可以自動推斷，因此非首層的全連接定義時不需要指定輸入維度。

init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。該參數僅在不傳遞weights參數時有意義。

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

weights：權值，為numpy array的list。該list應含有一個形如（input_dim,output_dim）的權重矩陣和一個形如(output_dim,)的偏置向量。

W_regularizer：施加在權重上的正則項，為WeightRegularizer對象

b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象

activity_regularizer：施加在輸出上的正則項，為ActivityRegularizer對象

W_constraints：施加在權重上的約束項，為Constraints對象

b_constraints：施加在偏置上的約束項，為Constraints對象

bias：布爾值，是否包含偏置向量（即層對輸入做線性變換還是仿射變換）

input_dim：整數，輸入數據的維度。當該層作為網絡的第一層時，必須指定該參數或input_shape參數。

transform_bias：用以初始化傳遞參數，默認為-2（請參考文獻理解本參數的含義）

0x13: MaxoutDense層

全連接的Maxout層。MaxoutDense層以nb_features個Dense(input_dim,output_dim)線性層的輸出的最大值為輸出。MaxoutDense可對輸入學習出一個凸的、分段線性的激活函數

Relevant Link:

https://keras-cn.readthedocs.io/en/latest/layers/core_layer/

6. 卷積層

數據輸入層: 對數據做一些處理，比如去均值(把輸入數據各個維度都中心化為0，避免數據過多偏差，影響訓練效果)、歸一化(把所有的數據都歸一到同樣的范圍)、PCA/白化等等
中間是
CONV: 卷積計算層，線性乘積 求和(內積)
RELU: 激勵層(激活函數)，用于把向量轉化為一個"量值"，用于評估本輪參數的分類效果
POOL: 池化層，簡言之，即取區域平均或最大
最右邊是
FC: 全連接層

0x0: CNN之卷積計算層

1. CNN核心概念: 濾波

在通信領域中，濾波(Wave filtering)指的是將信號中特定波段頻率濾除的操作，是抑制和防止干擾的一項重要措施。在CNN圖像識別領域，指的是對圖像(不同的數據窗口數據)和濾波矩陣(一組固定的權重：因為每個神經元的多個權重固定，所以又可以看做一個恒定的濾波器filter)做內積(逐個元素相乘再求和)的操作就是所謂的"卷積"操作，也是卷積神經網絡的名字來源。
直觀上理解就是從一個區域(區域的大小就是filter濾波器的size)中抽取出"重要的細節"，而抽取的方法就是建立"區域權重"，根據區域權重把一個區域中的重點細節過濾出來
再直觀一些理解就是例如上圖的汽車圖像，濾波器要做的就是把其中的輪胎、車后視鏡、前臉輪廓、A柱形狀過濾出來，從邊緣細節的角度來看待一張非格式化的圖像
這種技術的理論基礎是學術界認為人眼對圖像的識別也是分層的，人眼第一眼接收到的就是一個物理的輪廓細節，然后傳輸給大腦皮層，然后在輪廓細節的基礎上進一步抽象建立起對一個物理的整體感知

非嚴格意義上來講，上圖中紅框框起來的部分便可以理解為一個濾波器，即帶著一組固定權重的神經元。多個濾波器疊加便成了卷積層

2. 圖像上的卷積

在下圖對應的計算過程中，輸入是一定區域大小(width*height)的數據，和濾波器filter（帶著一組固定權重的神經元）做內積后等到新的二維數據。
具體來說，左邊是圖像輸入，中間部分就是濾波器filter（帶著一組固定權重的神經元），不同的濾波器filter會得到不同的輸出數據，比如顏色深淺、輪廓。相當于如果想提取圖像的不同特征，則用不同的濾波器filter，提取想要的關于圖像的特定信息：顏色深淺或輪廓

3. CNN濾波器

在CNN中，濾波器filter（帶著一組固定權重的神經元）對局部輸入數據進行卷積計算。每計算完一個數據窗口內的局部數據后，數據窗口不斷平移滑動，直到計算完所有數據

可以看到：

兩個神經元，即depth=2，意味著有兩個濾波器。
數據窗口每次移動兩個步長取3*3的局部數據，即stride=2。
zero-padding=1

然后分別以兩個濾波器filter為軸滑動數組進行卷積計算，得到兩組不同的結果。通過這種滑動窗口的濾波過程，逐步把圖像的各個細節信息提取出來(邊緣輪廓、圖像深淺)。值得注意的是

局部感知機制
左邊數據在變化，每次濾波器都是針對某一局部的數據窗口進行卷積，這就是所謂的CNN中的局部感知機制。
打個比方，濾波器就像一雙眼睛，人類視角有限，一眼望去，只能看到這世界的局部。如果一眼就看到全世界，你會累死，而且一下子接受全世界所有信息，你大腦接收不過來。當然，即便是看局部，針對局部里的信息人類雙眼也是有偏重、偏好的。比如看美女，對臉、胸、腿是重點關注，所以這3個輸入的權重相對較大

參數(權重)共享機制
數據窗口滑動，導致輸入濾波器的數據在變化，但中間濾波器Filter w0的權重(即每個神經元連接數據窗口的權重)是固定不變的，這個權重不變即所謂的CNN中的參數(權重)共享機制。
再打個比方，某人環游全世界，所看到的信息在變，但采集信息的雙眼不變。一個人對景物的認知在一定時間段內是保持不變的，但是需要注意的是，這些權重也不是永遠不變的，隨著訓練的進行，權重會根據激活函數的判斷結果不斷調整網絡中的權重(這就是所謂的BP反向傳播算法)

4. CNN激勵層

常用的非線性激活函數有sigmoid、tanh、relu等等，前兩者sigmoid/tanh比較常見于全連接層，后者relu常見于卷積層

4. 1 sigmoid

激活函數sigmoid：$g(z)=\frac{1}{1+exp(?z)}$，其中$z$是一個線性組合，比如$z$可以等于：$b+w1?b1+w2?b2$

橫軸表示定義域z，縱軸表示值域g(z)。sigmoid函數的功能是相當于把一個實數壓縮至0到1之間。當z是非常大的正數時，g(z)會趨近于1，而z是非常大的負數時，則g(z)會趨近于0
這樣一來便可以把激活函數看作一種“分類的概率”，比如激活函數的輸出為0.9的話便可以解釋為90%的概率為正樣本

4.2 ReLU激勵層

ReLU的優點是收斂快，求梯度簡單

5. CNN池化層

池化，簡言之，即取區域平均或最大

接下來拿一個真實的CNN網絡來解釋CNN的構造原理

Input layer of NxN pixels (N=32).

Convolutional layer (64 filter maps of size 11x11).

Max-pooling layer.

Densely-connected layer (4096 neurons)

Output layer. 9 neurons.

輸入圖像是一個32*32的圖像集，下面分別解釋數據在各層的維度變化

input layer: 32x32 neurons

convolutional layer(64 filters, size 11x11): (32?11+1)?(32?11+1) = 22?22 = 484 for each feature map. As a result, the total output of the convolutional layer is 22?22?64 = 30976.

pooling layer(2x2 regions): reduced to 11?11?64 = 7744.

fully-connected layer: 4096 neurons

output layer

The number of learnable parameters P of this network is:

P = 1024?(11?11?64)+64+(11?11?64)?4096+4096+4096?9+9 = 39690313

我們注意看你第二層的CNN層，它實際上可以理解為我們對同一幅圖，根據不同的觀察重點(濾波窗口移動)得到的不同細節視角的圖像

0x1: Convolution1D層

一維卷積層，用以在一維輸入信號上進行鄰域濾波。當使用該層作為首層時，需要提供關鍵字參數input_dim或input_shape。例如input_dim=128長為128的向量序列輸入，而input_shape=(10,128)代表一個長為10的128向量序列(對于byte詞頻的代碼段特征向量來說就是input_shape=(15000, 256))

keras.layers.convolutional.Convolution1D(nb_filter, filter_length, init='uniform', activation='linear', weights=None, border_mode='valid', subsample_length=1, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True, input_dim=None, input_length=None )1. nb_filter：卷積核的數目(即輸出的維度)(我們可以利用filter來減少CNN輸入層的維度，降低計算量) 2. filter_length：卷積核的空域或時域長度 3. init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。該參數僅在不傳遞weights參數時有意義。 4. activation：激活函數，為預定義的激活函數名（參考激活函數），或逐元素（element-wise）的Theano函數。如果不指定該參數，將不會使用任何激活函數（即使用線性激活函數：a(x)=x） 5. weights：權值，為numpy array的list。該list應含有一個形如（input_dim,output_dim）的權重矩陣和一個形如(output_dim,)的偏置向量。 6. border_mode：邊界模式，為“valid”, “same” 或“full”，full需要以theano為后端 7. subsample_length：輸出對輸入的下采樣因子 8. W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 9. b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象 10. activity_regularizer：施加在輸出上的正則項，為ActivityRegularizer對象 11. W_constraints：施加在權重上的約束項，為Constraints對象 12. b_constraints：施加在偏置上的約束項，為Constraints對象 13. bias：布爾值，是否包含偏置向量（即層對輸入做線性變換還是仿射變換） 14. input_dim：整數，輸入數據的維度。當該層作為網絡的第一層時，必須指定該參數或input_shape參數。 15. input_length：當輸入序列的長度固定時，該參數為輸入序列的長度。當需要在該層后連接Flatten層，然后又要連接Dense層時，需要指定該參數，否則全連接的輸出無法計算出來

example

# apply a convolution 1d of length 3 to a sequence with 10 timesteps, # with 64 output filters model = Sequential() model.add(Convolution1D(64, 3, border_mode='same', input_shape=(10, 32))) # now model.output_shape == (None, 10, 64)# add a new conv1d on top model.add(Convolution1D(32, 3, border_mode='same')) # now model.output_shape == (None, 10, 32)

可以將Convolution1D看作Convolution2D的快捷版，對例子中（10，32）的信號進行1D卷積相當于對其進行卷積核為（filter_length, 32）的2D卷積

0x2: AtrousConvolution1D層

AtrousConvolution1D層用于對1D信號進行濾波，是膨脹/帶孔洞的卷積。當使用該層作為首層時，需要提供關鍵字參數input_dim或input_shape。例如input_dim=128長為128的向量序列輸入，而input_shape=(10,128)代表一個長為10的128向量序列.

keras.layers.convolutional.AtrousConvolution1D(nb_filter, filter_length, init='uniform', activation='linear', weights=None, border_mode='valid', subsample_length=1, atrous_rate=1, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True )1. nb_filter：卷積核的數目（即輸出的維度） 2. filter_length：卷積核的空域或時域長度 3. init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。該參數僅在不傳遞weights參數時有意義。 5. activation：激活函數，為預定義的激活函數名（參考激活函數），或逐元素（element-wise）的Theano函數。如果不指定該參數，將不會使用任何激活函數（即使用線性激活函數：a(x)=x） 6. weights：權值，為numpy array的list。該list應含有一個形如（input_dim,output_dim）的權重矩陣和一個形如(output_dim,)的偏置向量。 7. border_mode：邊界模式，為“valid”，“same”或“full”，full需要以theano為后端 8. subsample_length：輸出對輸入的下采樣因子 9. atrous_rate:卷積核膨脹的系數，在其他地方也被稱為'filter_dilation' 10. W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 11. b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象 12. activity_regularizer：施加在輸出上的正則項，為ActivityRegularizer對象 13. W_constraints：施加在權重上的約束項，為Constraints對象 14. b_constraints：施加在偏置上的約束項，為Constraints對象 15. bias：布爾值，是否包含偏置向量（即層對輸入做線性變換還是仿射變換） 16. input_dim：整數，輸入數據的維度。當該層作為網絡的第一層時，必須指定該參數或input_shape參數。 17. input_length：當輸入序列的長度固定時，該參數為輸入序列的長度。當需要在該層后連接Flatten層，然后又要連接Dense層時，需要指定該參數，否則全連接的輸出無法計算出來。

example

# apply an atrous convolution 1d with atrous rate 2 of length 3 to a sequence with 10 timesteps, # with 64 output filters model = Sequential() model.add(AtrousConvolution1D(64, 3, atrous_rate=2, border_mode='same', input_shape=(10, 32))) # now model.output_shape == (None, 10, 64)# add a new atrous conv1d on top model.add(AtrousConvolution1D(32, 3, atrous_rate=2, border_mode='same')) # now model.output_shape == (None, 10, 32)

0x3: Convolution2D層

二維卷積層對二維輸入進行滑動窗卷積，當使用該層作為第一層時，應提供input_shape參數。例如input_shape = (3,128,128)代表128*128的彩色RGB圖像

keras.layers.convolutional.Convolution2D(nb_filter, nb_row, nb_col, init='glorot_uniform', activation='linear', weights=None, border_mode='valid', subsample=(1, 1), dim_ordering='th', W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True )1. nb_filter：卷積核的數目 2. nb_row：卷積核的行數 3. nb_col：卷積核的列數 4. init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。該參數僅在不傳遞weights參數時有意義。 5. activation：激活函數，為預定義的激活函數名（參考激活函數），或逐元素（element-wise）的Theano函數。 如果不指定該參數，將不會使用任何激活函數（即使用線性激活函數：a(x)=x） 6. weights：權值，為numpy array的list。該list應含有一個形如（input_dim,output_dim）的權重矩陣和一個形如(output_dim,)的偏置向量。 7. border_mode：邊界模式，為“valid”，“same”或“full”，full需要以theano為后端 8. subsample：長為2的tuple，輸出對輸入的下采樣因子，更普遍的稱呼是“strides” 9. W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 10. b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象 11. activity_regularizer：施加在輸出上的正則項，為ActivityRegularizer對象 12. W_constraints：施加在權重上的約束項，為Constraints對象 13. b_constraints：施加在偏置上的約束項，為Constraints對象 14. dim_ordering：‘th’或‘tf’。‘th’模式中通道維（如彩色圖像的3通道）位于第1個位置（維度從0開始算），而在‘tf’模式中，通道維位于第3個位置。例如128*128的三通道彩色圖片，在‘th’模式中input_shape應寫為（3，128，128），而在‘tf’模式中應寫為（128，128，3），注意這里3出現在第0個位置，因為input_shape不包含樣本數的維度，在其內部實現中，實際上是（None，3，128，128）和（None，128，128，3）。默認是image_dim_ordering指定的模式，可在~/.keras/keras.json中查看，若沒有設置過則為'tf'。 15. bias：布爾值，是否包含偏置向量（即層對輸入做線性變換還是仿射變換）

example

# apply a 3x3 convolution with 64 output filters on a 256x256 image: model = Sequential() model.add(Convolution2D(64, 3, 3, border_mode='same', input_shape=(3, 256, 256))) # now model.output_shape == (None, 64, 256, 256)# add a 3x3 convolution on top, with 32 output filters: model.add(Convolution2D(32, 3, 3, border_mode='same')) # now model.output_shape == (None, 32, 256, 256)

0x4: AtrousConvolution2D層

該層對二維輸入進行Atrous卷積，也即膨脹卷積或帶孔洞的卷積。當使用該層作為第一層時，應提供input_shape參數。例如input_shape = (3,128,128)代表128*128的彩色RGB圖像

Relevant Link:

https://keras-cn.readthedocs.io/en/latest/layers/convolutional_layer/
http://baike.baidu.com/item/%E6%BB%A4%E6%B3%A2
http://blog.csdn.net/v_july_v/article/details/51812459
http://cs231n.github.io/convolutional-networks/#overview
http://blog.csdn.net/stdcoutzyx/article/details/41596663

7. 池化層

0x1: MaxPooling1D層

對時域1D信號進行最大值池化

keras.layers.convolutional.MaxPooling1D(pool_length=2, stride=None, border_mode='valid' )pool_length：下采樣因子，如取2則將輸入下采樣到一半長度 stride：整數或None，步長值 border_mode：‘valid’或者‘same’

0x2: MaxPooling2D層

為空域信號施加最大值池化

keras.layers.convolutional.MaxPooling2D(pool_size=(2, 2), strides=None, border_mode='valid', dim_ordering='th' ) 1. pool_size：長為2的整數tuple，代表在兩個方向（豎直，水平）上的下采樣因子，如取（2，2）將使圖片在兩個維度上均變為原長的一半 2. strides：長為2的整數tuple，或者None，步長值。 3. border_mode：‘valid’或者‘same’ 4. dim_ordering：‘th’或‘tf’。‘th’模式中通道維（如彩色圖像的3通道）位于第1個位置（維度從0開始算），而在‘tf’模式中，通道維位于第3個位置。例如128*128的三通道彩色圖片，在‘th’模式中input_shape應寫為（3，128，128），而在‘tf’模式中應寫為（128，128，3），注意這里3出現在第0個位置，因為input_shape不包含樣本數的維度，在其內部實現中，實際上是（None，3，128，128）和（None，128，128，3）。默認是image_dim_ordering指定的模式，可在~/.keras/keras.json中查看，若沒有設置過則為'tf'

0x3: AveragePooling1D層

對時域1D信號進行平均值池化

keras.layers.convolutional.AveragePooling1D(pool_length=2, stride=None, border_mode='valid' ) 1. pool_length：下采樣因子，如取2則將輸入下采樣到一半長度 2. stride：整數或None，步長值 3. border_mode：‘valid’或者‘same’ 注意，目前‘same’模式只能在TensorFlow作為后端時使用

0x4: GlobalMaxPooling1D層

對于時間信號的全局最大池化

keras.layers.pooling.GlobalMaxPooling1D()

Relevant Link:

https://keras-cn.readthedocs.io/en/latest/layers/pooling_layer/

8. 遞歸層Recurrent

0x1: Recurrent層

這是遞歸層的抽象類，請不要在模型中直接應用該層（因為它是抽象類，無法實例化任何對象）。請使用它的子類LSTM或SimpleRNN。
所有的遞歸層（LSTM,GRU,SimpleRNN）都服從本層的性質，并接受本層指定的所有關鍵字參數

keras.layers.recurrent.Recurrent(weights=None, return_sequences=False, go_backwards=False, stateful=False, unroll=False, consume_less='cpu', input_dim=None, input_length=None )1. weights：numpy array的list，用以初始化權重。該list形如[(input_dim, output_dim),(output_dim, output_dim),(output_dim,)] 2. return_sequences：布爾值，默認False，控制返回類型。若為True則返回整個序列，否則僅返回輸出序列的最后一個輸出 3. go_backwards：布爾值，默認為False，若為True，則逆向處理輸入序列 4. stateful：布爾值，默認為False，若為True，則一個batch中下標為i的樣本的最終狀態將會用作下一個batch同樣下標的樣本的初始狀態。 5. unroll：布爾值，默認為False，若為True，則遞歸層將被展開，否則就使用符號化的循環。當使用TensorFlow為后端時，遞歸網絡本來就是展開的，因此該層不做任何事情。層展開會占用更多的內存，但會加速RNN的運算。層展開只適用于短序列。 6. consume_less：‘cpu’或‘mem’之一。若設為‘cpu’，則RNN將使用較少、較大的矩陣乘法來實現，從而在CPU上會運行更快，但會更消耗內存。如果設為‘mem’，則RNN將會較多的小矩陣乘法來實現，從而在GPU并行計算時會運行更快（但在CPU上慢），并占用較少內存。 7. input_dim：輸入維度，當使用該層為模型首層時，應指定該值（或等價的指定input_shape) 8. input_length：當輸入序列的長度固定時，該參數為輸入序列的長度。當需要在該層后連接Flatten層，然后又要連接Dense層時，需要指定該參數，否則全連接的輸出無法計算出來。注意，如果遞歸層不是網絡的第一層，你需要在網絡的第一層中指定序列的長度，如通過input_shape指定。

0x2: SimpleRNN層

全連接RNN網絡，RNN的輸出會被回饋到輸入

keras.layers.recurrent.SimpleRNN(output_dim, init='glorot_uniform', inner_init='orthogonal', activation='tanh', W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0.0, dropout_U=0.0 )output_dim：內部投影和輸出的維度 init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。 inner_init：內部單元的初始化方法 activation：激活函數，為預定義的激活函數名（參考激活函數） W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 U_regularizer：施加在遞歸權重上的正則項，為WeightRegularizer對象 b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象 dropout_W：0~1之間的浮點數，控制輸入單元到輸入門的連接斷開比例 dropout_U：0~1之間的浮點數，控制輸入單元到遞歸連接的斷開比例

0x3: GRU層

門限遞歸單元

keras.layers.recurrent.GRU(output_dim, init='glorot_uniform', inner_init='orthogonal', activation='tanh', inner_activation='hard_sigmoid', W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0.0, dropout_U=0.0 )output_dim：內部投影和輸出的維度 init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。 inner_init：內部單元的初始化方法 activation：激活函數，為預定義的激活函數名（參考激活函數） inner_activation：內部單元激活函數 W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 U_regularizer：施加在遞歸權重上的正則項，為WeightRegularizer對象 b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象 dropout_W：0~1之間的浮點數，控制輸入單元到輸入門的連接斷開比例 dropout_U：0~1之間的浮點數，控制輸入單元到遞歸連接的斷開比例

0x4: LSTM層

Keras長短期記憶模型

keras.layers.recurrent.LSTM(output_dim, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0.0, dropout_U=0.0 )output_dim：內部投影和輸出的維度 init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。 inner_init：內部單元的初始化方法 forget_bias_init：遺忘門偏置的初始化函數，Jozefowicz et al.建議初始化為全1元素 activation：激活函數，為預定義的激活函數名（參考激活函數） inner_activation：內部單元激活函數 W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 U_regularizer：施加在遞歸權重上的正則項，為WeightRegularizer對象 b_regularizer：施加在偏置向量上的正則項，為WeightRegularizer對象 dropout_W：0~1之間的浮點數，控制輸入單元到輸入門的連接斷開比例 dropout_U：0~1之間的浮點數，控制輸入單元到遞歸連接的斷開比例

Relevant Link:

https://keras-cn.readthedocs.io/en/latest/layers/recurrent_layer/

9. 嵌入層 Embedding

0x1: Embedding層

嵌入層將正整數（下標）轉換為具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]。是一種數字化->向量化的編碼方式，使用Embedding需要輸入的特征向量具備空間關聯性
Embedding層只能作為模型的第一層

keras.layers.embeddings.Embedding(input_dim, output_dim, init='uniform', input_length=None, W_regularizer=None, activity_regularizer=None, W_constraint=None, mask_zero=False, weights=None, dropout=0.0 )input_dim：大或等于0的整數，字典長度，即輸入數據最大下標+1 output_dim：大于0的整數，代表全連接嵌入的維度 init：初始化方法，為預定義初始化方法名的字符串，或用于初始化權重的Theano函數。該參數僅在不傳遞weights參數時有意義。 weights：權值，為numpy array的list。該list應僅含有一個如（input_dim,output_dim）的權重矩陣 W_regularizer：施加在權重上的正則項，為WeightRegularizer對象 W_constraints：施加在權重上的約束項，為Constraints對象 mask_zero：布爾值，確定是否將輸入中的‘0’看作是應該被忽略的‘填充’（padding）值，該參數在使用遞歸層處理變長輸入時有用。設置為True的話，模型中后續的層必須都支持masking，否則會拋出異常 input_length：當輸入序列的長度固定時，該值為其長度。如果要在該層后接Flatten層，然后接Dense層，則必須指定該參數，否則Dense層的輸出維度無法自動推斷。 dropout：0~1的浮點數，代表要斷開的嵌入比例

Relevant Link:

https://keras-cn.readthedocs.io/en/latest/layers/embedding_layer/

總結

以上是生活随笔為你收集整理的Keras:基于Theano和TensorFlow的深度学习库的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。