devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【神经网络】(5) 卷积神经网络（ResNet50），案例：艺术画作10分类，附数据集_使用resnet50实现10种植物分类使用迁移学习构建网络

作者：不正经 | 2024-02-16 11:38:53

赞

踩

使用resnet50实现10种植物分类使用迁移学习构建网络

各位同学好，今天和大家分享一下TensorFlow2.0中如何构建卷积神经网络ResNet-50，案例内容：现在收集了10位艺术大师的画作，采用卷积神经网络判断某一幅画是哪位大师画的。

数据集：百度网盘 请输入提取码

提取码： 2h5x

1. 数据加载

在文件夹中将图片按照训练集、验证集、测试集划分好之后，使用tf.keras.preprocessing.image_dataset_from_directory()从文件夹中读取数据。指定参数label_model，'int'代表目标值y是数值类型，即0, 1, 2, 3等；'categorical'代表onehot类型，对应索引的值为1，如图像属于第二类则表示为0,1,0,0,0；'binary'代表二分类。

  1. import tensorflow as tf
  2. from tensorflow import keras 
  3. from tensorflow.keras  import Model, optimizers, layers
  4.  
  5. #（1）获取数据集
  6. def get_data(height, width, batchsz):
  7.  
  8.     filepath1 = 'C:/Users/admin/.spyder-py3/test/数据集/艺术作品/new_data/train'
  9.     train_ds = tf.keras.preprocessing.image_dataset_from_directory(
  10.         filepath1,
  11.         label_mode='categorical',  # 做one-hot编码 ，正数形式"int", 多分类"categorical", 二分类"binary", or None
  12.         seed=123,
  13.         image_size=(height, width),  # resize图片大小
  14.         batch_size=batchsz)
  15.     
  16.     # 加载验证集数据
  17.     filepath2 = 'C:/Users/admin/.spyder-py3/test/数据集/艺术作品/new_data/val'
  18.     val_ds = tf.keras.preprocessing.image_dataset_from_directory(
  19.         filepath2,
  20.         label_mode='categorical',
  21.         seed=123,
  22.         image_size=(height, width),
  23.         batch_size=batchsz)
  24.     
  25.     # 加载测试集数据
  26.     filepath3 = 'C:/Users/admin/.spyder-py3/test/数据集/艺术作品/new_data/test'
  27.     test_ds = tf.keras.preprocessing.image_dataset_from_directory(
  28.         filepath3,
  29.         label_mode='categorical',
  30.         seed=123,
  31.         image_size=(height, width),
  32.         batch_size=batchsz) 
  33.     
  34.     return(train_ds, val_ds, test_ds)
  35.  
  36. # 从文件夹中获取图像
  37. train_ds, val_ds, test_ds = get_data(224, 224, 32)  #指定读入图片的宽度高度(和网络输入层大小相同)，每个batch的大小
  38.  
  39. # 类别名称
  40. class_names = train_ds.class_names
  41. print('类别有：',class_names)
  42. # 类别有： ['Alfred_Sisley', 'Edgar_Degas', 'Francisco_Goya', 'Marc_Chagall', 'Pablo_Picasso', 'Paul_Gauguin', 'Peter_Paul_Rubens', 'Rembrandt', 'Titian', 'Vincent_van_Gogh']

2. 数据预处理

