Keras 实现卷积神经网络识别手写数字、迁移学习以及tf.keras.applications使用
日萌社
人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）
4.4 案例：CNN进行分类
4.4.1 卷积神经网络构建识别手写数字
卷积神经网络包含一个或多个卷积层（Convolutional Layer）、池化层（Pooling Layer）和全连接层（Fully-connected Layer）。
4.4.1.1 使用 Keras 实现卷积神经网络
卷积神经网络的一个实现现如下所示，新加入了一些卷积层和池化层。当然这个网络可以增加、删除或调整 CNN 的网络结构和参数，以达到更好效果。
class CNN(tf.keras.Model):
def __init__(self):
super().__init__()
self.conv1 = tf.keras.layers.Conv2D(
filters=32, # 卷积层神经元（卷积核）数目
kernel_size=[5, 5], # 卷积核大小
padding='same', # padding策略（vaild 或 same）
activation=tf.nn.relu # 激活函数
)
self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
self.conv2 = tf.keras.layers.Conv2D(
filters=64,
kernel_size=[5, 5],
padding='same',
activation=tf.nn.relu
)
self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu)
self.dense2 = tf.keras.layers.Dense(units=10)
def call(self, inputs):
x = self.conv1(inputs) # [batch_size, 28, 28, 32]
x = self.pool1(x) # [batch_size, 14, 14, 32]
x = self.conv2(x) # [batch_size, 14, 14, 64]
x = self.pool2(x) # [batch_size, 7, 7, 64]
x = self.flatten(x) # [batch_size, 7 * 7 * 64]
x = self.dense1(x) # [batch_size, 1024]
x = self.dense2(x) # [batch_size, 10]
output = tf.nn.softmax(x)
return output
将前节的 model = MLP() 更换成 model = CNN() ，训练结束以及预测输出：
批次 4682: 损失 0.010545
批次 4683: 损失 0.003783
批次 4684: 损失 0.000980
测试准确率: 0.990600
可以发现准确率相较于之前的多层感知机有非常显著的提高。
我们来看一个个问题如果我们要做一个具体场景的计算机视觉任务，那么从头开始训练一个网络是合适的选择吗？怎么样才能避免浪费过多的计算时间？
keras_mlp.py
import tensorflow as tf
import numpy as np
import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
num_epochs = 5
batch_size = 64
learning_rate = 0.001
class MnistLoader(object):
"""数据加载处理类
"""
def __init__(self):
# 1、获取数据
(self.train_data, self.train_label), (self.test_data, self.test_label) = \
tf.keras.datasets.mnist.load_data()
# 2、处理数据， 归一化，维度拓展，类型
self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)
self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)
self.train_label = self.train_label.astype(np.int32)
self.test_label = self.test_label.astype(np.int32)
# 获取一个变量接收数据量
self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]
def get_batch(self, batch_size):
"""按照训练获取指定大小数据的批次数据
:param batch_size: 每批次数据的大小
:return:
"""
# 获取随机生成的batch_size大小的下标
index = np.random.randint(0, self.train_data.shape[0], batch_size)
return self.train_data[index, :], self.train_label[index]
class MLP(tf.keras.Model):
"""自定义MLP类
"""
def __init__(self):
super().__init__()
# 卷积到全连接层的数据形状处理
self.flatten = tf.keras.layers.Flatten()
self.dense1 = tf.keras.layers.Dense(units=100, activation=tf.nn.relu)
self.dense2 = tf.keras.layers.Dense(units=10)
def call(self, inputs):
"""
:param inputs: 模型的输入
:return:
"""
# 此例子中输入[batch_size, 28 ,28, 1]
x = self.flatten(inputs)
x = self.dense1(x)
x = self.dense2(x)
# 经过softmax计算[batch_size, 10]
output = tf.nn.softmax(x)
return output
class CNN(tf.keras.Model):
"""自定义CNN类，两层卷积池化+两个全连接层
"""
def __init__(self):
super().__init__()
# 两层卷积池化+两个全连接层
# [batch_size, 28 ,28, 1]--->[batch_size, 14, 14, 32]
# 第一层：32个filter, 5 * 5, padding=same
self.conv1 = tf.keras.layers.Conv2D(
filters=32, # 卷积核数量
kernel_size=[5, 5], # 卷积核大小
padding='same', # 领填充方式
activation=tf.nn.relu # 激活函数
)
self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
# 第二层：64个filter, 5 * 5, padding=same
# [batch_size, 14 ,14, 32]--->[batch_size, 7, 7, 64]
self.conv2 = tf.keras.layers.Conv2D(
filters=64, # 卷积核数量
kernel_size=[5, 5], # 卷积核大小
padding='same', # 领填充方式
activation=tf.nn.relu # 激活函数
)
self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
# 经过一个形状变化在输入到全连接层网络
self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu)
self.dense2 = tf.keras.layers.Dense(units=10)
def call(self, inputs):
"""模型输入输出构建
:param inputs: 输入[batch_size, 28 ,28, 1]
:return:
"""
x = self.conv1(inputs)
x = self.pool1(x)
x = self.conv2(x)
x = self.pool2(x)
x = self.flatten(x)
x = self.dense1(x)
x = self.dense2(x)
output = tf.nn.softmax(x)
return output
def train():
"""模型训练逻辑
:return:
"""
# 1、从 DataLoader 中随机取一批训练数据，并且初始化模型
mnist = MnistLoader()
# model = MLP()
model = CNN()
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
# 2、将这批数据送入模型，计算出模型的预测值；
# 总共样本len(train_data), 迭代次数epoches表示所有数据过几遍，batch_size:每批次训练的样本32， 64
# 一共需要多少批次 len(train_data)/ batch_size * epoches举例 1000/10 = 10批次才训练完成，10 * 5
num_batches = int(mnist.num_train_data // batch_size * num_epochs)
for batch_index in range(num_batches):
X, y = mnist.get_batch(batch_size)
with tf.GradientTape() as tape:
y_pred = model(X)
# 3、将模型预测值与真实值进行比较，计算损失函数（loss）。这里使用
# tf.keras.losses 中的交叉熵函数作为损失函数；
loss = tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred))
print("批次 %d: 损失 %f" % (batch_index, loss.numpy()))
# 4、计算损失函数关于模型变量的导数；
grads = tape.gradient(loss, model.variables)
# 5、将求出的导数值传入优化器，使用优化器的 apply_gradients 方法更新模型参数以最小化损失函数（优化器的详细使用方法见 前章 ）。
optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))
# 3、对测试数据及进行评估
y_pred = model.predict(mnist.test_data)
# 初始化一个metrics
sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
sparse_categorical_accuracy.update_state(y_true=mnist.test_label, y_pred=y_pred)
print("测试准确率：%f" % (sparse_categorical_accuracy.result()))
return None
if __name__ == '__main__':
# mnist = MnistLoader()
# train_data, train_label = mnist.get_batch(64)
# print(train_data, train_label)
train()
4.4.2 迁移学习(Transfer Learning)-Keras 中预定义的经典卷积神经网络结构
4.4.2.1 介绍
- 定义
- 迁移学习就是利用数据、任务或模型之间的相似性，将在旧的领域学习过或训练好的模型，应用于新的领域这样的一个过程。
- 两个任务的输入属于同一性质：要么同是图像、要么同是语音或其他
迁移学习到底在什么情况下使用呢？有两个方面需要我们考虑的
- 1、当我们有海量的数据资源时，可以不需要迁移学习，机器学习系统很容易从海量数据中学习到一个鲁棒性很强的模型。但通常情况下，我们需要研究的领域可获得的数据极为有限，在少量的训练样本上精度极高，但是泛化效果极差。
- 2、训练成本，很少去从头开始训练一整个深度卷积网络，从头开始训练一个卷积网络通常需要较长时间且依赖于强大的 GPU 计算资源。
4.4.2.2 方法
- 最常见的称呼叫做fine tuning,即微调
- 已训练好的模型，称之为Pre-trained model
通常我们需要加载以训练好的模型，这些可以是一些机构或者公司在ImageNet等类似比赛上进行训练过的模型。TensorFlow同样也提供了相关模型地址以及API：https://www.tensorflow.org/api_docs/python/tf/keras/applications
下图是其中包含的一些模型：
2.5.1.3 过程
这里我们举一个例子，假设有两个任务A和B，任务 A 拥有海量的数据资源且已训练好，但并不是我们的目标任务，任务 B 是我们的目标任务。下面的网络模型假设是已训练好的1000个类别模型
而B任务假设是某个具体场景如250个类别的食物识别，那么该怎么去做
- 1、建立自己的网络，在A的基础上，修改最后输出结构，并加载A的模型参数
- 2、根据数据大小调整
- 如果B任务数据量小，那么我们可以选择将A模型的所有的层进行freeze(可以通过Tensorflow的trainable=False参数实现)，而剩下的输出层部分可以选择调整参数训练
- 如果B任务的数据量大，那么我们可以将A中一半或者大部分的层进行freeze,而剩下部分的layer可以进行新任务数据基础上的微调
4.4.2 使用
tf.keras.applications 中有一些预定义好的经典卷积神经网络结构，如 VGG16 、 VGG19 、 ResNet 、 MobileNet 等。我们可以直接调用这些经典的卷积神经网络结构（甚至载入预训练的参数），而无需手动定义网络结构。
-
支持以下结构：
- densenet module: DenseNet models for Keras.
- imagenet_utils module: Utilities for ImageNet data preprocessing & prediction decoding.
- inception_resnet_v2 module: Inception-ResNet V2 model for Keras.
- inception_v3 module: Inception V3 model for Keras.
- mobilenet module: MobileNet v1 models for Keras.
- mobilenet_v2 module: MobileNet v2 models for Keras.
- nasnet module: NASNet-A models for Keras.
- resnet module: ResNet models for Keras.
- resnet50 module: Public API for tf.keras.applications.resnet50 namespace.
- resnet_v2 module: ResNet v2 models for Keras.
- vgg16 module: VGG16 model for Keras.
- vgg19 module: VGG19 model for Keras.
- xception module: Xception V1 model for Keras.
-
我们可以使用以下代码来实例化一个 MobileNetV2 网络结构：
- model = tf.keras.applications.MobileNetV2()
- input_shape ：输入张量的形状（不含第一维的 Batch），大多默认为 224 × 224 × 3 。一般而言，模型对输入张量的大小有下限，长和宽至少为 32 × 32 或 75 × 75 ；
-
include_top ：在网络的最后是否包含全连接层，默认为 True ；
-
weights ：预训练权值，默认为 'imagenet' ，即为当前模型载入在 ImageNet 数据集上预训练的权值。如需随机初始化变量可设为 None ；
-
classes ：分类数，默认为 1000。修改该参数需要 include_top 参数为 True 且 weights 参数为 None 。
当执行以上代码时，TensorFlow 会自动从网络上下载 MobileNetV2 网络结构，因此在第一次执行代码时需要具备网络连接。
可以使用 MobileNetV2 网络对相关数据集进行训练看看效果
model = tf.keras.applications.MobileNetV2(weights=None, classes=5)
4.4.3 总结
- 掌握keras卷积网络相关API
- 卷机网络的构建
- 迁移学习以及tf.keras.applications使用
transfer_learning.py
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input
import numpy as np
import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
class TransferModel(object):
"""VGG迁移学习做5个类别图片识别
"""
def __init__(self):
# 初始化训练集和测试集的迭代器
self.train_generator = ImageDataGenerator(rescale=1.0 / 255.0,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
self.test_generator = ImageDataGenerator(rescale=1.0 / 255.0)
# 数据目录
self.train_dir = "./data/train"
self.test_dir = "./data/test"
# 定义输入数据的大小和批次大小
self.image_size = (224, 224)
self.batch_size = 32
# 初始化VGG基础模型，
self.base_model = VGG16(weights='imagenet', include_top=False)
self.label_dict = {
'0': 'bus',
'1': 'dinosaurs',
'2': 'elephants',
'3': 'flowers',
'4': 'horse'
}
def get_local_data(self):
"""读取本地的图片数据以及类别标签
:return:
"""
# 1、datagen.flow_from_directory
train_gen = self.train_generator.flow_from_directory(self.train_dir,
target_size=self.image_size,
batch_size=self.batch_size,
class_mode='binary',
shuffle=True)
test_gen = self.train_generator.flow_from_directory(self.test_dir,
target_size=self.image_size,
batch_size=self.batch_size,
class_mode='binary',
shuffle=True)
return train_gen, test_gen
def refine_base_model(self):
"""
修改VGG的模型，在VGG的5个block，[None, ?, ?, 512]--->全局平均池化-->两个全连接层1024, 5
:return: 新的迁移学习模型
"""
# 1、获取VGG模型的输出，不包含原有模型的top结构
x = self.base_model.outputs[0]
# 2、在VGG的输出之后定义自己的模型
x = tf.keras.layers.GlobalAveragePooling2D()(x)
# 两个全连接层
x = tf.keras.layers.Dense(1024, activation=tf.nn.relu)(x)
y_predict = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
# 3、使用Model封装新的模型返回
transfer_model = tf.keras.models.Model(inputs=self.base_model.inputs, outputs=y_predict)
return transfer_model
def freeze_vgg_model(self):
"""
冻结VGG的前面卷积结构，不参与训练
:return:
"""
# 循环获取base_model当中的层
for layer in self.base_model.layers:
layer.trainable = False
return None
def compile(self, model):
"""
编译模型，指定优化器损失计算方式，准确率衡量
:return:
"""
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=['accuracy'])
return None
def fit_generator(self, model, train_gen, test_gen):
"""进行模型训练，注意使用fit_generator,不是fit
:param model:
:param train_gen:
:param test_gen:
:return:
"""
modelckpt = tf.keras.callbacks.ModelCheckpoint('./ckpt/transfer_{epoch:02d}-{val_accuracy:.2f}.h5',
monitor='val_accuracy',
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
model.fit_generator(train_gen, epochs=3, validation_data=test_gen, callbacks=[modelckpt])
return None
def predict(self, model):
"""预测输入图片的类别
:return:
"""
# 1、加载模型训练好的权重
model.load_weights("./ckpt/transfer_01-0.84.h5")
# 2、读取图片处理图片数据，形状，数据归一化
image = tf.io.read_file("./data/test/dinosaurs/402.jpg")
image_decoded = tf.image.decode_jpeg(image)
image_resized = tf.image.resize(image_decoded, [224, 224]) / 255.0
# 3维-->4维的形状改变
img = tf.reshape(image_resized, (1, image_resized.shape[0], image_resized.shape[1], image_resized.shape[2]))
print("修改之后的形状：", img.shape)
# 3、输入数据做预测
y_predict = model.predict(img)
index = np.argmax(y_predict, axis=1)
print(self.label_dict[str(index[0])])
return None
if __name__ == '__main__':
tm = TransferModel()
# # 训练模型步骤
# # 1、读取数据
# train_gen, test_gen = tm.get_local_data()
# # print(train_gen, test_gen)
# # 2、定义模型去微调模型和冻结模型
# # 3、模型的compile和训练
# model = tm.refine_base_model()
# print(model.summary())
# tm.freeze_vgg_model()
# tm.compile(model)
# tm.fit_generator(model, train_gen, test_gen)
# 测试数据
transfer_model = tm.refine_base_model()
tm.predict(transfer_model)
fashion_mnist.py
import tensorflow as tf
import numpy as np
import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
num_epochs = 10
batch_size = 64
learning_rate = 0.001
class MnistLoader(object):
"""数据加载处理类
"""
def __init__(self):
# 1、获取数据
(self.train_data, self.train_label), (self.test_data, self.test_label) = \
tf.keras.datasets.fashion_mnist.load_data()
# 2、处理数据， 归一化，维度拓展，类型
self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)
self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)
self.train_label = self.train_label.astype(np.int32)
self.test_label = self.test_label.astype(np.int32)
# 获取一个变量接收数据量
self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]
def get_batch(self, batch_size):
"""按照训练获取指定大小数据的批次数据
:param batch_size: 每批次数据的大小
:return:
"""
# 获取随机生成的batch_size大小的下标
index = np.random.randint(0, self.train_data.shape[0], batch_size)
return self.train_data[index, :], self.train_label[index]
class MLP(tf.keras.Model):
"""自定义MLP类
"""
def __init__(self):
super().__init__()
# 卷积到全连接层的数据形状处理
self.flatten = tf.keras.layers.Flatten()
self.dense1 = tf.keras.layers.Dense(units=128, activation=tf.nn.relu)
self.dense2 = tf.keras.layers.Dense(units=10)
def call(self, inputs):
"""
:param inputs: 模型的输入
:return:
"""
# 此例子中输入[batch_size, 28 ,28, 1]
x = self.flatten(inputs)
x = self.dense1(x)
x = self.dense2(x)
# 经过softmax计算[batch_size, 10]
output = tf.nn.softmax(x)
return output
class CNN(tf.keras.Model):
"""自定义CNN类，两层卷积池化+两个全连接层
"""
def __init__(self):
super().__init__()
# 两层卷积池化+两个全连接层
# [batch_size, 28 ,28, 1]--->[batch_size, 14, 14, 32]
# 第一层：32个filter, 5 * 5, padding=same
self.conv1 = tf.keras.layers.Conv2D(
filters=32, # 卷积核数量
kernel_size=[3, 3], # 卷积核大小
padding='same', # 领填充方式
activation=tf.nn.relu, # 激活函数
kernel_regularizer=tf.keras.regularizers.l2(0.0001)
)
self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
# 第二层：64个filter, 5 * 5, padding=same
# [batch_size, 14 ,14, 32]--->[batch_size, 7, 7, 64]
self.conv2 = tf.keras.layers.Conv2D(
filters=64, # 卷积核数量
kernel_size=[3, 3], # 卷积核大小
padding='same', # 领填充方式
activation=tf.nn.relu, # 激活函数
kernel_regularizer=tf.keras.regularizers.l2(0.0001)
)
self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
# 经过一个形状变化在输入到全连接层网络
self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu, kernel_regularizer=tf.keras.regularizers.l2(0.0001))
self.dropout = tf.keras.layers.Dropout(rate=0.4)
self.dense2 = tf.keras.layers.Dense(units=10)
def call(self, inputs):
"""模型输入输出构建
:param inputs: 输入[batch_size, 28 ,28, 1]
:return:
"""
x = self.conv1(inputs)
x = self.pool1(x)
x = self.conv2(x)
x = self.pool2(x)
x = self.flatten(x)
x = self.dense1(x)
# x = self.dropout(x, training=True)
x = self.dense2(x)
output = tf.nn.softmax(x)
return output
def train():
"""模型训练逻辑
:return:
"""
# 1、从 DataLoader 中随机取一批训练数据，并且初始化模型
mnist = MnistLoader()
# model = MLP()
model = CNN()
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
# 2、将这批数据送入模型，计算出模型的预测值；
# 总共样本len(train_data), 迭代次数epoches表示所有数据过几遍，batch_size:每批次训练的样本32， 64
# 一共需要多少批次 len(train_data)/ batch_size * epoches举例 1000/10 = 10批次才训练完成，10 * 5
num_batches = int(mnist.num_train_data // batch_size * num_epochs)
for batch_index in range(num_batches):
X, y = mnist.get_batch(batch_size)
with tf.GradientTape() as tape:
y_pred = model(X)
# 3、将模型预测值与真实值进行比较，计算损失函数（loss）。这里使用
# tf.keras.losses 中的交叉熵函数作为损失函数；
loss = tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred))
print("批次 %d: 损失 %f" % (batch_index, loss.numpy()))
# 4、计算损失函数关于模型变量的导数；
grads = tape.gradient(loss, model.variables)
# 5、将求出的导数值传入优化器，使用优化器的 apply_gradients 方法更新模型参数以最小化损失函数（优化器的详细使用方法见 前章 ）。
optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))
# 3、对测试数据及进行评估
y_pred = model.predict(mnist.test_data)
# 初始化一个metrics
sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
sparse_categorical_accuracy.update_state(y_true=mnist.test_label, y_pred=y_pred)
print("测试准确率：%f" % (sparse_categorical_accuracy.result()))
return None
if __name__ == '__main__':
# mnist = MnistLoader()
# train_data, train_label = mnist.get_batch(64)
# print(train_data, train_label)
train()
