在統(tǒng)計學和機器學習領(lǐng)域，集成方法（ensemble method）使用多種學習算法以獲得更好的預測性能（相比單獨使用其中任何一種算法）。和統(tǒng)計力學中的統(tǒng)計集成（通常是無窮集合）不同，一個機器學習集成僅由一個離散的可選模型的離散集合組成，但通常擁有更加靈活的結(jié)構(gòu) [1]。

使用集成的主要動機是在發(fā)現(xiàn)新的假設(shè)，該假設(shè)不一定存在于構(gòu)成模型的假設(shè)空間中。從經(jīng)驗的角度看，當模型具有顯著的多樣性時，集成方法傾向于得到更好的結(jié)果 [2]。

動機

在一個大型機器學習競賽的比賽結(jié)果中，最好的結(jié)果通常是由模型的集成而不是由單個模型得到的。例如，ILSVRC2015 的得分最高的單個模型架構(gòu)得到了第 13 名的成績。而第 1 到 12 名都使用了不同類型的模型集成。

我目前并沒有發(fā)現(xiàn)有任何的教程或文檔教人們?nèi)绾卧谝粋€集成中使用多種模型，因此我決定自己做一個這方面的使用向?qū)А?/p>

我將使用 Keras，具體來說是它的功能性 API，以從相對知名的論文中重建三種小型 CNN（相較于 ResNet50、Inception 等而言）。我將在 CIFAR-10 數(shù)據(jù)集上獨立地訓練每個模型 [3]。然后使用測試集評估每個模型。之后，我會將所有三個模型組成一個集合，并進行評估。通常按照預期，這個集成相比單獨使用其中任何一個模型，在測試集上能獲得更好的性能。

有很多種不同類型的集成：其中一種是堆疊（stacking）。這種類型更加通用并且在理論上可以表征任何其它的集成技術(shù)。堆疊涉及訓練一個學習算法結(jié)合多種其它學習算法的預測 [1]。對于這個示例，我將使用堆疊的最簡單的一種形式，其中涉及對集成的模型輸出取平均值。由于取平均過程不包含任何參數(shù)，這種集成不需要訓練（只需要訓練模型）。

本文介紹的集成的簡要結(jié)構(gòu)

準備數(shù)據(jù)

首先，導入類和函數(shù)：

1. fromkeras.modelsimportModel,Input

2. fromkeras.layersimportConv2D,MaxPooling2D,GlobalAveragePooling2D,Activation,Average,Dropout

3. fromkeras.utilsimportto_categorical

4. fromkeras.lossesimportcategorical_crossentropy

5. fromkeras.callbacksimportModelCheckpoint,TensorBoard

6. fromkeras.optimizersimportAdam

7. fromkeras.datasetsimportcifar10

9. importnumpyasnp

我使用的數(shù)據(jù)集是 CIFAR-10，因為很容易找到在這個數(shù)據(jù)集上工作得很好的架構(gòu)的相關(guān)論文。使用一個流行的數(shù)據(jù)集還可以令這個案例容易復現(xiàn)。

以下是數(shù)據(jù)集的導入代碼。訓練數(shù)據(jù)和測試數(shù)據(jù)都已經(jīng)歸一化。訓練標簽向量被轉(zhuǎn)換成一個 one-hot 矩陣。不需要轉(zhuǎn)換測試標簽向量，因為它不會在訓練中使用。

1. (x_train, y_train), (x_test, y_test) = cifar10.load_data()

2. x_train = x_train /255.

3. x_test = x_test /255.

4. y_train = to_categorical(y_train, num_classes=10)

數(shù)據(jù)集由 6 萬張 10 個類別的 32x32 的 RGB 圖像組成。其中 5 萬張用于訓練/驗證，其它 1 萬張用于測試。

