## 迁移学习简述

迁移学习 (Transfer Learning) 是一种机器学习方法，就是把为任务 A 开发的已经训练好的模型参数作为初始点，重新迁移使用在为任务 B 开发模型中，来帮助新模型的训练。

TensorFlow Hub 是一个用于促进机器学习模型中可复用部分再次进行探索与发布的库，主要将预训练过的 TensorFlow 模型片段再次利用到新的任务上。迁移学习的经典做法，即首先使用 transfer learning 对数据集进行训练，经过一定的 Epoch 批次之后，再改用 fine tuning 的方法，接着刚才训练过的模型即训练权重集继续进行训练，可以得到较好的效果。
EfficientNet 是 Google 公司开发的全新的神经网络模型。原码看我

## 利用 Efficientnet 进行猫狗识别实战

  1. 数据准备
    使用 Kaggle 比赛猫狗大战的数据集 Kaggle Cats and Dogs Dataset。点击下载
    猫狗图片在文件夹 PetImages 中，共有图片 25000 张，为了节约时间，我们选取每类 900 张图片用于训练，100 张用于测试。
  2. 训练数据
    首先需要导入 Efficientnet：import efficientnet.keras as efk（安装：pip install efficientnet）
    训练参数设置：
  1. batch_size = 30
  2. width = 300
  3. height = 300
  4. epochs = 10
  5. NUM_TRAIN = 900
  6. NUM_TEST = 100
  7. dropout_rate = 0.2
  8. input_shape = (height, width, 3)

图像尺寸根据选择模型相应变化：
efficientnet 迁移学习 - 图1

本次实验设置训练轮数为 10，共 900 张图片作为训练数据，100 张图片作为测试数据。

  1. 使用 Efficientnet 迁移学习：
  2. base_model = efk.EfficientNetB3(weights='imagenet', include_top=False, input_shape=input_shape)
  3. top_model = tf.keras.models.Sequential()
  4. model=base_model
  6. top_model.add(tf.keras.layers.GlobalMaxPooling2D(name="gap"))
  7. if dropout_rate > 0:
  8.     top_model.add(tf.keras.layers.Dropout(dropout_rate, name="dropout_out"))
  9. top_model.add(tf.keras.layers.Dense(2, activation='softmax', name="fc_out"))
  10. model = tf.keras.models.Model(inputs = model.input,outputs = top_model(model.output))
  14. base_model.trainable = False
  16. model.compile(loss='categorical_crossentropy', optimizer=tf.keras.optimizers.RMSprop(lr=2e-5),
  17.               metrics=['acc'])

使用 model.summary() 查看网络模型参数：
efficientnet 迁移学习 - 图2

  1. 训练模型
    训练网络模型，并将训练好后的网络模型文件保存，函数 fit 和 fit_generator 均可以使用，此处使用 fit。
  2. history_tl = model.fit(       
  3.       train_data,
  4.       train_label,
  5.       steps_per_epoch= NUM_TRAIN//batch_size,
  6.       epochs=epochs,
  7.       validation_data=(valid_data,valid_label),
  8.       validation_steps= NUM_TEST//batch_size,
  9.       shuffle=True,
  10.       verbose=1)
  1. 结果可视化
    输出 Training 和 Validation 的 accuracy 及 loss 图：
  1. def plot_training(history):
  2.     acc = history.history['acc']
  3.     val_acc = history.history['val_acc']
  4.     loss = history.history['loss']
  5.     val_loss = history.history['val_loss']
  6.     epochs_x = range(len(acc))
  8.     plt.plot(epochs_x, acc, 'bo', label='Training acc')
  9.     plt.plot(epochs_x, val_acc, 'b', label='Validation acc')
  10.     plt.title('Training and validation accuracy')
  11.     plt.legend()
  12.     plt.figure()
  13.     plt.plot(epochs_x, loss, 'bo', label='Training loss')
  14.     plt.plot(epochs_x, val_loss, 'b', label='Validation loss')
  15.     plt.title('Training and validation loss')
  16.     plt.legend()
  17.     plt.show()
  1. 训练结果
    对数据集进行训练，总共训练 10 轮。训练数据共 900 张图片，其中猫和狗各 450 张，测试数据共 100 张图片，其中猫和狗各 50 张。以下是 EfficientnetB0 和 EfficientnetB1 的训练结果，大家可以看看 3~7 的结果，此处不再展示。
    使用 EfficientnetB0 训练结果：
    第一轮结束准确率到达 74%, 第二轮达到 82%，第 10 轮达到 100%。efficientnet 迁移学习 - 图3
    Training 和 Validation 的 accuracy 及 loss 图：
    在这里插入图片描述)
    efficientnet 迁移学习 - 图5

使用 EfficientnetB1 训练结果：
第一轮结束准确率到达 20%, 第二轮达到 27%，第 10 轮达到 94%。
efficientnet 迁移学习 - 图6

