Deep Learning with Python 5-1

[Yukyukuon]

书第五章：机器学习基础

卷积神经网络（convnet）

Keras Conv2D官方说明：https://keras.io/api/layers/convolution_layers/ 卷积神经网络接收形状为(image_height, image_width, image_channels)的输入张量（不包括批量维度）

tf.keras.layers.Conv2D(
    filters,
    kernel_size,
    strides=(1, 1),
    padding="valid",
    data_format=None,
    dilation_rate=(1, 1),
    groups=1,
    activation=None,
    use_bias=True,
    kernel_initializer="glorot_uniform",
    bias_initializer="zeros",
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    **kwargs
)

• filters ：整数，输出空间的维度（即卷积中输出滤波器的数量）,或者叫卷积核个数，这个与卷积后的输出通道数一样
• kernel_size ：卷积核尺寸，一般为3×3，或者5×5，此处用2个整数的元组或列表表示，比如（3,3），[5,5],如果height, width长宽一样，直接用一个整数表示就行，比如3或者5，卷积后的，卷积后的height，width的计算公式如下：滑动步长为strides，卷积核的尺寸为S，输入的尺寸为P，padding = ‘valid“，height =width = (P-S)/strides +1
• strides：滑动步长，默认横向和纵向滑动均为1
• padding = “valid”：默认是边缘不填充，另一个取值为 “same”，表示边缘用0填充，如果padding =“same”，则输出的形状为 height =width = P/strides ，向上取整
• data_format：输入的数据格式，此处只有两个取值 ，“channels_first”,和“channels_last”，即输入的数据格式中，通道数是第一个还是最后一个，默认为“channels_last”,即默认输入数据的格式中，通道数为最后一个
• dalition_rate：卷积核的膨胀系数
• activation：激活函数
• use_bias：偏置项，此处取值为布尔值，0或者1,0表示没有增加bias，1表示有

计算参数

卷积核大小：kernel_size 输入数据的层数：input_layer 截距项，偏置项：bias 输出的层数：output_layer Params = (kernel_size input_layer + bias) output_layer

卷积运算

密集连接层和卷积层的根本区别在于，Dense 层从输入特征空间中学到的是全局模式，而卷积层学到的是局部模式。 卷积神经网络具有以下两个有趣的性质：

• 卷积神经网络学到的模式具有平移不变性（translation invariant）
• 卷积神经网络可以学到模式的空间层次结构（spatial hierarchies of patterns）

对于包含两个空间轴（高度和宽度）和一个深度轴（也叫通道轴）的3D 张量，其卷积也叫特征图（feature map）。

卷积由以下两个关键参数所定义：

• 从输入中提取的图块尺寸
• 输出特征图的深度

输出的宽度和高度可能与输入的宽度和高度不同，不同的原因可能有两点：

• 边界效应，可以通过对输入特征图进行填充来抵消。
• 使用了步幅（stride）

最大池化运算（The Max-pooling operation）

最大池化的作用：对特征图进行下采样，与步进卷积类似。 最大池化是从输入特征图中提取窗口，并输出每个通道的最大值。最大池化使用硬编码的max 张量运算对局部图块进行变换，而不是使用学到的线性变换（卷积核）。最大池化与卷积的最大不同之处在于，最大池化通常使用2×2 的窗口和步幅2，其目的是将特征图下采样2 倍。与此相对的是，卷积通常使用3×3 窗口和步幅1。

简而言之，使用下采样的原因，一是减少需要处理的特征图的元素个数，二是通过让连续卷积层的观察窗口越来越大（即窗口覆盖原始输入的比例越来越大），从而引入空间过滤器的层级结构。

实例：猫狗大战

配置数据集

使用的是Kaggle的猫狗分类数据集：https://www.kaggle.com/competitions/dogs-vs-cats 处理前：这个数据集包含25 000 张猫狗图像（每个类别都有12 500 张），大小为543MB

• 训练集：data/kaggle_original_data/train（12 500 张猫狗图片，带标注）
• 测试集：data/kaggle_original_data/test1（12 500 张猫狗照片，不带标注）

