摘要：此服務器搭載了塊顯卡，是目前頂級的深度學習計算卡，單卡售價萬，整機售價接近萬，天價核彈，有錢真好。此神經網絡參考了的圖像識別項目，采用了模型，增加了函數以擴充數據集。在天價核彈上會是個什么情況呢明天去試試看咯

在圖像識別的道路越走越遠?( ?? ω ?? )y

1.解釋一下

深夜腦子不是很清楚，大部分代碼參考了github……
此CNN圖像識別神經網絡的用途是之后用來評估NVIDIA-DGX服務器的性能，因此盡量擴大網絡的訓練時間。
此服務器搭載了8塊NVIDIA TESLA V100顯卡，是目前頂級的深度學習計算卡，單卡售價102萬RMB，整機售價接近1000萬，天價核彈，有錢真好。根據網上的信息，此服務器可在8小時內完成titanX 8天的工作量，頂級民用cpu數個月工作量。

此神經網絡參考了GITHUB的圖像識別項目，采用了DenseNet模型，增加了ImageDataGenerator函數以擴充數據集。打算后續通過改變常量epoch的值在各個平臺進行運算。

由于深夜倉促，尚未完成GPU的配置，因此把epoch設置為1先在CPU上跑跑試試，通過經驗估計在GTX1080上所需的時間。

2.數據集說明
該訓練采用cifar10數據集，包含60000張32x32像素的彩色圖片，這些圖片分屬不同的類別，如圖所示：

具體說明參考多倫多大學官網：http://www.cs.toronto.edu/~kr...

此網絡的目的是盡量精確地通過圖像識別將圖片分類到自己所屬類別當中。

下載數據集后直接改名后放入user.kerasdatasets文件夾中：

解壓后可發現，數據集分成6個batch，其中5個為訓練集，1個為測試集：

3.深夜倉促，直接上代碼：

導入第三方庫（numpy/keras/math）：

import numpy as np
import keras
import math
from keras.datasets import cifar10
from keras.preprocessing.image import ImageDataGenerator
from keras.layers.normalization import BatchNormalization
from keras.layers import Conv2D, Dense, Input, add, Activation, AveragePooling2D, GlobalAveragePooling2D
from keras.layers import Lambda, concatenate
from keras.initializers import he_normal
from keras.layers.merge import Concatenate
from keras.callbacks import LearningRateScheduler, TensorBoard, ModelCheckpoint
from keras.models import Model
from keras import optimizers
from keras import regularizers
from keras.utils.vis_utils import plot_model as plot

設置常量：

growth_rate        = 12 
depth              = 100
compression        = 0.5

img_rows, img_cols = 32, 32           #圖片尺寸
img_channels       = 3                #圖片色彩通道數，RGB
num_classes        = 10               #數據集類別數量
batch_size         = 64               #訓練batch所包含的example數量，只能是64或者32
epochs             = 1                #全數據集迭代次數，這里打算用cpu運算一次。
                                      #根據測試的顯卡和自己的要求改epoch數量
                                      #當epoch數量為250時識別效果較好，但這里不考慮效果

iterations         = 782              #每一次epoch的步數
weight_decay       = 0.0001

mean = [125.307, 122.95, 113.865]
std  = [62.9932, 62.0887, 66.7048]

根迭代次數改變scheduler，越迭代到后面該值越小，這意味著希望訓練過程中隨機因素逐步減小：

def scheduler(epoch):
    if epoch <= 100:
       return 0.1
    if epoch <= 180:
       return 0.01
    return 0.0005

定義一個DenseNet模型（github搬運工上線！）：

