Keras:基于Theano和TensorFlow的深度学习库
原文鏈接：https://www.cnblogs.com/littlehann/p/6442161.html
catalogue
1. 引言
Keras是一個高層神經網絡庫，Keras由純Python編寫而成并基Tensorflow或Theano
簡易和快速的原型設計（keras具有高度模塊化，極簡，和可擴充特性）
支持CNN和RNN，或二者的結合
支持任意的鏈接方案（包括多輸入和多輸出訓練）
無縫CPU和GPU切換
0x1: Keras設計原則
0x2: 快速開始
sudo apt-get install libblas-dev liblapack-dev libatlas-base-dev gfortran pip install scipyKeras的核心數據結構是“模型”，模型是一種組織網絡層的方式。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®ularization=L1&batchSize=10&dataset=circle®Dataset=reg-plane&learningRate=0.03®ularizationRate=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]兩個向量。
0x3: 泛型模型
在原本的Keras版本中，模型其實有兩種
在現在這版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來構造該模型
也可以通過.add()方法一個個的將layer加入模型中：
model = Sequential() model.add(Dense(32, input_dim=784)) model.add(Activation('relu'))0x1: 指定輸入數據的shape
模型需要知道輸入數據的shape，因此，Sequential的第一層需要接受一個關于輸入數據shape的參數，后面的各個層則可以自動的推導出中間數據的shape，因此不需要為每個層都指定這個參數。有幾種方法來為第一層指定輸入數據的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接收三個參數：
指標列表就是用來生成最后的判斷結果的：
# 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只返回其輸出序列的最后一步結果，從而其時域維度降低（即將輸入序列轉換為單個向量）
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被編碼為特征向量
兩路特征向量被串連在一起，然后通過一個全連接網絡得到結果
Relevant Link:
http://www.jianshu.com/p/9dc9f41f0b29
http://keras-cn.readthedocs.io/en/latest/getting_started/sequential_model/
4. 泛型模型
Keras泛型模型接口是用戶定義多輸出模型、非循環有向模型或具有共享層的模型等復雜模型的途徑
例如這個全連接網絡：
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 training0x1: 所有的模型都是可調用的，就像層一樣
利用泛型模型的接口，我們可以很容易的重用已經訓練好的模型：你可以把模型當作一個層一樣，通過提供一個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個單詞
然后，我們插入一個額外的損失，使得即使在主損失很高的情況下，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編碼
若要對不同的輸入共享同一層，就初始化該層一次，然后多次調用它
# 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回歸層，從一系列可能的回答中挑選一個。
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 )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）代表將輸入的第二個維度重拍到輸出的第一個維度，而將輸入的第一個維度重排到第二個維度
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 )“sum”，“mul”，“concat”，“ave”，“cos”，“dot”
在進行merge的時候需要仔細思考采用哪種連接方式，以及將哪個軸進行merge，因為這會很大程度上影響神經網絡的訓練過程
0x9: Lambda層
本函數用以對上一層的輸出施以任何Theano/TensorFlow表達式
keras.layers.core.Lambda(function, output_shape=None, 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過的數據，則拋出異常
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 )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)=11+exp(?z)g(z)=\frac{1}{1+exp(-z)}g(z)=1+exp(?z)1?，其中zzz是一個線性組合，比如zzz可以等于：b+w1?b1+w2?b2b + w1*b1+w2*b2b+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的構造原理
輸入圖像是一個32*32的圖像集，下面分別解釋數據在各層的維度變化
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）都服從本層的性質，并接受本層指定的所有關鍵字參數
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層只能作為模型的第一層
Relevant Link:
https://keras-cn.readthedocs.io/en/latest/layers/embedding_layer/
總結
以上是生活随笔為你收集整理的Keras:基于Theano和TensorFlow的深度学习库的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Nat Genet | 杨俊/岳峰团队合
- 下一篇： 同学，要开学了，你的导师也很焦虑