[譯] Keras TensorFlow 教程：如何從零開發一個復雜深度學習模型

wsxxw2014 7年前發布 | 61K 次閱讀 Keras 深度學習 TensorFlow

Keras 是提供一些高可用的 Python API ，能幫助你快速的構建和訓練自己的深度學習模型，它的后端是 TensorFlow 或者 Theano 。本文假設你已經熟悉了 TensorFlow 和卷積神經網絡，如果，你還沒有熟悉，那么可以先看看這個 10分鐘入門 TensorFlow 教程和卷積神經網絡教程，然后再回來閱讀這個文章。

在這個教程中，我們將學習以下幾個方面：

為什么選擇 Keras？為什么 Keras 被認為是深度學習的未來？
在Ubuntu上面一步一步安裝Keras。
Keras TensorFlow教程：Keras基礎知識。
了解 Keras 序列模型
4.1 實際例子講解線性回歸問題
使用 Keras 保存和回復預訓練的模型
Keras API
6.1 使用Keras API開發VGG卷積神經網絡
6.2 使用Keras API構建并運行SqueezeNet卷積神經網絡

1. 為什么選擇Keras？

Keras 是 Google 的一位工程師 Fran?ois Chollet 開發的一個框架，可以幫助你在 Theano 上面進行快速原型開發。后來，這被擴展為 TensorFlow 也可以作為后端。并且最近，TensorFlow決定將其作為 contrib 文件中的一部分進行提供。

Keras 被認為是構建神經網絡的未來，以下是一些它流行的原因：

輕量級和快速開發：Keras 的目的是在消除樣板代碼。幾行 Keras 代碼就能比原生的 TensorFlow 代碼實現更多的功能。你也可以很輕松的實現 CNN 和 RNN，并且讓它們運行在 CPU 或者 GPU 上面。
框架的“贏者”：Keras 是一個API，運行在別的深度學習框架上面。這個框架可以是 TensorFlow 或者 Theano。Microsoft 也計劃讓 CNTK 作為 Keras 的一個后端。目前，神經網絡框架世界是非常分散的，并且發展非常快。具體，你可以看看 Karpathy 的這個推文：

想象一下，我們每年都要去學習一個新的框架，這是多么的痛苦。到目前為止，TensorFlow 似乎成為了一種潮流，并且越來越多的框架開始為 Keras 提供支持，它可能會成為一種標準。

目前，Keras 是成長最快的一種深度學習框架。因為可以使用不同的深度學習框架作為后端，這也使得它成為了流行的一個很大的原因。你可以設想這樣一個場景，如果你閱讀到了一篇很有趣的論文，并且你想在你自己的數據集上面測試這個模型。讓我們再次假設，你對TensorFlow 非常熟悉，但是對Theano了解的非常少。那么，你必須使用TensorFlow 對這個論文進行復現，但是這個周期是非常長的。但是，如果現在代碼是采用Keras寫的，那么你只要將后端修改為TensorFlow就可以使用代碼了。這將是對社區發展的一個巨大的推動作用。

2. 怎么安裝Keras，并且把TensorFlow作為后端

a) 依賴安裝

安裝 h5py，用于模型的保存和載入：

pip install h5py

還有一些依賴包也要安裝。

pip install numpy scipy
pip install pillow

如果你還沒有安裝TensorFlow，那么你可以按照這個教程先去安裝TensorFlow。一旦，你安裝完成了 TensorFlow，你只需要使用 pip 很容易的安裝 Keras。

sudo pip install keras

使用以下命令來查看 Keras 版本。

>>> import keras
Using TensorFlow backend.
>>> keras.__version__
'2.0.4'

一旦，Keras 被安裝完成，你需要去修改后端文件，也就是去確定，你需要 TensorFlow 作為后端，還是 Theano 作為后端，修改的配置文件位于 ~/.keras/keras.json 。具體配置如下：

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