def densenet(img_input,classes_num):

    def bn_relu(x):
        x = BatchNormalization()(x)
        x = Activation("relu")(x)
        return x

    def bottleneck(x):
        channels = growth_rate * 4
        x = bn_relu(x)
        x = Conv2D(channels,kernel_size=(1,1),strides=(1,1),padding="same",kernel_initializer=he_normal(),kernel_regularizer=regularizers.l2(weight_decay),use_bias=False)(x)
        x = bn_relu(x)
        x = Conv2D(growth_rate,kernel_size=(3,3),strides=(1,1),padding="same",kernel_initializer=he_normal(),kernel_regularizer=regularizers.l2(weight_decay),use_bias=False)(x)
        return x

    def single(x):
        x = bn_relu(x)
        x = Conv2D(growth_rate,kernel_size=(3,3),strides=(1,1),padding="same",kernel_initializer=he_normal(),kernel_regularizer=regularizers.l2(weight_decay),use_bias=False)(x)
        return x

    def transition(x, inchannels):
        x = bn_relu(x)
        x = Conv2D(int(inchannels * compression),kernel_size=(1,1),strides=(1,1),padding="same",kernel_initializer=he_normal(),kernel_regularizer=regularizers.l2(weight_decay),use_bias=False)(x)
        x = AveragePooling2D((2,2), strides=(2, 2))(x)
        return x

    def dense_block(x,blocks,nchannels):
        concat = x
        for i in range(blocks):
            x = bottleneck(concat)
            concat = concatenate([x,concat], axis=-1)
            nchannels += growth_rate
        return concat, nchannels

    def dense_layer(x):
        return Dense(classes_num,activation="softmax",kernel_initializer=he_normal(),kernel_regularizer=regularizers.l2(weight_decay))(x)


    # nblocks = (depth - 4) // 3 
    nblocks = (depth - 4) // 6 
    nchannels = growth_rate * 2

    x = Conv2D(nchannels,kernel_size=(3,3),strides=(1,1),padding="same",kernel_initializer=he_normal(),kernel_regularizer=regularizers.l2(weight_decay),use_bias=False)(img_input)

    x, nchannels = dense_block(x,nblocks,nchannels)
    x = transition(x,nchannels)
    x, nchannels = dense_block(x,nblocks,nchannels)
    x = transition(x,nchannels)
    x, nchannels = dense_block(x,nblocks,nchannels)
    x = bn_relu(x)
    x = GlobalAveragePooling2D()(x)
    x = dense_layer(x)
    return x

載入數據集，并對標簽進行矩陣設置，改變數據集數據類型：

(x_train, y_train), (x_test, y_test) = cifar10.load_data()
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test  = keras.utils.to_categorical(y_test, num_classes)
x_train = x_train.astype("float32")
x_test  = x_test.astype("float32")

將數據集歸一化，方便訓練：

for i in range(3):
    x_train[:,:,:,i] = (x_train[:,:,:,i] - mean[i]) / std[i]
    x_test[:,:,:,i] = (x_test[:,:,:,i] - mean[i]) / std[i]

定義模型并打印簡圖，shell中打印的模型圖太長了，就不貼了，長得一逼，需要看的話直接在shell中print summary就可以：

img_input = Input(shape=(img_rows,img_cols,img_channels))
output    = densenet(img_input,num_classes)
model     = Model(img_input, output)
# model.load_weights("ckpt.h5")
print(model.summary())
plot(model, to_file="cnn_model.png",show_shapes=True)

這個模型的參數情況如下圖所示。圖像識別的問題就是這點麻煩，參數太多了，大批求導，怪不得天價核彈這么貴還這么有市場：

本質上還是一個分類問題，使用交叉熵作為損失函數，定義輸出結果的好壞：

sgd = optimizers.SGD(lr=.1, momentum=0.9, nesterov=True)
model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"])

設定回饋：

tb_cb     = TensorBoard(log_dir="./densenet/", histogram_freq=0)
change_lr = LearningRateScheduler(scheduler)
ckpt      = ModelCheckpoint("./ckpt.h5", save_best_only=False, mode="auto", period=10)
cbks      = [change_lr,tb_cb,ckpt]

添加上數據集擴充功能，對圖像做一些彈性變換，比如水平翻轉，垂直翻轉，旋轉：

print("Using real-time data augmentation.")
datagen   = ImageDataGenerator(horizontal_flip=True,width_shift_range=0.125,height_shift_range=0.125,fill_mode="constant",cval=0.)

datagen.fit(x_train)

訓練模型：

model.fit_generator(datagen.flow(x_train, y_train,batch_size=batch_size), steps_per_epoch=iterations, epochs=epochs, callbacks=cbks,validation_data=(x_test, y_test))
model.save("densenet.h5")

訓練過程cpu（i7-7820hk）滿載：

在cpu上進行一次訓練需要將近10000秒：

根據之前手寫數字文本識別模型的經驗（cpu需要12秒，gtx1080只需要0.47秒，gpu是cpu性能的25.72倍），把本程序的epoch改到2500，則gtx1080需要大概270小時。

在v100天價核彈上會是個什么情況呢？明天去試試看咯！