开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 人工智能 -> Keras学习之：全网最详细，一文包你会！使用 Keras 自带的模型实现迁移学习 -> 正文阅读

[人工智能]Keras学习之：全网最详细，一文包你会！使用 Keras 自带的模型实现迁移学习

迁移学习是什么，为什么要用迁移学习

场景一

我们在训练模型的时候，拿 CNN 网络来举例，CNN 的前几层捕获的是边缘的信息，其实对于任何图片，他们的边缘信息都是有共同点的，这些信息抽象度比较低，重要程度也并不高。但是我们建立神经网络的时候，并不可能只要后几层，这就类似再高的楼，都要有地基。而有了前面的这些层次，神经网络的参数就会在一层层的堆叠中不断变大，那么我们怎么来解决这个问题呢？

场景二

我想训练一个目标跟踪或者图像分割的复杂神经网络，他们的前端无一例外地都要使用很庞大的 CNN 网络来提取图片中的信息。但是如果我从头训练整个网络，势必会消耗大量的时间和资源。

破局之法：迁移学习

使用别人构建的标准模型为你的模型或者功能服务；
使用别人训练好的模型的参数，减少了自己训练的麻烦；
可以在别人模型的基础上进行进一步操作，站在巨人的肩膀上；
可以横跨很多领域，使得功能实现更加灵活。

迁移学习主要的三种手段

实现迁移学习有以下三种手段：

Transfer Learning： 冻结预训练模型的全部卷积层，只训练自己定制的全连接层。
Extract Feature Vector： 先计算出预训练模型的卷积层对所有训练和测试数据的特征向量，然后抛开预训练模型，只训练自己定制的简配版全连接网络。
Fine-tuning： 冻结预训练模型的部分卷积层（通常是靠近输入的多数卷积层，因为这些层保留了大量底层信息）甚至不冻结任何网络层，训练剩下的卷积层（通常是靠近输出的部分卷积层）和全连接层。

Keras 可以使用哪些已经训练好的模型

可以翻阅我的这篇文章：
Keras学习之：keras 自带的经典模型加载和使用（vgg-16，resnet，mobilenet，densenet等）

模型选择：Inceptionv3

Inceptionv3 的网络结构中的基本块就是这种形式，结合了多种大小的卷积核对同一个图片进行多次卷积操作，最终将结果按照通道进行整合。
具体的情况不再赘述，可以去找相应的文章看。

实现步骤

加载数据集 cifar10，因为 keras 中使用的 Inceptionv3 的模型的默认输入是 (299,299,3)，因此我们需要使用三通道的数据集。这里推荐使用 cifar10 或者 cifar100 进行测试。当然你也可以自己使用别的图片数据集。

导入模块

## 导入 Inceptionv3 模型
from keras.applications.inception_v3 import InceptionV3
## 导入画图工具
import matplotlib.pyplot as plt
## 导入建立神经网络的基本模块
from keras.layers import *
from keras.models import *
from keras.optimizers import *
from keras.losses import categorical_crossentropy
## 导入数据增强模块
from keras_preprocessing.image import ImageDataGenerator
## 导入数据集
from keras.datasets import cifar10,cifar100
## 导入 keras one-hot 变量转换模块
from keras.utils import to_categorical
## 导入 sklearn 中划分数据集的模块
from sklearn.model_selection import train_test_split
## 导入矩阵运算模块 
import numpy as np
## 导入 opencv 来调整图片尺寸
import cv2

加载数据集


## 导入数据，自动划分为训练和测试集合
(x_train,y_train),(x_test,y_test)= cifar10.load_data()

## 将训练和测试的标签都转换成独热编码 one-hot coding
y_test = to_categorical(y_test)
y_train = to_categorical(y_train)

## 打印观察数据的规模
print(x_train.shape)
print(y_train.shape)

调整数据集中图片的尺寸

## 对训练和测试的图片数据进行 resize
temp = [cv2.resize(i,(299,299)) for i in x_train]
temp_test = [cv2.resize(i,(299,299)) for i in x_test]
## 重新转回为 array 
temp = np.array(temp)
temp_test = np.array(temp_test)

print(temp.shape)
print(temp_test.shape)
## 重新调整 训练集和数据集的维度
x_train = temp.reshape(50000,299,299,3)
x_test = temp_test.reshape(10000,299,299,3)

数据增强 / 使用简单的原始数据

'''
构建增强数据的生成器
可用可不用，最好使用
在本文中因为只是对迁移学习的效果进行验证；
因此不适用这个数据增强器增强我们的数据
使用原始数据的话，这里就不用看了。
'''
train_datagen = ImageDataGenerator(
    rotation_range=30,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
)

#val_datagen = ImageDataGenerator(
#     rotation_range=30,
#     width_shift_range=0.2,
#     height_shift_range=0.2,
#     shear_range=0.2,
#     zoom_range=0.2,
#     horizontal_flip=True,
# )

加载 Keras 中的 Inceptionv3 模型

在这里插入图片描述

