基于Keras实现猫狗大战,25000张猫狗图像的精准分类

最新推荐文章于 2022-12-23 07:54:51 发布

curd_boy

最新推荐文章于 2022-12-23 07:54:51 发布

阅读量3.2k

点赞数 11

分类专栏：机器学习 # 深度学习文章标签：基于Keras实现猫狗大战

本文链接：https://blog.csdn.net/weixin_43746433/article/details/95533753

版权

机器学习同时被 2 个专栏收录

23 篇文章 11 订阅

订阅专栏

深度学习

3 篇文章 0 订阅

订阅专栏

文章目录

1. 建立简单版CNN网络模型
2. 使用数据增强
3. 预训练网络 + 不增强数据的卷积基提取特征
4.1 预训练网络之特征提取 + 增强数据的特征提取
5.预训练网络之微调模型

猫狗大战kaggle竞赛地址： https://www.kaggle.com/c/dogs-vs-cats
猫狗大战数据集百度网盘：链接： https://pan.baidu.com/s/1S8rvlk98VYL4bB420XzPkA 密码：ia54

1. 建立简单版CNN网络模型

1.1 将下载好的文件分为训练集、测试集、验证集。

import os, shutil

original_dataset_dir = 'D:/软件（学习）/Python/DeepLearning/chapter4/data/kaggle/kaggle_original_data' ##下载好的地址

# The directory where we will
# store our smaller dataset
base_dir = 'D:/软件（学习）/Python/DeepLearning/chapter4/data/kaggle/cats_and_dogs_small'  ##分好的数据集地址
os.mkdir(base_dir)

# Directories for our training,
# validation and test splits
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)

# Directory with our training cat pictures
train_cats_dir = os.path.join(train_dir, 'cats')
os.mkdir(train_cats_dir)

# Directory with our training dog pictures
train_dogs_dir = os.path.join(train_dir, 'dogs')
os.mkdir(train_dogs_dir)

# Directory with our validation cat pictures
validation_cats_dir = os.path.join(validation_dir, 'cats')
os.mkdir(validation_cats_dir)

# Directory with our validation dog pictures
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
os.mkdir(validation_dogs_dir)

# Directory with our validation cat pictures
test_cats_dir = os.path.join(test_dir, 'cats')
os.mkdir(test_cats_dir)

# Directory with our validation dog pictures
test_dogs_dir = os.path.join(test_dir, 'dogs')
os.mkdir(test_dogs_dir)

# Copy first 1000 cat images to train_cats_dir
fnames = ['cat.{}.jpg'.format(i) for i in range(1000)]   #1-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)

# Copy next 500 cat images to validation_cats_dir
fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)] #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)

# Copy next 500 cat images to test_cats_dir
fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)] #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)

# Copy first 1000 dog images to train_dogs_dir
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)

# Copy next 500 dog images to validation_dogs_dir
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)

# Copy next 500 dog images to test_dogs_dir
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)

print('total training cat images:', len(os.listdir(train_cats_dir)))
print('total training dog images:', len(os.listdir(train_dogs_dir)))
print('total validation cat images:', len(os.listdir(validation_cats_dir)))
print('total validation dog images:', len(os.listdir(validation_dogs_dir)))
print('total test cat images:', len(os.listdir(test_cats_dir)))
print('total test dog images:', len(os.listdir(test_dogs_dir)))

图片分类如下：
在这里插入图片描述

1.2 构建神经网络

###5.2.3
# 5-5将猫狗分类的小型卷积神经网络实例化
from keras import layers
from 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'))
model.summary()

from keras import optimizers #配置模型用于训练
model.compile(loss='binary_crossentropy',
              optimizer=optimizers.RMSprop(lr=1e-4),
              metrics=['acc'])

1.3 数据预处理

读取图片文件；
将jpg解码成RGB像素点；
将这些像素点转换成浮点型张量；
将[0, 255]区间的像素值减小到[0, 1]区间中，CNN更喜欢处理小的输入值。

train_dir='../data/kaggle/cats_and_dogs_small/train'
validation_dir='../data/kaggle/cats_and_dogs_small/validation'

###5-7 使用 ImageDataGenerator 从目录中读取图像
from keras.preprocessing.image import ImageDataGenerator
# All images will be rescaled by 1./255
train_datagen = ImageDataGenerator(rescale=1./255)  #所有图像乘1/255缩放
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
        # This is the target directory
        train_dir,    
        target_size=(150, 150),  # All images will be resized to 150x150  
        batch_size=20,
        # Since we use binary_crossentropy loss, we need binary labels
        class_mode='binary')  #使用binary_crossentropy，需用二进制标签

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

