基于谷歌最新网络模型EfficientNet,使用迁移学习对猫狗图像识别分类的实际案例应用

Index 目录索引

  • 0 Introduction 引言
  • 1 迁移学习概述
  • 2 数据集的准备
  • 3 使用Transfer leaning对数据集进行训练
  • 4 使用Fine tuning载入上节训练过的模型继续对数据集进行训练
  • 5 使用训练好的模型文件来进行对图像的识别
    • 5.1 未进行fine tuning,使用transfer learning后生成的模型直接进行分类预测
    • 5.2 fine tuning之后,继续transfer learning生成的模型来进行分类预测
  • 6 Supplementary Contents 补充内容
  • ♣️ 项目完整代码(托管于Github)
  • 7 References 参考

0 Introduction 引言

EfficientNet是Google谷歌的最新论文EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks中提出的全新神经网络模型(简称模型,下同)。

可以毫不夸张地说,此模型一出,对前面的那些模型们具有碾压效果。论文里作者在Github上开源了该网络模型训练好的源码,地址在这里,有兴趣的小伙伴们可以加以参考。在这篇论文中,作者系统地研究并验证了网络深度宽度分辨率之间的平衡可以发挥出更好的性能。由于本篇文章侧重于基于该模型的实际应用,将不对该论文展开过多的解读。本文参考的代码[1]已经在文末的参考部分列出。

1 迁移学习概述

迁移学习(Transfer Learning)是一种机器学习方法,就是把为任务 A 开发的已经训练好的模型参数作为初始点,重新迁移使用在为任务 B 开发模型中,来帮助新模型的训练[2]。这是百度百科关于迁移学习的解释,下面引用斯坦福大学的 CS231n(面向视觉识别的卷积神经网络)课程中关于迁移学习的定义[3]

In practice, very few people train an entire Convolutional Network 
from scratch (with random initialization), because it is relatively 
rare to have a dataset of sufficient size. Instead, it is common to 
pretrain a ConvNet on a very large dataset (e.g. ImageNet, which 
contains 1.2 million images with 1000 categories), and then use the 
ConvNet either as an initialization or a fixed feature extractor for 
the task of interest.

关于迁移学习的概念,大家仁者见仁智者见智,由于其并不是本篇文章的重点,在这里不再赘述。本节部分只介绍迁移学习的经典做法,即首先使用transfer learning对数据集进行训练,经过一定的Epoch批次之后,再改用fine tuning的方法,接着刚才训练过的模型即训练权重集继续进行训练,同时可以适当地降低learning rate学习率。之所以使用fine tuning,是因为这样做可以加速训练过程,详情可以在本文第四小节的内容中体会。理论讲解完毕,下面开始进入应用部分。

2 数据集的准备

正所谓兵马未动,粮草先行巧妇难为无米之炊,训练网络模型时候也一样,训练之前需要先把数据集给准备好,这里我们用到的是Kaggle比赛猫狗大战的数据集Kaggle Cats and Dogs Dataset,下载地址在这里(使用时请严格遵守数据集中附的MSR-LA - 3467.docx文件中提到的Microsoft Research Data License Agreement)。

下载好数据集后解压文件,会得到如下文件夹目录(其中以“- -”开头的是子目录):

kagglecatsanddogs_3367a
--PetImages
--MSR-LA - 3467.docx
--readme[1].txt

其中的PetImages文件夹就是猫狗图像了,每类各12500张,我们手动选取其中每类1000张图像用于训练,500张用于测试(这里可以根据个人情况酌量添加)。

3 使用Transfer leaning对数据集进行训练

本部分将介绍基于迁移学习的猫狗识别的training训练核心代码块,首先是引入EfficientNet:

from efficientnet import EfficientNetB0 as Net   # Import efficientnet and load the conv base model

接下来是Hyper parameters超参数的设置:

# Hyper parameters 超参数
batch_size = 16

# width = 150   # Error Detected
# height = 150   # B0的输入是 224*224*3
width = 224   # Last Modified: 2020.05.26
height = 224
epochs = 100
NUM_TRAIN = 2000
NUM_TEST = 1000
dropout_rate = 0.2
input_shape = (height, width, 3)

刚才下载解压好并手动选取放置后的数据集目录代码:

train_dir = './data/dog_vs_cat_small/train'
validation_dir = './data/dog_vs_cat_small/validation'

图像数据增强代码块:

train_datagen = ImageDataGenerator(          
      rescale=1./255,
      rotation_range=40,
      width_shift_range=0.2,
      height_shift_range=0.2,
      shear_range=0.2,
      zoom_range=0.2,
      horizontal_flip=True,
      fill_mode='nearest')