1. print('x_train shape: {} |

2. y_train shape: {}\nx_test shape : {} |

3. y_test shape : {}'.format(x_train.shape, y_train.shape, x_test.shape, y_test.shape))

>>> x_train shape: (50000, 32, 32, 3) | y_train shape: (50000, 10)

>>> x_test shape : (10000, 32, 32, 3) | y_test shape : (10000, 1)

由于三個模型使用的是相同類型的數(shù)據(jù)，定義單個用于所有模型的輸入層是合理的。

1. input_shape = x_train[0,:,:,:].shape

2. model_input =Input(shape=input_shape)

第一個模型：ConvPool-CNN-C

第一個將要訓練的模型是 ConvPool-CNN-C[4]。它使用了常見的模式，即每個卷積層連接一個池化層。唯一一個對一些人來說可能不熟悉的細節(jié)是其最后的層。它使用的并不是多個全連接層，而是一個全局平均池化層（global average pooling layer）。

以下是關(guān)于全局池化層的工作方式的簡介。最后的卷積層 Conv2D(10，(1，1)) 輸出和 10 個輸出類別相關(guān)的 10 個特征圖。然后 GlobalAveragePooling2D() 層計算這 10 個特征圖的空間平均（spatial average），意味著其輸出是一個維度為 10 的向量。之后，對這個向量應用一個 softmax 激活函數(shù)。如你所見，這個方法在某種程度上類似于在模型的頂部使用全連接層?？梢栽谶@篇論文 [5] 中查看更多關(guān)于全局池化層的內(nèi)容。

重要事項：不要對最后的 Conv2D(10，(1，1)) 層的輸出直接應用激活函數(shù)，因為這個層的輸出需要先輸入 GlobalAveragePooling2D()。

1. defconv_pool_cnn(model_input):

3. x =Conv2D(96, kernel_size=(3,3), activation='relu', padding = 'same')(model_input)

4. x =Conv2D(96, (3,3), activation='relu', padding ='same')(x)

5. x =Conv2D(96, (3,3), activation='relu', padding ='same')(x)

6. x =MaxPooling2D(pool_size=(3,3), strides =2)(x)

7. x =Conv2D(192, (3,3), activation='relu', padding ='same')(x)

8. x =Conv2D(192, (3,3), activation='relu', padding ='same')(x)

9. x =Conv2D(192, (3,3), activation='relu', padding ='same')(x)

10. x =MaxPooling2D(pool_size=(3,3), strides =2)(x)

11. x =Conv2D(192, (3,3), activation='relu', padding ='same')(x)

12. x =Conv2D(192, (1,1), activation='relu')(x)

13. x =Conv2D(10, (1,1))(x)

14. x =GlobalAveragePooling2D()(x)

15. x =Activation(activation='softmax')(x)

17. model =Model(model_input, x, name='conv_pool_cnn')

19. returnmodel

用具體例子解釋該模型

1. conv_pool_cnn_model = conv_pool_cnn(model_input)

為了簡單起見，每個模型都使用相同的參數(shù)進行編譯和訓練。其中，epoch 數(shù)等于 20、批尺寸等于 32（每個 epoch 進行 1250 次迭代）的參數(shù)設(shè)置能使三個模型都找到局部極小值。隨機選擇訓練集的 20% 作為驗證集。

1. defcompile_and_train(model, num_epochs):

3. model.compile(loss=categorical_crossentropy, optimizer=Adam(), metrics=['acc'])

4. filepath ='weights/'+ model.name +'.{epoch:02d}-{loss:.2f}.hdf5'

5. checkpoint =ModelCheckpoint(filepath, monitor='loss', verbose=0, save_weights_only=True, save_best_only=True, mode='auto', period=1)

6. tensor_board =TensorBoard(log_dir='logs/', histogram_freq=0, batch_size=32)

7. history = model.fit(x=x_train, y=y_train, batch_size=32, epochs=num_epochs, verbose=1, callbacks=[checkpoint, tensor_board], validation_split=0.2)

8. returnhistory

大約需要每 epoch1 分鐘的時間訓練這個（以及下一個）模型，我們使用了單個 Tesla K80 GPU。如果你使用的是 CPU，可能需要花較多的時間。

1. _ = compile_and_train(conv_pool_cnn_model, num_epochs=20)

該模型達到了大約 79% 的驗證準確率。

ConvPool-CNN-C 驗證準確率和損失

通過計算測試集的誤差率對模型進行評估。

1. defevaluate_error(model):

2. pred=model.predict(x_test,batch_size=32)

3. pred=np.argmax(pred,axis=1)

4. pred=np.expand_dims(pred,axis=1)# make same shape as y_test

5. error=np.sum(np.not_equal(pred,y_test))/y_test.shape[0]

7. returnerror

8. evaluate_error(conv_pool_cnn_model)

>>> 0.2414

第二個模型：ALL-CNN-C

下一個模型，ALL-CNN-C，來自同一篇論文 [4]。這個模型和上一個很類似。唯一的區(qū)別是用步幅為 2 的卷積層取代了最大池化層。再次，需要注意，在 Conv2D(10，(1，1)) 層之后不要立刻應用激活函數(shù)，如果在該層之后應用了 ReLU 激活函數(shù)，會導致訓練失敗。

1. defall_cnn(model_input):

3. x=Conv2D(96,kernel_size=(3,3),activation='relu',padding='same')(model_input)

4. x=Conv2D(96,(3,3),activation='relu',padding='same')(x)

5. x=Conv2D(96,(3,3),activation='relu',padding='same',strides=2)(x)

6. x=Conv2D(192,(3,3),activation='relu',padding='same')(x)

7. x=Conv2D(192,(3,3),activation='relu',padding='same')(x)

8. x=Conv2D(192,(3,3),activation='relu',padding='same',strides=2)(x)

9. x=Conv2D(192,(3,3),activation='relu',padding='same')(x)

10. x=Conv2D(192,(1,1),activation='relu')(x)

11. x=Conv2D(10,(1,1))(x)

12. x=GlobalAveragePooling2D()(x)

13. x=Activation(activation='softmax')(x)

15. model=Model(model_input,x,name='all_cnn')

17. returnmodel

18. all_cnn_model=all_cnn(model_input)

19. _=compile_and_train(all_cnn_model,num_epochs=20)

該模型收斂到了大約 75% 的驗證準確率。

ConvPool-CNN-C 驗證準確率和損失

由于這兩個模型很相似，誤差率差別不大。

1. evaluate_error(all_cnn_model)

>>> 0.26090000000000002

第三個模型：Network In Network CNN

第三個 CNN 是 Network In Network CNN[5]。這個模型來自引入了全局池化層的論文。它比之前的兩個模型更小，因此其訓練速度更快。（再提醒一次，不要在最后的卷積層之后使用 ReLU 函數(shù)?。?/p>

相較于在 MLP 卷積層中使用多層感知機，我使用的是 1x1 卷積核的卷積層。從而需要優(yōu)化的參數(shù)變得更少，訓練速度進一步加快，并且還獲得了更好的結(jié)果（當使用全連接層的時候無法獲得高于 50% 的驗證準確率）。該論文中稱，MLP 卷積層中應用的函數(shù)等價于在普通卷積層上的級聯(lián)跨通道參數(shù)化池化（cascaded cross channel parametric pooling），其中依次等價于一個 1x1 卷積核的卷積層。如果這個結(jié)論有錯誤，歡迎指正。

1. defnin_cnn(model_input):

3. #mlpconv block 1

4. x=Conv2D(32,(5,5),activation='relu',padding='valid')(model_input)

5. x=Conv2D(32,(1,1),activation='relu')(x)

6. x=Conv2D(32,(1,1),activation='relu')(x)

7. x=MaxPooling2D((2,2))(x)

8. x=Dropout(0.5)(x)

10. #mlpconv block2

11. x=Conv2D(64,(3,3),activation='relu',padding='valid')(x)

12. x=Conv2D(64,(1,1),activation='relu')(x)

13. x=Conv2D(64,(1,1),activation='relu')(x)

14. x=MaxPooling2D((2,2))(x)

15. x=Dropout(0.5)(x)

17. #mlpconv block3

18. x=Conv2D(128,(3,3),activation='relu',padding='valid')(x)

19. x=Conv2D(32,(1,1),activation='relu')(x)

20. x=Conv2D(10,(1,1))(x)

22. x=GlobalAveragePooling2D()(x)

23. x=Activation(activation='softmax')(x)

25. model=Model(model_input,x,name='nin_cnn')

27. returnmodel

28. nin_cnn_model=nin_cnn(model_input)

這個模型的訓練速度快得多，在我的機器上每個 epoch 只要 15 秒就能完成。

1. _=compile_and_train(nin_cnn_model,num_epochs=20)

該模型達到了大約 65% 的驗證準確率。

NIN-CNN 驗證準確率和損失

這個模型比之前的兩個模型簡單得多，因此其誤差率要高一點。

1. evaluate_error(nin_cnn_model)

>>> 0. 0.31640000000000001

三個模型的集成

現(xiàn)在將這三個模型組合成一個集成。

所有三個模型都被重新實例化并加載了最佳的已保存權(quán)重。

1. conv_pool_cnn_model=conv_pool_cnn(model_input)

2. all_cnn_model=all_cnn(model_input)

3. nin_cnn_model=nin_cnn(model_input)

5. conv_pool_cnn_model.load_weights('weights/conv_pool_cnn.29-0.10.hdf5')

6. all_cnn_model.load_weights('weights/all_cnn.30-0.08.hdf5')

7. nin_cnn_model.load_weights('weights/nin_cnn.30-0.93.hdf5')

9. models=[conv_pool_cnn_model,all_cnn_model,nin_cnn_model]

集成模型的定義是很直接的。它使用了所有模型共享的輸入層。在頂部的層中，該集成通過使用 Average() 合并層計算三個模型輸出的平均值。

1. defensemble(models,model_input):

3. outputs=[model.outputs[0]formodelinmodels]

4. y=Average()(outputs)

6. model=Model(model_input,y,name='ensemble')

8. returnmodel

9. ensemble_model=ensemble(models,model_input)

不出所料，相比于任何單一模型，集成有著更低的誤差率。

1. evaluate_error(ensemble_model)

>>> 0.2049

其他可能的集成

為了完整性，我們可以查看由兩個模型組合組成的集成的性能。相比于單一模型，前者有更低的誤差率。

1. pair_A=[conv_pool_cnn_model,all_cnn_model]

2. pair_B=[conv_pool_cnn_model,nin_cnn_model]

3. pair_C=[all_cnn_model,nin_cnn_model]

4. pair_A_ensemble_model=ensemble(pair_A,model_input)

5. evaluate_error(pair_A_ensemble_model)

>>> 0.21199999999999999

1. pair_B_ensemble_model=ensemble(pair_B,model_input)

2. evaluate_error(pair_B_ensemble_model)

>>> 0.22819999999999999

1. pair_C_ensemble_model=ensemble(pair_C,model_input)

2. evaluate_error(pair_C_ensemble_model)

>>>0.2447

結(jié)論

重申一下介紹中的內(nèi)容：每個模型有其自身的缺陷。使用集成背后的原因是通過堆疊表征了關(guān)于數(shù)據(jù)的不同假設(shè)的不同模型，我們可以找到一個更好的假設(shè)，它不在一個從其構(gòu)建集成的模型的假設(shè)空間之中。

與在大多數(shù)情況下使用單個模型相比，使用一個非?；A(chǔ)的集成實現(xiàn)了更低的誤差率。這證明了集成的有效性。

當然，在使用集成處理你的機器學習任務時，需要牢記一些實際的考慮。由于集成意味著同時堆棧多個模型，這也意味著輸入數(shù)據(jù)需要前向傳播到每個模型。這增加了需要被執(zhí)行的計算量，以及最終的評估（預測）時間。如果你在研究或 Kaggle 競賽中使用集成，增加的評估時間并不重要，但是在設(shè)計一個商業(yè)化產(chǎn)品時卻非常關(guān)鍵。另一個考慮是最后的模型增加的大小，它會再次成為商業(yè)化產(chǎn)品中集成使用的限制性因素。

參考文獻

1. Ensemble Learning. (n.d.). In Wikipedia. Retrieved December 12, 2017, from https://en.wikipedia.org/wiki/Ensemble_learning

2. D. Opitz and R. Maclin (1999)「Popular Ensemble Methods: An Empirical Study」, Volume 11, pages 169–198 (http://jair.org/papers/paper614.html)

3. Learning Multiple Layers of Features from Tiny Images, Alex Krizhevsky, 2009.

4. Striving for Simplicity: The All Convolutional Net：arXiv:1412.6806v3 [cs.LG]

5. Network In Network：arXiv:1312.4400v3 [cs.NE]