Training 和 Validation 的 accuracy 及 loss 图：
efficientnet 迁移学习 - 图7
efficientnet 迁移学习 - 图8

  1. 模型载入
    训练中利用 save 函数将模型保存为 h5 文件：
    再次使用时不需要重新训练数据，导入 load_model 函数，然后在对应路径下使用函数导出保存的模型。
  1. from tensorflow.keras.models import load_model
  2. model = load_model('./transdata/my_model.h5')

使用该模型预测分类结果

  1. def predict_image(img_path):
  2.     img = Image.open(img_path)
  3.     img = img.resize((height, width))
  4.     x=np.array(img)
  6.     x = x.reshape((1,) + x.shape)
  8.     result = model.predict([x])[0][0]
  9.     if result > 0.5:
  10.         animal = "cat"
  11.     else:
  12.         animal = "dog"
  13.         result = 1 - result
  14.     return animal, result

输入图像路径，使用 model.predict 函数就可以预测对应类别，如果需要批量预测的话可以自己修改代码实现。

全部代码

  1. import tensorflow as tf
  2. import efficientnet.tfkeras as efk
  3. from keras.utils import to_categorical
  4. import os
  5. import numpy as np
  6. from PIL import Image
  7. import matplotlib.pyplot as plt
  11. batch_size = 30
  12. width = 300
  13. height = 300
  14. epochs = 10
  15. NUM_TRAIN = 900
  16. NUM_TEST = 100
  17. dropout_rate = 0.2
  18. input_shape = (height, width, 3)
  20. path_cat='./transdata/PetImages/Cat/'
  21. path_dog='./transdata/PetImages/Dog/'
  24. def load_data():
  25.     data=np.empty((1000,width,height,3),dtype="float32")
  26.     label=np.empty((1000,))
  27.     imgcat=os.listdir(path_cat)
  28.     imgdog=os.listdir(path_dog)
  29.     cnt=0
  30.     for i in range(0,500):
  31.         img=Image.open(path_cat+str(i)+".jpg")
  33.         arr=np.array(img)
  35.         arr.resize((width,height,3))
  36.         data[cnt,:,:,:]=arr
  38.         label[cnt]=0
  39.         cnt+=1
  40.         img=Image.open(path_dog+str(i)+".jpg")
  41.         arr=np.array(img)
  42.         arr.resize((width,height,3))
  43.         data[cnt,:,:,:]=arr
  45.         label[cnt]=1
  46.         cnt+=1
  47.     return data,label
  49. data,label=load_data()
  51. label = to_categorical(label)
  53. train_data=data[:900]
  54. train_label=label[:900]
  55. valid_data=data[900:1000]
  56. valid_label=label[900:1000]
  57. train_label = to_categorical(train_label)
  58. valid_label = to_categorical(valid_label)
  61. base_model = efk.EfficientNetB3(weights='imagenet', include_top=False, input_shape=input_shape)
  62. top_model = tf.keras.models.Sequential()
  63. model=base_model
  65. top_model.add(tf.keras.layers.GlobalMaxPooling2D(name="gap"))
  66. if dropout_rate > 0:
  67.     top_model.add(tf.keras.layers.Dropout(dropout_rate, name="dropout_out"))
  68. top_model.add(tf.keras.layers.Dense(2, activation='softmax', name="fc_out"))
  69. model = tf.keras.models.Model(inputs = model.input,outputs = top_model(model.output))
  73. base_model.trainable = False
  75. model.compile(loss='categorical_crossentropy', optimizer=tf.keras.optimizers.RMSprop(lr=2e-5),
  76.               metrics=['acc'])
  79. history_tl = model.fit(       
  80.       train_data,
  81.       train_label,
  82.       steps_per_epoch= NUM_TRAIN//batch_size,
  83.       epochs=epochs,
  84.       validation_data=(valid_data,valid_label),
  85.       validation_steps= NUM_TEST//batch_size,
  86.       shuffle=True,
  87.       verbose=1)
  89. model.save('./transdata/my_model3.h5')
  91. def plot_training(history):
  92.     acc = history.history['acc']
  93.     val_acc = history.history['val_acc']
  94.     loss = history.history['loss']
  95.     val_loss = history.history['val_loss']
  96.     epochs_x = range(len(acc))
  98.     plt.plot(epochs_x, acc, 'bo', label='Training acc')
  99.     plt.plot(epochs_x, val_acc, 'b', label='Validation acc')
  100.     plt.title('Training and validation accuracy')
  101.     plt.legend()
  102.     plt.figure()
  103.     plt.plot(epochs_x, loss, 'bo', label='Training loss')
  104.     plt.plot(epochs_x, val_loss, 'b', label='Validation loss')
  105.     plt.title('Training and validation loss')
  106.     plt.legend()
  108.     plt.show()
  110. plot_training(history_tl)

因为本人也是刚开始学习，使用难免有理解不到位的地方，欢迎各位大佬指正，也欢迎大家交流讨论。
部分内容参考此博客。
https://blog.csdn.net/qq_47043529/article/details/105871957