处理后：创建一个新数据集，其中包含三个子集：每个类别各1000 个样本的训练集、每个类别各500 个样本的验证集和每个类别各500 个样本的测试集。

• 训练集：data/cats_and_dogs_small/train
  • 训练用猫的文件：data/cats_and_dogs_small/train/cats
  • 训练用狗的文件：data/cats_and_dogs_small/train/dogs
• 验证集：data/cats_and_dogs_small/validation
  • 验证用猫的文件：data/cats_and_dogs_small/validation/cats
  • 验证用狗的文件：data/cats_and_dogs_small/validation/dogs
• 测试集：data/cats_and_dogs_small/test
  • 测试分类后猫保存的文件：data/cats_and_dogs_small/test/cats
  • 测试分类后狗保存的文件：data/cats_and_dogs_small/test/dogs

import os, shutil
# 改变当前工作目录到指定的路径
os.chdir("/home/yifanjia/workspace")

# 创建处理后文件夹位置
original_dataset_dir = 'data/kaggle_original_data/train'
base_dir = 'data/cats_and_dogs_small'
os.mkdir(base_dir)
train_dir = os.path.join(base_dir, 'train')
os.mkdir(train_dir)
validation_dir = os.path.join(base_dir, 'validation')
os.mkdir(validation_dir)
test_dir = os.path.join(base_dir, 'test')
os.mkdir(test_dir)

train_cats_dir = os.path.join(train_dir, 'cats')
os.mkdir(train_cats_dir)
train_dogs_dir = os.path.join(train_dir, 'dogs')
os.mkdir(train_dogs_dir)
validation_cats_dir = os.path.join(validation_dir, 'cats')
os.mkdir(validation_cats_dir)
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
os.mkdir(validation_dogs_dir)
test_cats_dir = os.path.join(test_dir, 'cats')
os.mkdir(test_cats_dir)
test_dogs_dir = os.path.join(test_dir, 'dogs')
os.mkdir(test_dogs_dir)

#复制cat图片到处理后的文件夹
fnames = ['cat.{}.jpg'.format(i) for i in range(1000)]
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname)
    dst = os.path.join(train_cats_dir, fname)
    shutil.copyfile(src, dst)

fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)]
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname)
    dst = os.path.join(validation_cats_dir, fname)
    shutil.copyfile(src, dst)

fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)]
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname)
    dst = os.path.join(test_cats_dir, fname)
    shutil.copyfile(src, dst)

# 复制dog图片到处理后文件夹
fnames = ['dog.{}.jpg'.format(i) for i in range(1000)]
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname)
    dst = os.path.join(train_dogs_dir, fname)
    shutil.copyfile(src, dst)

fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)]
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname)
    dst = os.path.join(validation_dogs_dir, fname)
    shutil.copyfile(src, dst)

fnames = ['dog.{}.jpg'.format(i) for i in range(1500, 2000)]
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname)
    dst = os.path.join(test_dogs_dir, fname)
    shutil.copyfile(src, dst)

构建网络

初始输入的尺寸为150×150，所以最后在Flatten 层之前的特征图大小为7×7

from tensorflow.keras import layers
from tensorflow.keras import models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu',
                        input_shape=(150, 150, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

编译模型

使用RMSprop 优化器。因为网络最后一层是单一sigmoid单元，所以我们将使用二元交叉熵作为损失函数

from tensorflow.keras import optimizers
model.compile(loss='binary_crossentropy',
              optimizer=optimizers.RMSprop(lr=1e-4),
              metrics=['acc'])

数据预处理

1. 读取图像文件
2. 将JPEG 文件解码为RGB 像素网格
3. 将这些像素网格转换为浮点数张量
4. 将像素值（0~255 范围内）缩放到[0, 1] 区间（正如你所知，神经网络喜欢处理较小的输入值）

Keras有一个图像处理辅助工具的模块，位于keras.preprocessing.image。特别地，它包含ImageDataGenerator 类，可以快速创建Python 生成器，能够将硬盘上的图像文件自动转换为预处理好的张量批量。

ImageDataGenerator()是keras.preprocessing.image模块中的图片生成器，可以每一次给模型“喂”一个batch_size大小的样本数据，同时也可以在每一个批次中对这batch_size个样本数据进行增强，扩充数据集大小，增强模型的泛化能力。比如进行旋转，变形，归一化等等。

# 使用ImageDataGenerator 从目录中读取图像
# rescale 重缩放因子。rescale的作用是对图片的每个像素值均乘上这个放缩因子，
# 这个操作在所有其它变换操作之前执行，在一些模型当中，直接输入原图的像素值可能会落入激活函数的“死亡区”，
# 因此设置放缩因子为1/255，把像素值放缩到0和1之间有利于模型的收敛，避免神经元“死亡”。
from tensorflow.keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale=1./255)
validation_datagen = ImageDataGenerator(rescale=1./255)