定义预先处理函数，将x的每个像素值从[0,255]映射到[-1,1]，映射到[0,1]也没问题。使用.map()将数据集中的所有数据放入函数进行处理，对训练数据打乱顺序.shuffle()，但不改变x和y之间的对应关系。

  1. #（2）数据预处理
  2. def processing(x,y):
  3.     x = 2 * tf.cast(x, tf.float32)/255.0 - 1  # 将每个像素值从[0,255]映射到[-1,1]
  4.     y = tf.cast(y, tf.int32)
  5.     return(x,y)
  6. # 构造数据集
  7. train_ds = train_ds.map(processing).shuffle(10000) # 训练数据
  8. val_ds = val_ds.map(processing) # 验证数据
  9. test_ds = test_ds.map(processing) # 测试数据
  10.  
  11. # 查看数据是否处理正确
  12. sample = next(iter(train_ds)) #构造迭代器，每次运行取出一个batch数据
  13. print('x_batch.shape:', sample[0].shape, 'y_batch.shape', sample[1].shape)
  14. # x_batch.shape: (32, 128, 128, 3) y_batch.shape (32, 10)
  15.  
  16. # 绘图展示
  17. import matplotlib.pyplot as plt
  18. for i in range(15):
  19.     plt.subplot(3,5,i+1)
  20.     plt.imshow(sample[0][i]) #sample存放的是一个batch的图像
  21.     plt.xticks([]) #不显示坐标刻度
  22.     plt.yticks([])
  23. plt.show()

经过处理后的图像如下：

3. 网络构建