history = model.fit_generator(
#利用批量生成器拟合模型,用fit_generator向模型中填充数据,生成器函数，生成器的输出应该为：一个形如（inputs，targets）的tuple,一个形如（inputs, targets,sample_weight）的tuple。
#所有的返回值都应该包含相同数目的样本。生成器将无限在数据集上循环。每个epoch以经过模型的样本数达到samples_per_epoch时，记一个epoch结束
      train_generator,
      steps_per_epoch=50,#整数，当生成器返回steps_per_epoch次数据时计一个epoch结束，执行下一个epoch
      epochs=10, #整数，数据迭代的轮数
      validation_data=validation_generator,  #具有以下三种形式之一生成验证集的生成器,
      #一个形如（inputs,targets）的tuple,一个形如（inputs,targets，sample_weights）的tuple
      validation_steps=20) #当validation_data为生成器时，本参数指定验证集的生成器返回次数
###5-9
model.save('cats_and_dogs_small_1.h5')  #保存模型

1.4 绘制训练过程中的损失曲线和精度曲线

#5-10  #绘制训练过程中的损失曲线和精度曲线
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(len(acc))

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.savefig('../tmp/Training and validation acc.png')

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.savefig('../tmp/Training and validation loss.png')
plt.show()

训练结果：
分析
训练曲线的最大特征就是过拟合。训练集上的准确率线性增加，接近100%，而验证集上的准确率是在70%~72%之间。同样的，训练集上的loss线性下降趋于0，而验证集上的loss在迭代5个epoch之后趋于上升。
由于训练样本只选取了2000个，因此数据量不足是过拟合的最大的问题。缓解过拟合的方法有很多，诸如：dropout、L2-norm等等。在这里，我们使用**增大数据（data augmentation）**的方式来试一试解决过拟合，这种方法也是处理图片分类的通常做法。

2. 使用数据增强

增强数据
过拟合是由于学习到样本量过小导致的，使得我们训练的模型对于新的数据没有很好的泛化能力。增大数据（data augmentation）是在已有的训练样本上增加数据的一种最好的方式。增大数据是通过随机的改变那些已经被模型“记住”的图片，通过缩放、裁剪、拉伸图片来使得模型不会两次见到同一张图片。
在Keras中是通过ImageDataGenerator来实现，看一个例子：

2.1 显示几个随机增强后的训练图像

###5.2.5 使用ImageDataGenerator实例读取图像执行多次随即变换数据增强
##5-11
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
import os
train_cats_dir = os.path.join(train_dir, 'cats')
fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]

# We pick one image to "augment"
img_path = fnames[3]

# Read the image and resize it
img = image.load_img(img_path, target_size=(150, 150))

# Convert it to a Numpy array with shape (150, 150, 3)
x = image.img_to_array(img)

# Reshape it to (1, 150, 150, 3)
x = x.reshape((1,) + x.shape)

# The .flow() command below generates batches of randomly transformed images.
# It will loop indefinitely, so we need to `break` the loop at some point!
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，并将batch_size调大为32，epoch调大至100，再来看看效果。

2.2 定义含dropout的新卷积神经网络，进一步降低过拟合

#5-13 定义一个含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'])

2.3 利用数据增强器，训练卷积网络神经

rain_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,)

# Note that the validation data should not be augmented!
test_datagen = ImageDataGenerator(rescale=1./255)  #测试集不能增强！

train_generator = train_datagen.flow_from_directory(
        # This is the target directory
        train_dir,
        # All images will be resized to 150x150
        target_size=(150, 150),
        batch_size=32,
        # Since we use binary_crossentropy loss, we need binary labels
        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=100,
      epochs=10,
      validation_data=validation_generator,
      validation_steps=50)

model.save('cats_and_dogs_small_2.h5') #保存第二个模型

2.4 绘制使用数据增强和dropout 训练过程中的损失曲线和精度曲线

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

epochs = range(len(acc))

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

训练结果：
分析
我们可以看出在准确率上有很大的提升，训练集和验证集上的准确率是在85%~86%之间。同样的，训练集和验证集上的loss均趋于0.35以下，未出现大幅度的过拟合。那么我们思考一下，如何将准确率达到90%以上，有一种很好的优化方式就是使用预训练模型。

3. 预训练网络 + 不增强数据的卷积基提取特征

预训练卷积网络
由于我们的数据样本本身就少，那么想要追求高准确率，需要基于大数据集图片分类的预先训练好的网络，例如ImageNet。由于ImageNet的数据量无比之大（1.4 million 已经标注的图片，1000个不同的类别），那么我们用ImageNet预先训练好的网络来对我们的猫狗进行提取特征，可见这个预训练网络可以为大多数不同的计算机视觉分类的问题提供很大的帮助。ImageNet中包含了许多的动物类别，包含不同品种的猫和狗，因此我们期望很够很好的提升猫狗大战的准确率。
我们选用VGG16的结构，得益于它在ImageNet中良好的表现，VGG16不仅简单而且好用，不需要引入其他的概念，还有一些其他的模型，它们都有一些很优雅的名字-VGG，ResNet， Inception-ResNet，Xception等等。
预训练网络使用方式
特征提取 and 微调
特征提取
特征提取是用一个之前的已经训练好的网络结构，利用这些已经训练好的参数来对于新的样本提取有趣的特征。之后，将这些提取出的特征送入一个新的分类器。我们将卷积层的模型称之为基线卷积，这一部分是已经有训练好的，算是被冻结了，不需要修改的，我们需要做的就是定义全连接层，定义新的分类器。