請注意，參數 image_data_format 是 channels_last ，也就是說這個后端是 TensorFlow。因為，在TensorFlow中圖像的存儲方式是 [height, width, channels] ，但是在Theano中是完全不同的，也就是 [channels, height, width] 。因此，如果你沒有正確的設置這個參數，那么你模型的中間結果將是非常奇怪的。對于Theano來說，這個參數就是 channels_first 。

那么，至此你已經準備好了，使用Keras來構建模型，并且把TensorFlow作為后端。

3. Keras基礎知識

在Keras中主要的數據結構是 model ，該結構定義了一個完整的圖。你可以向已經存在的圖中加入任何的網絡結構。

import keras

Keras 有兩種不同的建模方式：

Sequential models：這種方法用于實現一些簡單的模型。你只需要向一些存在的模型中添加層就行了。
Functional API：Keras的API是非常強大的，你可以利用這些API來構造更加復雜的模型，比如多輸出模型，有向無環圖等等。

在本文的下一節中，我們將學習Keras的Sequential models 和 Functional API的理論和實例。

4. Keras Sequential models

在這一部分中，我將來介紹Keras Sequential models的理論。我將快速的解釋它是如何工作的，還會利用具體代碼來解釋。之后，我們將解決一個簡單的線性回歸問題，你可以在閱讀的同時運行代碼，來加深印象。

以下代碼是如何開始導入和構建序列模型。

from keras.models import Sequential
models = Sequential()

接下來我們可以向模型中添加 Dense（full connected layer），Activation，Conv2D，MaxPooling2D函數。

from keras.layers import Dense, Activation, Conv2D, MaxPooling2D, Flatten, Dropout
model.add(Conv2D(64, (3,3), activation='relu', input_shape = (100,100,32)))
# This ads a Convolutional layer with 64 filters of size 3 * 3 to the graph

以下是如何將一些最流行的圖層添加到網絡中。我已經在卷積神經網絡教程中寫了很多關于圖層的描述。

1. 卷積層

這里我們使用一個卷積層，64個卷積核，維度是3 3的，之后采用 relu 激活函數進行激活，輸入數據的維度是 `100 100*32`。注意，如果是第一個卷積層，那么必須加上輸入數據的維度，后面幾個這個參數可以省略。

model.add(Conv2D(64, (3,3), activation='relu', input_shape = (100,100,32)))

2. MaxPooling 層

指定圖層的類型，并且指定赤的大小，然后自動完成赤化操作，酷斃了！

model.add(MaxPooling2D(pool_size=(2,2)))

3. 全連接層

這個層在 Keras 中稱為被稱之為 Dense 層，我們只需要設置輸出層的維度，然后Keras就會幫助我們自動完成了。

model.add(Dense(256, activation='relu'))

4. Dropout

model.add(Dropout(0.5))

5. 扁平層

model.add(Flatten())

數據輸入

網絡的第一層需要讀入訓練數據。因此我們需要去制定輸入數據的維度。因此， input_shape 參數被用于制定輸入數據的維度大小。

model.add(Conv2D(32, (3,3), activation='relu', input_shape=(224, 224, 3)))

在這個例子中，數據輸入的第一層是一個卷積層，輸入數據的大小是 224*224*3 。

以上操作就幫助你利用序列模型構建了一個模型。接下來，讓我們學習最重要的一個部分。一旦你指定了一個網絡架構，你還需要指定優化器和損失函數。我們在Keras中使用compile函數來達到這個功能。比如，在下面的代碼中，我們使用 rmsprop 來作為優化器， binary_crossentropy 來作為損失函數值。

model.compile(loss='binary_crossentropy', optimizer='rmsprop')

如果你想要使用隨機梯度下降，那么你需要選擇合適的初始值和超參數：

from keras.optimizers import SGD
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)

現在，我們已經構建完了模型。接下來，讓我們向模型中輸入數據，在Keras中是通過 fit 函數來實現的。你也可以在該函數中指定 batch_size 和 epochs 來訓練。

model.fit(x_train, y_train, batch_size = 32, epochs = 10, validation_data(x_val, y_val))