接下来到最重要的一步了，构建ResNet50网络，网络的结构图如下：resnet50结构图 ，可以根据这个结构图慢慢敲代码，我这里使用函数的方法构建ResNet50网络。ResNet的原理解释如下：六、ResNet网络详细解析（超详细哦）

  1. #（3）构建RNN-RESNET
  2. # conv_block部分
  3. def conv_block(input_tensor, filters, stride):
  4.     # 分别接收卷积核的个数，即特征图的个数
  5.     filter1, filter2, filter3 = filters
  6.  
  7.     # ==1== 正向传播部分
  8.     # 卷积层
  9.     x = layers.Conv2D(filter1, kernel_size=(1,1), strides=stride)(input_tensor)  
  10.     # BN层
  11.     x = layers.BatchNormalization()(x) 
  12.     # 激活层
  13.     x = layers.Activation('relu')(x)  
  14.     
  15.     # 卷积层
  16.     x = layers.Conv2D(filter2, kernel_size=(3,3), strides=(1,1), padding='same')(x)
  17.     # BN层
  18.     x = layers.BatchNormalization()(x) 
  19.     # 激活函数
  20.     x = layers.Activation('relu')(x) 
  21.     
  22.     # 卷积层
  23.     x = layers.Conv2D(filter3, kernel_size=(1,1), strides=(1,1))(x) 
  24.     # BN层
  25.     x = layers.BatchNormalization()(x) 
  26.     
  27.     # ==2== shotcut部分
  28.     # 卷积层
  29.     shotcut = layers.Conv2D(filter3, kernel_size=(1,1), strides=stride)(input_tensor) 
  30.     # BN层
  31.     shotcut = layers.BatchNormalization()(shotcut) 
  32.     
  33.     # ==3== 两部分组合
  34.     x = layers.add([x, shotcut]) 
  35.     # 激活函数
  36.     x = layers.Activation('relu')(x) 
  37.     
  38.     # 返回结果
  39.     return x
  40.  
  41.  
  42. # identity_block部分
  43. def iden_block(input_tensor, filters):
  44.     # 接收卷积核的个数
  45.     filter1, filter2, filter3 = filters
  46.   
  47.     # ==1== 正向传播
  48.     # 卷积层
  49.     x = layers.Conv2D(filter1, kernel_size=(1,1), strides=(1,1))(input_tensor)  
  50.     # BN层
  51.     x = layers.BatchNormalization()(x) 
  52.     # 激活函数
  53.     x = layers.Activation('relu')(x) 
  54.     
  55.     # 卷积层
  56.     x = layers.Conv2D(filter2, kernel_size=(3,3), strides=(1,1), padding='same')(x) 
  57.     # BN层
  58.     x = layers.BatchNormalization()(x) 
  59.     # 激活函数
  60.     x = layers.Activation('relu')(x) 
  61.     
  62.     # 卷积层
  63.     x = layers.Conv2D(filter3, kernel_size=(1,1), strides=(1,1))(x) 
  64.     # BN层
  65.     x = layers.BatchNormalization()(x) 
  66.     
  67.     # ==2== 结合
  68.     x = layers.add([x, input_tensor])
  69.     # 激活函数
  70.     x = layers.Activation('relu')(x) 
  71.     
  72.     return x
  73.  
  74.  
  75. # 本体
  76. def resnet50(input_shape=[224,224,3], output_shape=10):
  77.     # 输入层
  78.     inputs = keras.Input(shape=input_shape)  #[224,224,3]
  79.     # padding，上下左右各三层
  80.     x = layers.ZeroPadding2D((3,3))(inputs)
  81.     
  82.     # 卷积层
  83.     x = layers.Conv2D(64, kernel_size=(7,7), strides=(2,2))(x) #[112,112,64]
  84.     # BN层
  85.     x = layers.BatchNormalization()(x)  #[112,112,64]
  86.     # relu层
  87.     x = layers.Activation('relu')(x)  #[112,112,64]
  88.     # 池化层
  89.     x = layers.MaxPool2D(pool_size=(3,3), strides=(2,2))(x)  #[55,55,64]
  90.     
  91.     # block1
  92.     x = conv_block(x, [64, 64, 256], stride=(1,1)) #[55,55,256] 
  93.     x = iden_block(x, [64, 64, 256]) #[55,55,256]
  94.     x = iden_block(x, [64, 64, 256]) #[55,55,256]    
  95.     
  96.     # block2
  97.     x = conv_block(x, [128, 128, 256], stride=(2,2)) #[28,28,512]
  98.     x = iden_block(x, [128, 128, 256]) #[28,28,512]   
  99.     x = iden_block(x, [128, 128, 256]) #[28,28,512]
  100.     x = iden_block(x, [128, 128, 256]) #[28,28,512]
  101.     
  102.     # block3
  103.     x = conv_block(x, [256, 256, 1024], stride=(2,2)) #[14,14,1024]
  104.     x = iden_block(x, [256, 256, 1024]) #[14,14,1024] 
  105.     x = iden_block(x, [256, 256, 1024]) #[14,14,1024]
  106.     x = iden_block(x, [256, 256, 1024]) #[14,14,1024]
  107.     x = iden_block(x, [256, 256, 1024]) #[14,14,1024]
  108.     x = iden_block(x, [256, 256, 1024]) #[14,14,1024]
  109.     
  110.     # block4
  111.     x = conv_block(x, [512, 512, 2048], stride=(2,2)) #[7,7,2048]
  112.     x = iden_block(x, [512, 512, 2048]) #[7,7,2048]
  113.     x = iden_block(x, [512, 512, 2048]) #[7,7,2048]
  114.  
  115.     # 平均池化层
  116.     x = layers.AveragePooling2D(pool_size=(7,7))(x) #[1,1,2048]
  117.     # Flatten层
  118.     x = layers.Flatten()(x)  #[None,2048]
  119.     # 输出层，不做softmax
  120.     outputs = layers.Dense(output_shape)(x)
  121.     
  122.     # 构建模型
  123.     model = Model(inputs=inputs, outputs=outputs) 
  124.     
  125.     # 返回模型
  126.     return model
  127.  
  128. # 创建restnet-50
  129. model = resnet50()
  130. # 查看网络结构
  131. model.summary()