validation_datagen = ImageDataGenerator(
      rescale=1./255,
      rotation_range=40,
      width_shift_range=0.2,
      height_shift_range=0.2,
      shear_range=0.2,
      zoom_range=0.2,
      horizontal_flip=True,
      fill_mode='nearest')

分批读取数据集:

train_generator = train_datagen.flow_from_directory(
        train_dir,
        target_size=(height, width),
        batch_size=batch_size,
        class_mode='categorical')

validation_generator = validation_datagen.flow_from_directory(
        validation_dir,
        target_size=(height, width),
        batch_size=batch_size,
        class_mode='categorical')

以下是本节内容的核心部分,即使用EfficientNet进行迁移学习的代码块:

conv_base = Net(weights='imagenet', include_top=False, input_shape=input_shape)
model = models.Sequential()
model.add(conv_base)
model.add(layers.GlobalMaxPooling2D(name="gap"))
if dropout_rate > 0:
    model.add(layers.Dropout(dropout_rate, name="dropout_out"))
model.add(layers.Dense(2, activation='softmax', name="fc_out")) 

# 输出网络模型参数
# model.summary()  

# 冻结卷积层不参与训练
conv_base.trainable = False

model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=2e-5),
              metrics=['acc'])

一切准备就绪,下面开始训练网络模型,并将训练好后的网络模型文件保存,输出Training和Validation的accuracy及loss图:

history_tl = model.fit_generator(       
      train_generator,
      steps_per_epoch= NUM_TRAIN //batch_size,
      epochs=epochs,
      validation_data=validation_generator,
      validation_steps= NUM_TEST //batch_size,
      verbose=1,
      use_multiprocessing=True,
      workers=4
)
# 训练后的模型文件保存目录
model.save('./output_model_file/my_model.h5')


def plot_training(history):

    acc = history.history['acc']
    val_acc = history.history['val_acc']
    loss = history.history['loss']
    val_loss = history.history['val_loss']

    epochs_x = range(len(acc))

    plt.plot(epochs_x, acc, 'bo', label='Training acc')
    plt.plot(epochs_x, val_acc, 'b', label='Validation acc')
    plt.title('Training and validation accuracy')
    plt.legend()

    plt.figure()

    plt.plot(epochs_x, loss, 'bo', label='Training loss')
    plt.plot(epochs_x, val_loss, 'b', label='Validation loss')
    plt.title('Training and validation loss')
    plt.legend()

    plt.show()

# 用于训练后输出Training和Validation的accuracy及loss图
plot_training(history_tl)

Training文件执行后的训练过程如下:

Using TensorFlow backend.
Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.
Epoch 1/100

  1/125 [..............................] - ETA: 22:03 - loss: 4.5333 - acc: 0.5000
  2/125 [..............................] - ETA: 11:00 - loss: 4.7284 - acc: 0.4375
  3/125 [..............................] - ETA: 7:18 - loss: 4.5324 - acc: 0.4792 
  4/125 [..............................] - ETA: 5:28 - loss: 4.2386 - acc: 0.4531
  5/125 [>.............................] - ETA: 4:21 - loss: 3.9124 - acc: 0.4625
  6/125 [>.............................] - ETA: 3:37 - loss: 4.0239 - acc: 0.4688
  7/125 [>.............................] - ETA: 3:05 - loss: 3.7774 - acc: 0.4911
  8/125 [>.............................] - ETA: 2:42 - loss: 3.8022 - acc: 0.5078
  9/125 [=>............................] - ETA: 2:23 - loss: 3.8040 - acc: 0.4792
 10/125 [=>............................] - ETA: 2:08 - loss: 3.7879 - acc: 0.4750
 11/125 [=>............................] - ETA: 1:56 - loss: 3.6966 - acc: 0.4943
 ...
123/125 [============================>.] - ETA: 0s - loss: 2.5113 - acc: 0.4553
124/125 [============================>.] - ETA: 0s - loss: 2.5085 - acc: 0.4556
125/125 [==============================] - 38s 305ms/step - loss: 2.5123 - acc: 0.4555 - val_loss: 1.8039 - val_acc: 0.4315
Epoch 2/100

  1/125 [..............................] - ETA: 7s - loss: 2.0313 - acc: 0.3750
  2/125 [..............................] - ETA: 7s - loss: 2.1477 - acc: 0.4062
  3/125 [..............................] - ETA: 7s - loss: 2.2250 - acc: 0.3542
  4/125 [..............................] - ETA: 7s - loss: 2.0626 - acc: 0.3906
  5/125 [>.............................] - ETA: 7s - loss: 2.1242 - acc: 0.3875
 ...

