基于Keras 的VGG16神经网络模型的Mnist数据集识别并使用GPU加速

这段话放在前面：之前一种用的Pytorch，用着还挺爽，感觉挺方便的，但是在最近文献的时候，很多实验都是基于Google 的Keras的，所以抽空学了下Keras，学了之后才发现Keras相比Pytorch而言，基于keras来写神经网络的话太方便，因为Keras高度的封装性，所以基于Keras来搭建神经网络很简单，在Keras下，可以用两种两种方法来搭建网络模型，分别是Sequential（）与Model（），对于网络结构简单，层次较少的模型使用sequential方法较好，只需不断地model.add即可，而后者更适用于网络模型复杂的情况，各有各的好处。

论GPU的重要性：在未使用GPU之前，一直用的CPU来训练，那速度，简直是龟速，一个VGG16花了10个小时，费时费力还闹心，然后今天将它加载在实验室的服务器上，只花了不到半个小时就好了。

下面给出代码：

 #!/usr/bin/env python 3.6
 #_*_coding:utf-8 _*_
 #@Time    :2019/11/9 15:19
 #@Author  :hujinzhou 
 #@FileName: My_frist_keras_moudel.py

 #@Software: PyCharm
 from keras.datasets import mnist
 from call_back import LossHistory
 from keras.utils.np_utils import to_categorical
 import numpy as np
 import cv2
 import pylab
 from keras.optimizers import Adam,SGD
 from matplotlib import pyplot as plt
 from keras.utils.vis_utils import plot_model
 from keras.layers import Dense, Activation, Flatten,Convolution2D,MaxPool2D,Dropout,BatchNormalization
 from keras.models import Sequential, Model
 from keras.layers.normalization import BatchNormalization
 np.random.seed(10)
 """下载mnist数据集,x_train训练集的数据，y_train训练集的标签，测试集依次类推"""
 (x_train,y_train),(x_test,y_test)=mnist.load_data()
 print(x_train.shape)
 print(len(x_train))
 print(y_train[0])
 "-----------------------------------------------------------------------------------------"
 """通过迭代的方法将训练集中的数据整形为32*32"""
 x_train4D = [cv2.cvtColor(cv2.resize(i,(32,32)), cv2.COLOR_GRAY2BGR) for i in x_train]
 x_train4D = np.concatenate([arr[np.newaxis] for arr in x_train4D]).astype('float32')

 x_test4D = [cv2.cvtColor(cv2.resize(i,(32,32)), cv2.COLOR_GRAY2BGR) for i in x_test]
 x_test4D = np.concatenate([arr[np.newaxis] for arr in x_test4D]).astype('float32')
 print(x_test4D.shape)
 print(x_train4D.shape)
 "------------------------------------------------------------------------------------"
 plt.imshow(x_train4D[0],cmap='gray')
 pylab.show()
 #x_train4D = x_train4D.astype('float32')
 #x_test4D = x_test4D.astype('float32')
 """归一化"""
 x_test4D_normalize=x_test4D/255
 x_train4D_normalize=x_train4D/255

 """one_hot encoding"""
 y_trainOnehot=to_categorical(y_train)
 y_testOnehot=to_categorical(y_test)

 """建立模型"""
 "--------------------------------------------------------------------------"
 model=Sequential()
 model.add(Convolution2D(filters=64,
                         kernel_size=(5,5),
                         padding='same',
                         input_shape=(32,32,3),

                         kernel_initializer='he_normal',
                         name='cnn1'

                         )
           )#output32*32*64
 model.add(BatchNormalization(axis=-1))
 model.add(Activation('relu'))

 # model.add(Convolution2D(filters=64,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn2'
 #                         )
 #           )#output32*32*64
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 model.add(MaxPool2D(pool_size=(2,2),strides=(2, 2)))#output16*16*64

 model.add(Convolution2D(filters=128,
                         kernel_size=(5,5),
                         padding='same',

                         kernel_initializer='he_normal',
                         name='cnn3'
                         )
           )#output16*16*128
 model.add(BatchNormalization(axis=-1))
 model.add(Activation('relu'))
 # model.add(Convolution2D(filters=128,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn4'
 #                         )
 #           )#output16*16*128
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 model.add(MaxPool2D(pool_size=(2,2),strides=(2, 2)))#output8*8*128

 model.add(Convolution2D(filters=256,
                         kernel_size=(5,5),
                         padding='same',

                         kernel_initializer='he_normal',
                         name='cnn5'
                         )
           )#output8*8*256
 model.add(BatchNormalization(axis=-1))
 model.add(Activation('relu'))
 # model.add(Convolution2D(filters=256,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn6'
 #                         )
 #           )#output8*8*256
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 # model.add(Convolution2D(filters=256,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn7'
 #                         )
 #           )#output8*8*256
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 model.add(MaxPool2D(pool_size=(2,2),strides=(2, 2)))#output4*4*256
 model.add(Convolution2D(filters=512,
                         kernel_size=(5,5),
                         padding='same',

                         kernel_initializer='he_normal',
                         name='cnn8'
                         )
           )#output4*4*512
 model.add(BatchNormalization(axis=-1))
 model.add(Activation('relu'))
 # model.add(Convolution2D(filters=512,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn9'
 #                         )
 #           )#output4*4*512
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 # model.add(Convolution2D(filters=512,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn10'
 #                         )
 #           )#output4*4*512
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 model.add(MaxPool2D(pool_size=(2,2),strides=(2, 2)))#output2*2*512
 model.add(Convolution2D(filters=512,
                         kernel_size=(5,5),
                         padding='same',

                         kernel_initializer='he_normal',
                         name='cnn11'
                         )
           )#output2*2*512
 model.add(BatchNormalization(axis=-1))
 model.add(Activation('relu'))
 # model.add(Convolution2D(filters=512,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn12'
 #                         )
 #           )#output2*2*512
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 # model.add(Convolution2D(filters=512,
 #                         kernel_size=(5,5),
 #                         padding='same',
 #
 #                         kernel_initializer='he_normal',
 #                         name='cnn13'
 #                         )
 #           )#output2*2*512
 # model.add(BatchNormalization(axis=-1))
 # model.add(Activation('relu'))
 model.add(MaxPool2D(pool_size=(2,2),strides=(2, 2)))#output1*1*512
 model.add(Dropout(0.5))
 model.add(Flatten())
 model.add(Dense(512))
 model.add(Activation('relu'))
 model.add(Dropout(0.5))
 model.add(Dense(10))
 model.add(Activation('softmax'))
 model.summary()
 plot_model(model,to_file='model4.png',show_shapes=True,show_layer_names=True)
 # for layer in model.layers:
 #     layer.trainable=False
 "--------------------------------------------------------------------------------"
 """训练模型"""
 adam=SGD(lr=0.1)
 model.compile(optimizer=adam,loss='categorical_crossentropy',metrics=['accuracy'])
 epoch=5
 batchsize=100
 # from keras.models import load_model
 # model = load_model('./My_keras_model_weight')
 history=model.fit(x=x_train4D_normalize,
           y=y_trainOnehot,
           epochs=epoch,
           batch_size=batchsize,
           validation_data=(x_test4D_normalize,y_testOnehot))

 """保存模型"""
 model.save('./My_keras_model2_weight')

 #model.load('./My_keras_model_weight')
 """画出损失曲线"""
 training_loss=history.history["loss"]
 train_acc=history.history["acc"]
 test_loss=history.history["val_loss"]
 test_acc=history.history["val_acc"]

 epoch_count=range(1,len(training_loss)+1)
 plt.plot(epoch_count,training_loss,'r--')
 plt.plot(epoch_count,test_loss,'b--')
 plt.plot(epoch_count,train_acc,'r--')
 plt.plot(epoch_count,test_acc,'b--')
 plt.legend(["Training_loss","Test_loss","train_acc","test_acc"])
 plt.xlabel("Epoch")
 plt.ylabel("loss")
 plt.show()

结果如下

最终的精度可以达到0.993左右

loss: 0.0261 - acc: 0.9932 - val_loss: 0.0246 - val_acc: 0.9933