Lenet神经网络实现

手写字体识别模型LeNet5诞生于1994年，是最早的卷积神经网络之一。LeNet5通过巧妙的设计，利用卷积、参数共享、池化等操作提取特征，避免了大量的计算成本，最后再使用全连接神经网络进行分类识别，这个网络也是最近大量神经网络架构的起点。虽然现在看来Lenet基本实际用处不大，而且架构现在基本也没人用了，但是可以作为神经网络架构的一个很好的入门基础。

Lenet神经网络架构图如下：

LeNet5由7层CNN（不包含输入层）组成，上图中输入的原始图像大小是32×32像素。下面分别介绍每一层的含义。

• input: 在原始的架构中，神经网络的输入是一张 32*32的灰度图像，不过这里我们选用的dataset是cifar10，是RGB图像，也就是 （32*32*3），3表示通道是3通道，即RGB三颜色。
• conv1: 第一层是一个卷积层啦，卷积核(kernel size)大小 5*5,步长(stride)为 1 ，不进行padding，所以刚才的输入图像，经过这层后会输出6张 28*28 的特征图(feature map)。
• maxpooling2: 接下来是一个降采样层，用的是maxpooling哦，stride为 2 , kernel size为 2*2 ，恩，所以很明显subsampling之后，输出6张 14*14的feature map。
• conv3: 第三层又是一个卷积层，kernel size和stride均与第一层相同，不过最后要输出16张feature map。
• maxpooling4:第四层，恩，又是一个maxpooling。
• fc5：对，第五层开始就是全连接(fully connected layer)层了，把第四层的feature map摊平，然后做最直白的举证运算，输入是120个结点。
• fc6：输出是84个结点。
• output：我们的dataset是cifar10,刚好也是10类哦，所以就是接一个softmax分成10类。

 下面是基于Keras的简单代码实现

  

   

    

     

    
    

     

      import keras
     
    
   

    

     

    
    

     

      import numpy as np
     
    
   

    

     

    
    

     

      from keras import optimizers
     
    
   

    

     

    
    

     

      from keras.datasets import cifar10
     
    
   

    

     

    
    

     

      from keras.models import Sequential
     
    
   

    

     

    
    

     

      from keras.layers import Conv2D, Dense, Flatten, MaxPooling2D
     
    
   

    

     

    
    

     

      from keras.callbacks import LearningRateScheduler, TensorBoard
     
    
   

    

     

    
    

     

      from keras.preprocessing.image import ImageDataGenerator
     
    
   

    

     

    
    

     

      from keras.regularizers import l2
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      batch_size    = 128
     
    
   

    

     

    
    

     

      epochs        = 200
     
    
   

    

     

    
    

     

      iterations    = 391
     
    
   

    

     

    
    

     

      num_classes   = 10
     
    
   

    

     

    
    

     

      weight_decay  = 0.0001
     
    
   

    

     

    
    

     

      mean          = [125.307, 122.95, 113.865]
     
    
   

    

     

    
    

     

      std           = [62.9932, 62.0887, 66.7048]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def build_model():
     
    
   

    

     

    
    

     

          model = Sequential()
     
    
   

    

     

    
    

     

          model.add(Conv2D(6, (5, 5), padding='valid', activation = 'relu', kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay), input_shape=(32,32,3)))
     
    
   

    

     

    
    

     

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

    

     

    
    

     

          model.add(Conv2D(16, (5, 5), padding='valid', activation = 'relu', kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay)))
     
    
   

    

     

    
    

     

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

    

     

    
    

     

          model.add(Flatten())
     
    
   

    

     

    
    

     

          model.add(Dense(120, activation = 'relu', kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay) ))
     
    
   

    

     

    
    

     

          model.add(Dense(84, activation = 'relu', kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay) ))
     
    
   

    

     

    
    

     

          model.add(Dense(10, activation = 'softmax', kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay) ))
     
    
   

    

     

    
    

     

          sgd = optimizers.SGD(lr=.1, momentum=0.9, nesterov=True)
     
    
   

    

     

    
    

     

          model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
     
    
   

    

     

    
    

     
    return model
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def scheduler(epoch):
     
    
   

    

     

    
    

     
    if epoch < 100:
     
    
   

    

     

    
    

     
        return 0.01
     
    
   

    

     

    
    

     
    if epoch < 150:
     
    
   

    

     

    
    

     
        return 0.005
     
    
   

    

     

    
    

     
    return 0.001
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == '__main__':
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    # load data
     
    
   

    

     

    
    

     

          (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')
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    # data preprocessing [raw - mean / std]
     
    
   

    

     

    
    

     
    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]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    # build network
     
    
   

    

     

    
    

     

          model = build_model()
     
    
   

    

     

    
    

     
    print(model.summary())
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    # set callback
     
    
   

    

     

    
    

     

          tb_cb = TensorBoard(log_dir='./lenet_dp_da_wd', histogram_freq=0)
     
    
   

    

     

    
    

     

          change_lr = LearningRateScheduler(scheduler)
     
    
   

    

     

    
    

     

          cbks = [change_lr,tb_cb]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    # using real-time data augmentation
     
    
   

    

     

    
    

     
    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)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    # start 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))
     
    
   

    

     

    
    

     
    # save model
     
    
   

    

     

    
    

     

          model.save('lenet_dp_da_wd.h5')
     
    
  
 

文章来源: blog.csdn.net，作者：小小谢先生，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/xiewenrui1996/article/details/103016474