我们可以看到,首先使用transfer learning方法对数据集进行训练的过程中,刚开始的accuracy准确率并不是很高,从0.5左右开始逐步提升,而且经过100个Epoch之后才上升到了0.75附近。不要慌,下个部分我们将介绍到如何利用fine tuning方法在本节训练模型的基础上对模型继续进行训练。我们先来看使用transfer learning方法经过100个Epoch的训练好之后的结果。

使用transfer learning方法经过100个Epoch的训练之后,会在指定目录下生成模型文件,并显示Training和Validation的accuracy及loss图如下:
基于谷歌最新网络模型EfficientNet,使用迁移学习对猫狗图像识别分类的实际案例应用_第1张图片
基于谷歌最新网络模型EfficientNet,使用迁移学习对猫狗图像识别分类的实际案例应用_第2张图片

4 使用Fine tuning载入上节训练过的模型继续对数据集进行训练

首先是载入上节训练后保存的模型文件,即训练权重集:

model.load_weights('./output_model_file/my_model.h5')

然后是基于Fine tuning的策略,对网络模型进行修改和编译,重新搭建新的模型:

# Fine tuning网络模型的最后几层   
# 设置 'multiply_16' 及接下来的几层为可训练状态
conv_base.trainable = True

set_trainable = False

for layer in conv_base.layers:
    if layer.name == 'multiply_16':
        set_trainable = True
    if set_trainable:
        layer.trainable = True
    else:
        layer.trainable = False

模型搭建好之后,我们接着上节的网络模型继续进行200个Epoch的训练:

Using TensorFlow backend.
Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.
Epoch 1/200

  1/125 [..............................] - ETA: 6:21 - loss: 0.5286 - acc: 0.7500
  4/125 [..............................] - ETA: 1:34 - loss: 0.5933 - acc: 0.8281
  7/125 [>.............................] - ETA: 53s - loss: 0.4986 - acc: 0.8482 
 10/125 [=>............................] - ETA: 37s - loss: 0.4308 - acc: 0.8625
 13/125 [==>...........................] - ETA: 28s - loss: 0.4212 - acc: 0.8654
 15/125 [==>...........................] - ETA: 25s - loss: 0.4004 - acc: 0.8667
 16/125 [==>...........................] - ETA: 24s - loss: 0.4175 - acc: 0.8633
 17/125 [===>..........................] - ETA: 23s - loss: 0.4007 - acc: 0.8676
 ...
124/125 [============================>.] - ETA: 0s - loss: 0.5657 - acc: 0.8201
125/125 [==============================] - 23s 184ms/step - loss: 0.5710 - acc: 0.8195 - val_loss: 0.6552 - val_acc: 0.7540
Epoch 2/200

  1/125 [..............................] - ETA: 1s - loss: 0.1782 - acc: 0.9375
  4/125 [..............................] - ETA: 2s - loss: 0.4303 - acc: 0.8125
  7/125 [>.............................] - ETA: 2s - loss: 0.5291 - acc: 0.8036
 10/125 [=>............................] - ETA: 2s - loss: 0.6332 - acc: 0.7750
 13/125 [==>...........................] - ETA: 2s - loss: 0.5831 - acc: 0.7885
 14/125 [==>...........................] - ETA: 3s - loss: 0.6281 - acc: 0.7812
 ...

通过输出我们可以看到,接着上节保存的模型进行训练的时候,准确率直接是从0.75开始的,这也是情理之中的事情,毕竟是使用fine tuning方法进行的训练,我们来看下200个Epoch之后输出的Training和Validation的accuracy及loss图:
基于谷歌最新网络模型EfficientNet,使用迁移学习对猫狗图像识别分类的实际案例应用_第3张图片
基于谷歌最新网络模型EfficientNet,使用迁移学习对猫狗图像识别分类的实际案例应用_第4张图片
通过观察Training和Validation的accuracy及loss图,我们可以看到,经过200个Epoch之后,准确率已经由原来的0.75提升到了0.80附近,这不能不算得上是一件值得高兴的事情。

5 使用训练好的模型文件来进行对图像的识别

模型训练好之后,我们就可以使用该模型用于猫狗图像的识别分类预测任务了。本节中我们将对比使用fine tuning之后生成的模型和未进行fine tuning,在transfer learning后直接进行分类预测的准确率结果。

5.1 未进行fine tuning,使用transfer learning后生成的模型直接进行分类预测

首先是载入经过transfer learning训练后保存的模型文件:

# 载入模型
model = load_model('./output_model_file/my_model.h5')

定义图像分类的预测函数:

def predict_image(img_path):
    # 读入要识别的图像并修改为要求的尺寸大小
    img = image.load_img(img_path, target_size=(height, width))
    # 将图像转化为Numpy数组格式
    x = image.img_to_array(img)
    x = x.reshape((1,) + x.shape)
    x /= 255.
    result = model.predict([x])[0][0]
    if result > 0.5:
        animal = "cat"
    else:
        animal = "dog"
        result = 1 - result
    return animal, result