flow_from_directory（）加载数据，

• 指定train，valid，test的目录
• target_size：默认为(256, 256). 图像将被resize成该尺寸
• batch_size：批量数据的尺寸（默认：32）
• class_mode："categorical", "binary", "sparse", "input", "other" or None 之一。 默认："categorical"。决定返回标签数组的类型
  • "categorical" 将是 2D one-hot 编码标签
  • "binary" 将是 1D 二进制标签
  • "sparse" 将是 1D 整数标签
  • "input" 将是与输入图像相同的图像（主要用于与自动编码器一起使用）
  • "other" 将是 y_col 数据的 numpy 数组
  • None, 不返回任何标签，生成器只会产生批量的图像数据

# 读取指定文件，子文件有cats和dogs，会自动识别在相同文件夹里为相同一类
train_generator = train_datagen.flow_from_directory(
        train_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

validation_generator = validation_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

生成器的输出：生成了150×150 的RGB 图像［形状为(20,150, 150, 3)］与二进制标签［形状为(20,)］组成的批量。

注意，生成器会不停地生成这些批量，它会不断循环目标文件夹中的图像。

拟合模型

因为是生成器生成的数据，使用fit_generator 方法来拟合，它在数据生成器上的效果和fit 相同。

• 第一个参数应该是一个Python 生成器，可以不停地生成输入和目标组成的批量，比如train_generator
• steps_per_epoch：每一个epoch需要从生成器中抽取多少个样本 = data / 生成器的batch_size
• epochs：轮次
• validation_data：这个参数可以是一个数据生成器，但也可以是Numpy 数组组成的元组
• validation_steps：验证生成器为输入时，指定此参数，从验证生成器中抽取多少个批次用于评估 = validation_data / batch_size

history = model.fit_generator(
        train_generator,
        steps_per_epoch=100,
        epochs=30,
        validation_data=validation_generator,
        validation_steps=50)

保存模型

model.save('cats_and_dogs_small_1.h5')

绘制曲线

import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

数据增强

过拟合是学习样本太少，导致无法训练出能够泛化到新数据的模型。数据增强是从现有的训练样本中生成更多的训练数据，其方法是利用多种能够生成可信图像的随机变换来增加（augment）样本。

在Keras 中，这可以通过对ImageDataGenerator 实例读取的图像执行多次随机变换来实现：

• rotation_range：是角度值（在 0~180 范围内），表示图像随机旋转的角度范围。
• width_shift 和 height_shift：图像在水平或垂直方向上平移的范围（相对于总宽度或总高度的比例）。
• shear_range：随机错切变换的角度。让所有点的x坐标(或者y坐标)保持不变，而对应的y坐标(或者x坐标)则按比例发生平移，且平移的大小和该点到x轴(或y轴)的垂直距离成正比。
• zoom_range：图像随机缩放的范围。
• horizontal_flip：随机将一半图像水平翻转。
• fill_mode=‘nearest’：填充模式，默认为最近原则，比如一张图片向右平移，那么最左侧部分会被临近的图案覆盖

查看数据增强图片

# 数据增强例子
datagen = ImageDataGenerator(
        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')

# 显示几个随机增强后的训练图像
from keras.preprocessing import image  //图像预处理工具的模块

fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]
img_path = fnames[110]  //选择一张图片
img = image.load_img(img_path, target_size=(150, 150))  //读取图片并调整大小
x = image.img_to_array(img)  //将其转换为形状(150, 150, 3) 的Numpy 数组
x = x.reshape((1,) + x.shape)  //将其形状改变为(1, 150, 150, 3)

# 生成随机变换后的图像批量。循环是无限的，因此你需要在某个时刻终止循环
i = 0
for batch in datagen.flow(x, batch_size=1):
    plt.figure(i)
    imgplot = plt.imshow(image.array_to_img(batch[0]))
    i += 1
    if i % 4 == 0:
        break
plt.show()

Dropout + 数据增强

# 定义一个包含dropout 的新卷积神经网络
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu',
                       input_shape=(150, 150, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer=optimizers.RMSprop(lr=1e-4),
              metrics=['acc'])

# 利用数据增强生成器训练卷积神经网络
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,)
test_datagen = ImageDataGenerator(rescale=1./255)  //验证集不能用数据增强