3.1 将VGG16卷积实例化

采用VGG16作为基线卷积

from keras.applications import VGG16

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

3.2 数据准备

###5-17
import os
import numpy as np
from keras.preprocessing.image import ImageDataGenerator

base_dir = '../data/kaggle/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')

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

3.3 从预训练的基线卷积层中提取特征

不使用数据增强使用预训练的卷积基提取特征

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
    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:
            # Note that since generators yield data indefinitely in a loop,
            # we must `break` after every image has been seen once.
            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)

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

3.4 建立模型

from keras import models
from keras import layers
from 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))

3.5 绘制使用预训练网络特征提取 + 不增强数据的损失曲线和精度曲线

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(len(acc))

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

4.1 预训练网络之特征提取 + 增强数据的特征提取

4.1 预训练网络之特征提取

###5-20 使用数据增强提取特征
from  keras import models
from keras import layers
from keras.applications import VGG16


conv_base = VGG16(weights='imagenet',
                  include_top=False,
                  input_shape=(150, 150, 3))
conv_base.summary()
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'))
model.summary()

print('This is the number of trainable weights '
      'before freezing the conv base:', len(model.trainable_weights))
conv_base.trainable = False

print('This is the number of trainable weights '
      'after freezing the conv base:', len(model.trainable_weights))
      ###5-21 使用冻结的卷积基 训练模型

4.2 增强数据

from keras.preprocessing.image import ImageDataGenerator

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

# Note that the validation data should not be augmented!
test_datagen = ImageDataGenerator(rescale=1./255)

import os
from keras import models
from keras import layers
from keras import optimizers
base_dir = '../data/kaggle/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')

train_generator = train_datagen.flow_from_directory(
        # This is the target directory
        train_dir,
        # All images will be resized to 150x150
        target_size=(150, 150),
        batch_size=20,
        # Since we use binary_crossentropy loss, we need binary labels
        class_mode='binary')

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

4.3 建立模型

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,
      verbose=2)
model.save('cats_and_dogst_small_3.h5')

4.4 预训练网络之特征提取 + 增强数据的特征提取的曲线和精度曲线

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))

import matplotlib.pyplot as plt
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()

5.预训练网络之微调模型

微调（Fine-tuning）
这也是另一种重用预训练模型的一种方式，微调就是我们解冻之前固定的VGG16模型，进行细微的调整，使模型与我们的问题更相关。
1）在一个已经训练好的基线网络上添加自定义网络；
2）冻结基线网络；
3）训练我们所添加的部分；
4）解冻一些基线网络中的卷积层；
5）将我们所添加的部分与解冻的卷积层相连接；
网络模型
我们将VGG16中的第5大卷积层解冻，和全连接层一起参与训练，更新参数。同时，加入测试集，并对测试集最后计算结果进行平滑处理。同样，我们增加了数据量来防止过拟合，我们训练试一试。

5.1 VGG16中的第基线网络中第5大卷积层解冻

from keras.applications import VGG16

conv_base = VGG16(weights='imagenet',
                  include_top=False,
                  input_shape=(150, 150, 3))
conv_base.summary()
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

5.2 模型的构建

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)
model.save('cats_and_dogs_small_4.h5')

5.3 绘制训练集和验证集的精度和损失值图

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

epochs = range(len(acc))

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

5.4 计算结果进行平滑处理

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.legend()
plt.show()

5.5 测试集在数据生成器上评估模型的损失值和精度值

test_generator = test_datagen.flow_from_directory(
        test_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')
test_loss, test_acc = model.evaluate_generator(test_generator, steps=50)
print('test acc:', test_acc)

model.evaluate_generator参数
generator: 一个生成 (inputs, targets) 或 (inputs, targets, sample_weights) 的生成器，或一个 Sequence (keras.utils.Sequence) 对象的实例，以避免在使用多进程时数据的重复。
steps: 在声明一个 epoch 完成并开始下一个 epoch 之前从 generator 产生的总步数（批次样本）。它通常应该等于你的数据集的样本数量除以批量大小。对于 Sequence，它是可选的：如果未指定，将使用len(generator) 作为步数。
预训练网络之微调模型—训练结果与分析
训练结果
测试结果能够保持在90%~91%，但是始终没有训练到95%以上

参考文章：https://blog.csdn.net/apengpengpeng/article/details/80866029