将要进行识别的图像路径:

img = './12499.jpg'

用于输出识别图像结果的代码语句:

print(predict_image(img))

以下是图像识别的类别输出及对应的概率:

Using TensorFlow backend.
...
('dog', 0.9990355644840747)

可以看到,使用训练后的模型,可以成功地识别出该图像所属的类别。

5.2 fine tuning之后,继续transfer learning生成的模型来进行分类预测

同样的,先载入经过transfer learning和fine tuning之后生成的模型文件:

# 载入模型
# model = load_model('./output_model_file/my_model.h5')
model = load_model('./models/cats_and_dogs_small.h5')

用于图像分类的预测函数不变,仍然识别刚才那张名为12499.jpg的照片,这时的预测结果及其准确率如下:

Using TensorFlow backend.
...
('dog', 0.9998197872046148)

可以看到,虽然两种情况下的识别准确性是同等的,都能成功地识别出其所属的类别,但是在fine tuning之后,图像识别的准确率提升了0.00078左右。

6 Supplementary Contents 补充内容

以上案例的演示是Windows下进行的,如有Linux下运行的小伙伴,第一次执行training训练文件时候可能会出现如下情况:

[**@** EfficientNet]# python training.py
Using TensorFlow backend.
Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.

Downloading data from https://github.com/qubvel/efficientnet/releases/download/v0.0.1/efficientnet-b0_imagenet_1000_notop.h5
  122880/16717576 [..............................] - ETA: 18:11Traceback (most recent call last):
  File "training.py", line 85, in 
    conv_base = Net(weights='imagenet', include_top=False, input_shape=input_shape)
  File "/**/efficientnet/model.py", line 400, in EfficientNetB0
    weights=weights, classes=classes, pooling=pooling)
  File "/**/efficientnet/model.py", line 391, in _get_model_by_name
    md5_hash=weights['md5'],
  File "/usr/local/python3/lib/python3.6/site-packages/tensorflow/python/keras/utils/data_utils.py", line 248, in get_file
    urlretrieve(origin, fpath, dl_progress)
  File "/usr/local/python3/lib/python3.6/urllib/request.py", line 277, in urlretrieve
    block = fp.read(bs)
  File "/usr/local/python3/lib/python3.6/http/client.py", line 449, in read
    n = self.readinto(b)
  File "/usr/local/python3/lib/python3.6/http/client.py", line 493, in readinto
    n = self.fp.readinto(b)
  File "/usr/local/python3/lib/python3.6/socket.py", line 586, in readinto
    return self._sock.recv_into(b)
  File "/usr/local/python3/lib/python3.6/ssl.py", line 1012, in recv_into
    return self.read(nbytes, buffer)
  File "/usr/local/python3/lib/python3.6/ssl.py", line 874, in read
    return self._sslobj.read(len, buffer)
  File "/usr/local/python3/lib/python3.6/ssl.py", line 631, in read
    v = self._sslobj.read(len, buffer)
ConnectionResetError: [Errno 104] Connection reset by peer

之所以会报这个错误,是因为首次执行training训练文件的时候,程序会自动从网上下载EfficientNet模型文件,但由于网速的限制,可能会出现下载中断的情况,报出ConnectionResetError的错误。针对这个情况,我们可以预先将要用到的EfficientNet网络模型离线下载,然后将该模型放置到指定的路径下,这样以后执行training训练文件的时候就不会每次都先下载网络模型了,而是直接可以使用我们预先放置好的网络模型来进行训练。至于如何离线下载网络模型并上传,以及如何找到网络模型上传的指定目录,已经详细地记录在了我的这篇博文里,点击这里即可跳转到这篇博文进行阅读。

♣️ 项目完整代码(托管于Github)

项目的完整Github代码(完善和维护中)

写到这里,差不多本文就要结束了。之所以会选择写这篇文章,是因为本人发现,谷歌的EfficientNet模型已经提出将近有小半年的时间了,可是在CSDN上面竟然没有一个可供参考的EfficientNet模型用于图像分类的完整案例,于是乎本人花了将近一周的时间咬着牙痛苦地做出了这个案例。如有需要,后续将会给出本案例对应的Github完整代码 Github代码已经公开,大家按需所取,如果有问题可以在下方留言区留言交流。如果我的这篇文章帮助到了你,那我也会感到很高兴,一个人能走多远,在于与谁同行

7 References 参考

[1] 参考代码
[2] 百度百科关于迁移学习的解释
[3] 斯坦福大学的 CS231n课程关于迁移学习的定义

你可能感兴趣的:(image,classification,of,DL)