weights 设置为 “imagenet” 的话，他就会自动进行参数下载了。
建议 include_top 设置为 false，如果设置为 true 的话，模型参数大的不得了

## include_top = False 代表不包括他的全连接层
base_model = InceptionV3(weights="imagenet",include_top=False)

模型删改

'''
在原有基础上构建进一步的模型
'''
# 拿到他模型最后一层的输出
x = base_model.output
# 添加一个 全局池化层
x = GlobalAveragePooling2D()(x)
# 添加一个 64 个隐藏单元的全连接层
x = Dense(64,activation='relu')(x)
# 整个新网络的输出层
output = Dense(10,activation='softmax')(x)
# 重新构建模型。=> （base 模型 + 我们构建的部分 ）
model = Model(inputs=base_model.input,outputs=output)

打印此时的模型信息，就会发现，需要训练的参数还是巨大的，有 21900138。
红色框里面是我们构建的模块

在这里插入图片描述

知识迁移

回顾一下上面的知识：
在这里插入图片描述

第一种手段：Transfer Learning

不要忘记，冻结所有原来的层之后，一定要 compile 才会生效哦~

'''
遍历所有的 Inceptionv3 自己的层，
把这些层的 trainable 都设置为 false；
！！！！ 
注意，设置完之后，一定要 compile 才会生效，
所以不要忘记最后一行代码！！！
'''
for layer in base_model.layers:
    layer.trainable = False
model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])

冻结了之后，可以再看一遍要训练的参数量，是不是小 case，只有 131786

在这里插入图片描述

第三种手段：Fine-tune

'''第三种手段在本质上和第一种是一样的，只是冻结的层数不同
    训练的参数越多，当然对任务的拟合效果大概率会更好。
'''
frozen_layer_number = 250
for layer in base_model.layers[:frozen_layer_number+1]:
    layer.trainable = False
model.compile(optimizer=Adagrad(lr=0.0001),loss='categorical_crossentropy',metrics=['accuracy'])

就算冻结了 250 层，要训练的参数还是这么多

在这里插入图片描述

冻结之后的训练

'''
冻结完毕之后就可以开始训练了。
为了简便，这里没有用一些 checkpoint ，步长递减，回调
之类的方法，大家可以参考我的其他关于 keras 的文章
'''

## 不使用 generator 的方法
history = model.fit(x_train,
                       y_train,
                       batch_size=64,
                        epochs=10,
                        validation_data=(x_test,y_test))

## 使用 generator 的方法
history_tl = model.fit_generator(generator=train_datagen.flow(x_train,y_train,batch_size=64),
                    steps_per_epoch=800,#800
                    epochs=10,
                    validation_data=(x_test,y_test))

为什么不讲第二种手段？ 别急，原理是相同的，但操作步骤略有不同，而且训练速度要快很多。放在最后压轴。

让我们先把第一种和第三种的步骤进行完毕。

第二种手段：Extract Feature Vector

由于这种手段是新建一个小规模的网络，因此和大网络之间并不存在交集
所以训练和收敛的速度都比较快。
为了方便演示，这里只是转换了训练和测试集的前 100 个样本，如果你要自己做测试的话，请务必保证原始的数据集大小。

'''
首先将 base model 辛辛苦苦提取出来的特征图拿过来
毕竟这是个好东西
为了做测试方便，我们不使用全部的数据集，而是使用前100个图片
的特征图做一下代码上的演示
'''

# x_train_features = base_model.predict(x_train)
# x_test_features = base_model.predict(x_test)

x_train_features = base_model.predict(x_train[:100])
x_test_features = base_model.predict(x_test[:100])
'''
通过 x_train_feature 的维度和尺寸来新建一个后续的网络模块
直接接受在 base model 中训练好的 x_train_feature 进行二次训练
从而适应自己的网络功能
'''
print(x_train_features.shape)
# (100, 8, 8, 2048)

'''开始构建小规模的第二阶段网络'''

model_= Sequential()
# flatten 之后的维度会变成 (100,8*8*2048)
model_.add(Flatten())
# 因此我们在我们构建的层里，接受的层的维度也要保持一致
model_.add(Dense(256,activation='relu',input_dim=2048*8*8))
model_.add(Dropout(0.5))
model_.add(Dense(10,activation='softmax'))

model_.compile(optimizer=Adam(lr=0.001),loss='categorical_crossentropy',metrics=['accuracy'])

## 训练的参数都不是固定的，根据自己的需求自己调整
history_ = model_.fit(x_train_features,
                       y_train[0:100],
                       batch_size=64,
                        epochs=50,
                        validation_data=(x_test_features,y_test[0:100]))

重点总结

迁移学习有三种方法
载入 keras 自带模型的时候要注意 input_shape 要符合官方规定的 (299,299,3) 才能加载 imagenet 的预训练参数
使用训练集之前，一定要把训练数据的尺寸调整为合适的尺寸，然后才能输入到网络中
以上就是用 keras 做简单的迁移学习的全部小方法。

代码重构