train_generator = train_datagen.flow_from_directory(
        train_dir,
        target_size=(150, 150),
        batch_size=32,
        class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        batch_size=32,
        class_mode='binary')

# 拟合
history = model.fit_generator(
    train_generator,
    steps_per_epoch=63,
    epochs=100,
    validation_data=validation_generator,
    validation_steps=32)
# 保存模型
model.save('./model/cats_and_dogs_small_2.h5')

使用预训练的卷积网络（pretrained network）

预训练网络（pretrained network）是一个保存好的网络，之前已在大型数据集（通常是大规模图像分类任务）上训练好。如果这个原始数据集足够大且足够通用，那么预训练网络学到的特征的空间层次结构可以有效地作为视觉世界的通用模型，因此这些特征可用于各种不同的计算机视觉问题，即使这些新问题涉及的类别和原始任务完全不同。

使用预训练网络有两种方法：特征提取（feature extraction）和微调模型（fine-tuning）

特征提取（feature extraction）

特征提取是使用之前网络学到的表示来从新样本中提取出有趣的特征。然后将这些特征输入一个新的分类器，从头开始训练。 对于卷积神经网络而言，特征提取就是取出之前训练好的网络的卷积基（convolutional base），在上面运行新数据，然后在输出上面训练一个新的分类器

# 将VGG16 卷积基实例化
from tensorflow.keras.applications import VGG16

conv_base = VGG16(weights='imagenet',
                 include_top=False,
                 input_shape=(150, 150, 3))

# 数据准备
import os
import numpy as np
from tensorflow.keras.preprocessing.image import ImageDataGenerator

base_dir = "../data/cats_and_dogs_small"
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')
test_dir = os.path.join(base_dir, 'test')

• weights 指定模型初始化的权重检查点。（此处是保留在imagenet训练的参数）
• include_top 指定模型最后是否包含密集连接分类器。
• input_shape 是输入到网络中的图像张量的形状。这个参数完全是可选的，如果不传入这个参数，那么网络能够处理任意形状的输入。

接下来，添加密集连接分类器有两种方法：

• （不做数据增强）数据集上运行卷积基，将输出保存成硬盘中的Numpy 数组，然后用这个数据作为输入，输入到独立的密集连接分类器中。
• （做数据增强）在顶部添加 Dense 层来扩展已有模型（即 conv_base），并在输入数据上端到端地运行整个模型。

不使用数据增强的快速特征提取

ImageDataGenerator.flow_from_directory函数的返回值是： 一个产生（x，y）元组的目录迭代器（DirectoryIterator）。 其中x是包含一批（batch_size，* target_size，channels）类型的图像的numpy数组，y是对应标签的numpy数组。

datagen =ImageDataGenerator(rescale=1./255)
batch_size =20

def extract_features(directory, sample_count):
    # 开启储存特征和标签的空间
    features = np.zeros(shape=(sample_count, 4, 4, 512))
    labels = np.zeros(shape=(sample_count))

    generator = datagen.flow_from_directory(
        directory,
        target_size=(150, 150),
        batch_size=batch_size,
        class_mode='binary')
    i = 0

    # 迭代器产生的每个batch数组保存在开启的储存空间中（因为会不断产生数据，所以你必须在读取完所有图像后终止循环）
    for inputs_batch, labels_batch in generator:
        features_batch = conv_base.predict(inputs_batch)
        features[i * batch_size : (i+1) * batch_size] = features_batch
        labels[i * batch_size : (i+1) * batch_size] = labels_batch
        i += 1
        if i * batch_size >= sample_count:
            break
        return features, labels