最后，我們使用 evaluate 函數來測試模型的性能。

score = model.evaluate(x_test, y_test, batch_size = 32)

這些就是使用序列模型在Keras中構建神經網絡的具體操作步驟。現在，我們來構建一個簡單的線性回歸模型。

4.1 實際例子講解線性回歸問題

問題陳述

在線性回歸問題中，你可以得到很多的數據點，然后你需要使用一條直線去擬合這些離散點。在這個例子中，我們創建了100個離散點，然后用一條直線去擬合它們。

a) 創建訓練數據

TrainX 的數據范圍是 -1 到 1，TrainY 與 TrainX 的關系是3倍，并且我們加入了一些噪聲點。

import keras
from keras.models import Sequential
from keras.layers import Dense
import numpy as np

trX = np.linspace(-1, 1, 101)
trY = 3 * trX + np.random.randn(*trX.shape) * 0.33

b) 構建模型

首先我們需要構建一個序列模型。我們需要的只是一個簡單的鏈接，因此我們只需要使用一個 Dense 層就夠了，然后用線性函數進行激活。

model = Sequential()
model.add(Dense(input_dim=1, output_dim=1, init='uniform', activation='linear'))

下面的代碼將設置輸入數據 x，權重 w 和偏置項 b。然我們來看看具體的初始化工作。如下：

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 
## Linear regression model is initialized with weight w: -0.03, b: 0.00

現在，我們可以l利用自己構造的數據 trX 和 trY 來訓練這個線性模型，其中 trY 是 trX 的3倍。因此，權重 w 的值應該是 3。

我們使用簡單的梯度下降來作為優化器，均方誤差（MSE）作為損失值。如下：

model.compile(optimizer='sgd', loss='mse')

最后，我們使用 fit 函數來輸入數據。

model.fit(trX, trY, nb_epoch=200, verbose=1)

在經過訓練之后，我們再次打印權重：

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

##Linear regression model is trained to have weight w: 2.94, b: 0.08

正如你所看到的，在運行 200 輪之后，現在權重非常接近于 3。你可以將運行的輪數修改為區間 [100, 300] 之間，然后觀察輸出結構有什么變化。現在，你已經學會了利用很少的代碼來構建一個線性回歸模型，如果要構建一個相同的模型，在 TensorFlow 中需要用到更多的代碼。

5. 使用 Keras 保存和回復預訓練的模型

HDF5 二進制格式

一旦你利用Keras完成了訓練，你可以將你的網絡保存在HDF5里面。當然，你需要先安裝 h5py。HDF5 格式非常適合存儲大量的數字收，并從 numpy 處理這些數據。比如，我們可以輕松的將存儲在磁盤上的多TB數據集進行切片，就好像他們是真正的 numpy 數組一樣。你還可以將多個數據集存儲在單個文件中，遍歷他們或者查看 .shape 和 .dtype 屬性。

如果你需要信心，那么告訴你，NASA也在使用 HDF5 進行數據存儲。h5py 是python對HDF5 C API 的封裝。幾乎你可以用C在HDF5上面進行的任何操作都可以用python在h5py上面操作。

保存權重

如果你要保存訓練好的權重，那么你可以直接使用 save_weights 函數。

model.save_weights("my_model.h5")

載入預訓練權重

如果你想要載入以前訓練好的模型，那么你可以使用 load_weights 函數。

model.load_weights('my_model_weights.h5')

6. Keras API

如果對于簡單的模型和問題，那么序列模型是非常好的方式。但是如果你要構建一個現實世界中復雜的網絡，那么你就需要知道一些功能性的API，在很多流行的神經網絡中，我們都有一個最小的網絡結構，完整的模型是根據這些最小的模型進行疊加完成的。這些基礎的API可以讓你一層一層的構建模型。因此，你只需要很少的代碼就可以來構建一個完整的復雜神經網絡。

讓我們來看看它是如何工作的。首先，你需要導入一些包。