from keras.applications.inception_v3 import InceptionV3
import matplotlib.pyplot as plt
from keras.layers import *
from keras.models import *
from keras.optimizers import *
from keras.losses import categorical_crossentropy
from keras_preprocessing.image import ImageDataGenerator
from keras.datasets import cifar10,cifar100
from keras.utils import to_categorical
import numpy as np
import cv2

INPUT_SHAPE = (299,299,3)
BATCH_SIZE = 64
EPOCHS = 100
TRAIN_SIZE = 50000
TEST_SIZE = 10000



class InceptionV3_Network():
    def __init__(self, base_model, classes, transfer_mean):
        self.base_model = base_model
        self.classes = classes
        self.transfer_mean = transfer_mean
        self.model = self.make_network()
        self.input_shape = INPUT_SHAPE


    def get_model_summary(self):
        return self.model.summary()

    def make_network(self):

        if self.transfer_mean == "second":
            model = Sequential()
            model.add(Flatten())
            model.add(Dense(256,activation='relu',input_dim=2048*8*8))
            model.add(Dropout(0.5))
            model.add(Dense(self.classes,activation='softmax'))
            model.compile(optimizer=Adam(lr=0.001), loss='categorical_crossentropy', metrics=['accuracy'])
            return model
        else:
            x = self.base_model.output
            x = GlobalAvgPool2D()(x)
            x = Dense(64, activation='relu')(x)
            output = Dense(self.classes, activation='softmax')(x)
            model =  Model(inputs=base_model.input, outputs=output)

            if self.transfer_mean == "first" :
                for layer in base_model.layers:
                    layer.trainable = False
                model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

            if self.transfer_mean == "third":
                frozen_layer_number = 250
                for layer in base_model.layers[:frozen_layer_number + 1]:
                    layer.trainable = False
                model.compile(optimizer=Adagrad(lr=0.0001),
                              loss='categorical_crossentropy',
                              metrics=['accuracy'])
            return model

    def train(self, dataset='cifar10'):

        x_train, y_train, x_test, y_test = training_data_process(BATCH_SIZE,aug=False,dataset=dataset)

        if self.transfer_mean == "second":
            # x_train_features = base_model.predict(x_train[:100])
            # x_test_features = base_model.predict(x_test[:100])
            x_train_features = base_model.predict(x_train)
            x_test_features = base_model.predict(x_test)

            return self.model.fit(x_train_features,
                       y_train,
                       batch_size=BATCH_SIZE,
                       epochs=EPOCHS,
                       validation_data=(x_test_features, y_test))
        else:
            return self.model.fit(x_train,
                                y_train,
                                batch_size=BATCH_SIZE,
                                epochs=EPOCHS,
                                validation_data=(x_test, y_test))



def image_augmentation_generator(rotation_range=20,
                         width_shift_range=0.1,
                         height_shift_range=0.1,
                         shear_range=0.,
                         zoom_range=0.,
                         zca_epsilon=1e-6,
                         horizontal_flip=True,
                         fill_mode='nearest'):
    return ImageDataGenerator(rotation_range=rotation_range,
                         width_shift_range=width_shift_range,
                         height_shift_range=height_shift_range,
                         shear_range=shear_range,
                         zoom_range=zoom_range,
                         zca_epsilon=zca_epsilon,
                         horizontal_flip=horizontal_flip,
                         fill_mode=fill_mode)

def training_data_process(batch_size,aug=False,dataset='cifar10'):

    if dataset == 'cifar10':
        original_shape = (32, 32, 3)
        (x_train, y_train), (x_test, y_test) = cifar10.load_data()

        temp = [cv2.resize(i, (INPUT_SHAPE[1], INPUT_SHAPE[2])) for i in x_train]
        temp_test = [cv2.resize(i, (INPUT_SHAPE[1], INPUT_SHAPE[2])) for i in x_test]
        ## 重新转回为 array
        temp = np.array(temp)
        temp_test = np.array(temp_test)

        print(temp.shape)
        print(temp_test.shape)
        ## 重新调整 训练集和数据集的维度
        x_train = temp.reshape(TRAIN_SIZE, INPUT_SHAPE[0], INPUT_SHAPE[1], INPUT_SHAPE[2])
        x_test = temp_test.reshape(TEST_SIZE, INPUT_SHAPE[0], INPUT_SHAPE[1], INPUT_SHAPE[2])

        y_test = to_categorical(y_test)
        y_train = to_categorical(y_train)
        x_train = x_train / 255.
        x_test = x_test / 255.



        if aug == True:
            aug = image_augmentation_generator()
            aug.fit(x_train)
            imgGen = aug.flow(x_train, y_train, batch_size=batch_size, shuffle=True)
        else:
            return  x_train, y_train, x_test, y_test

        return imgGen, x_test, y_test




if __name__ == '__main__':
    base_model = InceptionV3(weights="imagenet", include_top=False)
    total_model = InceptionV3_Network(base_model,10,"first")
    total_model.make_network()
    total_model.train(dataset='cifar10')