# 传入数据   
train_features, train_labels = extract_features(train_dir, 2000)
validation_features, validation_labels = extract_features(validation_dir, 1000)
test_features, test_labels = extract_features(test_dir, 1000)

目前，提取的特征形状为(samples, 4, 4, 512)。我们要将其输入到密集连接分类器中，所以首先必须将其形状展平为(samples, 8192)：

train_features = np.reshape(train_features, (2000, 4 * 4 * 512))
validation_features = np.reshape(validation_features, (1000, 4 * 4 * 512))
test_features = np.reshape(test_features, (1000, 4 * 4 * 512))

定义密集连接分类器（注意要使用dropout 正则化），并在刚刚保存的数据和标签上训练这个分类器：

from tensorflow.keras import models
from tensorflow.keras import layers
from tensorflow.keras import optimizers

model = models.Sequential()
model.add(layers.Dense(256, activation='relu', input_dim=4 * 4 *512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='sigmoid'))

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

history = model.fit(train_features, train_labels,
                   epochs=30,
                   batch_size=20,
                   validation_data=(validation_features, validation_labels))

使用数据增强的特征提取

方法就是：扩展conv_base 模型，然后在输入数据上端到端地运行模型。

# 在卷积基上添加一个密集连接分类器
from tensorflow.keras import models
from tensorflow.keras import layers

model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

在编译和训练模型之前，一定要“冻结”卷积基。冻结（freeze）一个或多个层是指在训练过程中保持其权重不变。 在Keras 中，冻结网络的方法是将其trainable 属性设为False。

conv_base.trainable = False

使用数据增强训练模型：

# 利用冻结卷积基端到端的训练模型
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras import optimizers

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')

# 验证资料不做数据增强
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
        train_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

validation_generator =test_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

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

history = model.fit_generator(
    train_generator,
    steps_per_epoch=100,
    epochs=30,
    validation_data=validation_generator,
    validation_steps=50)

绘图

import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

模型微调（fine-tuning）

微调是指将其顶部的几层“解冻”，并将这解冻的几层和新增加的部分（本例中是全连接分类器）联合训练
微调网络的步骤如下：

• 在已经训练好的基网络（base network）上添加自定义网络
• 冻结基网络
• 训练所添加的部分
• 解冻基网络的一些层
• 联合训练解冻的这些层和添加的部分

只有上面的分类器已经训练好了，才能微调卷积基的顶部几层。如果分类器没有训练好，那么训练期间通过网络传播的误差信号会特别大，微调的几层之前学到的表示都会被破坏

微调最后三个卷积层，也就是说，直到block4_pool 的所有层都应该被冻结，而block5_conv1、block5_conv2 和block5_conv3 三层应该是可训练的：

# 冻结直到某一层的所有层
conv_base.trainable = True

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

开始微调网络：

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

history = model.fit_generator(
    train_generator,
    steps_per_epoch=100,
    epochs=100,
    validation_data=validation_generator,
    validation_steps=50)

指数平滑+绘图：

def smooth_curve(points, factor=0.8):
    smoothed_points = []
    for point in points:
        if smoothed_points:
            previous = smoothed_points[-1]
            smoothed_points.append(previous * factor + point * (1 - factor))
        else:
            smoothed_points.append(point)
    return smoothed_points

plt.plot(epochs, smooth_curve(acc), 'bo', label='Smoothed training acc')
plt.plot(epochs, smooth_curve(val_acc), 'b', label='Smoothed validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()

plt.plot(epochs, smooth_curve(loss), 'bo', label='Smoothed training loss')
plt.plot(epochs, smooth_curve(val_loss), 'b', label='Smoothed validation loss')
plt.title('Training and validation loss')
plt.show()