from keras.models import Model

現在，你需要去指定輸入數據，而不是在順序模型中，在最后的 fit 函數中輸入數據。這是序列模型和這些功能性的API之間最顯著的區別之一。我們使用 input() 函數來申明一個 1*28*28 的張量。

from keras.layers import Input
## First, define the vision modules

digit_input = Input(shape=(1, 28, 28))

現在，讓我們來利用API設計一個卷積層，我們需要指定要在在哪個層使用卷積網絡，具體代碼這樣操作：

x = Conv2D(64, (3, 3))(digit_input)
x = Conv2D(64, (3, 3))(x)
x = MaxPooling2D((2, 2))(x)
out = Flatten()(x)

最后，我們對于指定的輸入和輸出數據來構建一個模型。

vision_model = Model(digit_input, out)

當然，我們還需要指定損失函數，優化器等等。但這些和我們在序列模型中的操作一樣，你可以使用 fit 函數和 compile 函數來進行操作。

接下來，讓我們來構建一個vgg-16模型，這是一個很大很“老”的模型，但是由于它的簡潔性，它是一個很好的學習模型。

6.1 使用Keras API開發VGG卷積神經網絡

VGG：

VGG卷積神經網絡是牛津大學在2014年提出來的模型。當這個模型被提出時，由于它的簡潔性和實用性，馬上成為了當時最流行的卷積神經網絡模型。它在圖像分類和目標檢測任務中都表現出非常好的結果。在2014年的ILSVRC比賽中， VGG 在Top-5中取得了92.3%的正確率。 該模型有一些變種，其中最受歡迎的當然是 vgg-16，這是一個擁有16層的模型。你可以看到它需要維度是 224*224*3 的輸入數據。

Vgg 16 architecture

讓我們來寫一個獨立的函數來完整實現這個模型。

img_input = Input(shape=input_shape)
# Block 1
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input)
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)

# Block 2
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)

# Block 3
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)

# Block 4
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)

# Block 5
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)

x = Flatten(name='flatten')(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)

我們可以將這個完整的模型，命名為 vgg16.py。

在這個例子中，我們來運行 imageNet 數據集中的某一些數據來進行測試。具體代碼如下：