网络结构如下

  1. __________________________________________________________________________________________________
  2.  Layer (type)                   Output Shape         Param #     Connected to                     
  3. ==================================================================================================
  4.  input_1 (InputLayer)           [(None, 224, 224, 3  0           []                               
  5.                                 )]                                                                
  6.                                                                                                   
  7.  zero_padding2d (ZeroPadding2D)  (None, 230, 230, 3)  0          ['input_1[0][0]']                
  8.                                                                                                   
  9.  conv2d (Conv2D)                (None, 112, 112, 64  9472        ['zero_padding2d[0][0]']         
  10.                                 )                                                                 
  11.                                                                                                   
  12.  batch_normalization (BatchNorm  (None, 112, 112, 64  256        ['conv2d[0][0]']                 
  13.  alization)                     )                                                                 
  14.                                                                                                   
  15.  activation (Activation)        (None, 112, 112, 64  0           ['batch_normalization[0][0]']    
  16.                                 )                                                                 
  17.                                                                                                                                                                                                    
  18.  
  19. ----------------------------------------------------------------------------------------
  20. ----------------------------------------------------------------------------------------
  21. 省略N多层
  22. ----------------------------------------------------------------------------------------
  23. ----------------------------------------------------------------------------------------      
  24.     
  25.                                                                                                   
  26.  activation_48 (Activation)     (None, 7, 7, 2048)   0           ['add_15[0][0]']                 
  27.                                                                                                   
  28.  activation_49 (Activation)     (None, 7, 7, 2048)   0           ['activation_48[0][0]']          
  29.                                                                                                   
  30.  average_pooling2d (AveragePool  (None, 1, 1, 2048)  0           ['activation_49[0][0]']          
  31.  ing2D)                                                                                           
  32.                                                                                                   
  33.  flatten (Flatten)              (None, 2048)         0           ['average_pooling2d[0][0]']      
  34.                                                                                                   
  35.  dense (Dense)                  (None, 10)           20490       ['flatten[0][0]']                
  36.                                                                                                   
  37. ==================================================================================================
  38. Total params: 22,979,210
  39. Trainable params: 22,928,650
  40. Non-trainable params: 50,560
  41. __________________________________________________________________________________________________

4. 网络配置

采用动态学习率的方法，指定学习率是指数曲线下降，使网络刚开始时能更快接近最优点，后续再慢慢向逼近最优点。由于在网络的输出层没有进行softmax将实数值转为概率值，因此，在编译时使用交叉熵损失函数计算预测值和真实值的差异时，需要指定参数from_logits=True，代表将logits层输出的实数经过softmax转换为概率之后再和真实值计算损失。这样能有效提高数据稳定性。

  1. #（4）网络配置
  2. # 设置动态学习率
  3. exponential_decay = optimizers.schedules.ExponentialDecay(initial_learning_rate=0.0001,  # 初始学习率
  4.                                                           decay_steps=2,  # 衰减步长
  5.                                                           decay_rate=0.95)  # 衰减率0.95
  6.  
  7. # 编译
  8. model.compile(optimizer=optimizers.Adam(learning_rate=exponential_decay), #指定学习率
  9.               #需要对真实值y进行onehot，而sparse_categorical_crossentropy会自动进行onehot              
  10.               loss = tf.losses.CategoricalCrossentropy(from_logits=True),  # from_logits会自动将输出层的实数转为softmax后再计算交叉熵
  11.               metrics = ['accuracy'])  # 指定模型评价指标
  12.  
  13. # 训练，给出训练集、验证集、循环10次、每轮循环开始之前重新洗牌
  14. model.fit(train_ds, validation_data=val_ds, epochs=10, shuffle=True)

5. 模型评估

绘制训练集和测试集的准确率和损失的对比曲线，观察是否出现过拟合现象。

  1. #（5）评估
  2. # ==1== 准确率
  3. train_acc = model.history['accuracy']  #训练集准确率
  4. val_acc = model.history['val_accuracy']  #验证集准确率
  5. # ==2== 损失
  6. train_loss = model.history['loss'] #训练集损失
  7. val_loss = model.history['val_loss'] #验证集损失
  8. # ==3== 绘图
  9. epochs_range = range(len(train_acc))
  10. plt.figure(figsize=(10,5))
  11. # 准确率
  12. plt.subplot(1,2,1)
  13. plt.plot(epochs_range, train_acc, label='train_acc')
  14. plt.plot(epochs_range, val_acc, label='val_acc')
  15. plt.legend()
  16. # 损失曲线
  17. plt.subplot(1,2,2)
  18. plt.plot(epochs_range, train_loss, label='train_loss')
  19. plt.plot(epochs_range, val_loss, label='val_loss')
  20. plt.legend()

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号