model = applications.VGG16(weights='imagenet')
img = image.load_img('cat.jpeg', target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
for results in decode_predictions(preds):
    for result in results:
        print('Probability %0.2f%% => [%s]' % (100*result[2], result[1]))

正如你在圖中看到的，模型會對圖片中的物體進行一個識別預測。

我們通過API構建了一個VGG模型，但是由于VGG是一個很簡單的模型，所以并沒有完全將API的能力開發出來。接下來，我們通過構建一個 SqueezeNet模型，來展示API的真正能力。

6.2 使用Keras API構建并運行SqueezeNet卷積神經網絡

SequeezeNet 是一個非常了不起的網絡架構，它的顯著點不在于對正確性有多少的提高，而是減少了計算量。當SequeezeNet的正確性和AlexNet接近時，但是ImageNet上面的預訓練模型的存儲量小于5 MB，這對于在現實世界中使用CNN是非常有利的。SqueezeNet模型引入了一個 Fire模型，它由交替的 Squeeze 和 Expand 模塊組成。

SqueezeNet fire module

現在，我們對 fire 模型進行多次復制，從而來構建完整的網絡模型，具體如下：

為了去構建這個網絡，我們將利用API的功能首先來構建一個單獨的 fire 模塊。

# Squeeze part of fire module with 1 * 1 convolutions, followed by Relu
x = Convolution2D(squeeze, (1, 1), padding='valid', name='fire2/squeeze1x1')(x)
x = Activation('relu', name='fire2/relu_squeeze1x1')(x)

#Expand part has two portions, left uses 1 * 1 convolutions and is called expand1x1 
left = Convolution2D(expand, (1, 1), padding='valid', name='fire2/expand1x1')(x)
left = Activation('relu', name='fire2/relu_expand1x1')(left)

#Right part uses 3 * 3 convolutions and is called expand3x3, both of these are follow#ed by Relu layer, Note that both receive x as input as designed. 
right = Convolution2D(expand, (3, 3), padding='same', name='fire2/expand3x3')(x)
right = Activation('relu', name='fire2/relu_expand3x3')(right)

# Final output of Fire Module is concatenation of left and right. 
x = concatenate([left, right], axis=3, name='fire2/concat')

為了重用這些代碼，我們可以將它們轉換成一個函數：

sq1x1 = "squeeze1x1"
exp1x1 = "expand1x1"
exp3x3 = "expand3x3"
relu = "relu_"
WEIGHTS_PATH = "https://github.com/rcmalli/keras-squeezenet/releases/download/v1.0/squeezenet_weights_tf_dim_ordering_tf_kernels.h5"

模塊化處理

sq1x1 = "squeeze1x1"
exp1x1 = "expand1x1"
exp3x3 = "expand3x3"
relu = "relu_"

def fire_module(x, fire_id, squeeze=16, expand=64):
   s_id = 'fire' + str(fire_id) + '/'
   x = Convolution2D(squeeze, (1, 1), padding='valid', name=s_id + sq1x1)(x)
   x = Activation('relu', name=s_id + relu + sq1x1)(x)

   left = Convolution2D(expand, (1, 1), padding='valid', name=s_id + exp1x1)(x)
   left = Activation('relu', name=s_id + relu + exp1x1)(left)

   right = Convolution2D(expand, (3, 3), padding='same', name=s_id + exp3x3)(x)
   right = Activation('relu', name=s_id + relu + exp3x3)(right)

   x = concatenate([left, right], axis=3, name=s_id + 'concat')
return x

現在，我們可以利用我們構建好的單獨的 fire 模塊，來構建完整的模型。

x = Convolution2D(64, (3, 3), strides=(2, 2), padding='valid', name='conv1')(img_input)
x = Activation('relu', name='relu_conv1')(x)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool1')(x)

x = fire_module(x, fire_id=2, squeeze=16, expand=64)
x = fire_module(x, fire_id=3, squeeze=16, expand=64)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool3')(x)

x = fire_module(x, fire_id=4, squeeze=32, expand=128)
x = fire_module(x, fire_id=5, squeeze=32, expand=128)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x)

x = fire_module(x, fire_id=6, squeeze=48, expand=192)
x = fire_module(x, fire_id=7, squeeze=48, expand=192)
x = fire_module(x, fire_id=8, squeeze=64, expand=256)
x = fire_module(x, fire_id=9, squeeze=64, expand=256)
x = Dropout(0.5, name='drop9')(x)

x = Convolution2D(classes, (1, 1), padding='valid', name='conv10')(x)
x = Activation('relu', name='relu_conv10')(x)
x = GlobalAveragePooling2D()(x)
out = Activation('softmax', name='loss')(x)

model = Model(inputs, out, name='squeezenet')

完整的網絡模型我們放置在 squeezenet.py 文件里。我們應該先下載 imageNet 預訓練模型，然后在我們自己的數據集上面進行訓練和測試。下面的代碼就是實現了這個功能：

import numpy as np
from keras_squeezenet import SqueezeNet
from keras.applications.imagenet_utils import preprocess_input, decode_predictions
from keras.preprocessing import image

model = SqueezeNet()

img = image.load_img('pexels-photo-280207.jpeg', target_size=(227, 227))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

preds = model.predict(x)
all_results = decode_predictions(preds)
for results in all_results:
  for result in results:
    print('Probability %0.2f%% => [%s]' % (100*result[2], result[1]))

對于相同的一幅圖預測，我們可以得到如下的預測概率。

至此，我們的Keras TensorFlow教程就結束了。希望可以幫到你 :-)

來源： cv-tricks

來自：http://www.jianshu.com/p/20585e3b6d02

本文由用戶 wsxxw2014 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1496586414412.html

Keras 深度學習 TensorFlow