一、图像分类简介

图像分类实质上就是从给定的类别集合中为图像分配对应标签的任务。也就是说我们的任务是分析一个输入图像并返回一个该图像类别的标签

1. 常用数据集

1.1 mnist数据集

手写数字0-9的集合，共有60k训练图像、10k测试图像、10个类别、图像大小28×28×1

from tensorflow.keras.datasets import mnist
# 加载mnist数据集

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

1.2 CIFAR-10和CIFAR-100

CIFAR-10数据集5万张训练图像、1万张测试图像、10个类别、每个类别有6k个图像，图像大小32×32×3
CIFAR-100数据集也是有5万张训练图像、1万张测试图像、包含100个类别、图像大小32×32×3。

import tensorflow as tf
from tensorflow.keras.datasets import cifar10,cifar100
# 加载Cifar10数据集

(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()
# 加载Cifar100数据集

(train_images, train_labels), (test_images, test_labels)= cifar100.load_data()

1.3 ImageNet

是ILSVRC竞赛使用的是数据集，由斯坦福大学李飞飞教授主导；
包含了超过1400万张全尺寸的有标记图片，大约有22000个类别的数据。

二、AlexNet

1. AlexNet的网络架构

# 构建AlexNet模型

net = tf.keras.models.Sequential([
    # 卷积层：96个卷积核，卷积核为11*11，步幅为4，激活函数relu

    tf.keras.layers.Conv2D(filters=96,kernel_size=11,strides=4,activation='relu'),
    # 池化:窗口大小为3*3、步幅为2

    tf.keras.layers.MaxPool2D(pool_size=3, strides=2),
    # 卷积层：256个卷积核，卷积核为5*5，步幅为1，padding为same，激活函数relu

    tf.keras.layers.Conv2D(filters=256,kernel_size=5,padding='same',activation='relu'),
    # 池化:窗口大小为3*3、步幅为2

    tf.keras.layers.MaxPool2D(pool_size=3, strides=2),
    # 卷积层：384个卷积核，卷积核为3*3，步幅为1，padding为same，激活函数relu

    tf.keras.layers.Conv2D(filters=384,kernel_size=3,padding='same',activation='relu'),
    # 卷积层：384个卷积核，卷积核为3*3，步幅为1，padding为same，激活函数relu

    tf.keras.layers.Conv2D(filters=384,kernel_size=3,padding='same',activation='relu'),
    # 卷积层：256个卷积核，卷积核为3*3，步幅为1，padding为same，激活函数relu

    tf.keras.layers.Conv2D(filters=256,kernel_size=3,padding='same',activation='relu'),
    # 池化:窗口大小为3*3、步幅为2

    tf.keras.layers.MaxPool2D(pool_size=3, strides=2),
    # 伸展为1维向量

    tf.keras.layers.Flatten(),
    # 全连接层:4096个神经元，激活函数relu

    tf.keras.layers.Dense(4096,activation='relu'),
    # 随机失活

    tf.keras.layers.Dropout(0.5),
    # 全链接层：4096个神经元，激活函数relu

    tf.keras.layers.Dense(4096,activation='relu'),
    # 随机失活

    tf.keras.layers.Dropout(0.5),
    # 输出层：10个神经元，激活函数softmax

    tf.keras.layers.Dense(10,activation='softmax')
])

2. 手写数字势识别

# 1. 模型读取

import numpy as np
# 获取手写数字数据集

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# 训练集数据维度的调整：N H W C

train_images = np.reshape(train_images,(train_images.shape[0],train_images.shape[1],train_images.shape[2],1))
# 测试集数据维度的调整：N H W C

test_images = np.reshape(test_images,(test_images.shape[0],test_images.shape[1],test_images.shape[2],1))

# 2. 模型编译

# 定义两个方法随机抽取部分样本演示

# 获取训练集数据

def get_train(size):
    # 随机生成要抽样的样本的索引

    index = np.random.randint(0, np.shape(train_images)[0], size)
    # 将这些数据resize成227*227大小

    resized_images = tf.image.resize_with_pad(train_images[index],227,227,)
    # 返回抽取的

    return resized_images.numpy(), train_labels[index]
# 获取测试集数据 

def get_test(size):
    # 随机生成要抽样的样本的索引

    index = np.random.randint(0, np.shape(test_images)[0], size)
    # 将这些数据resize成227*227大小

    resized_images = tf.image.resize_with_pad(test_images[index],227,227,)
    # 返回抽样的测试样本

    return resized_images.numpy(), test_labels[index]

# 获取训练样本和测试样本

train_images,train_labels = get_train(256)
test_images,test_labels = get_test(128)

# 数据展示：将数据集的前九个数据集进行展示

for i in range(9):
    plt.subplot(3,3,i+1)
    # 以灰度图显示，不进行插值

    plt.imshow(train_images[i].astype(np.int8).squeeze(), cmap='gray', interpolation='none')
    # 设置图片的标题：对应的类别

    plt.title("数字{}".format(train_labels[i]))

# 指定优化器，损失函数和评价指标

optimizer = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.0, nesterov=False)

net.compile(optimizer=optimizer,
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 3. 模型训练：指定训练数据，batchsize,epoch,验证集

net.fit(train_images,train_labels,batch_size=128,epochs=3,verbose=1,validation_split=0.1)

# 4. 模型评估
net.evaluate(test_images,test_labels,verbose=1)   

三、VGG

1. VGG的网络架构

# 定义VGG网络中的卷积块：卷积层的个数，卷积层中卷积核的个数

def vgg_block(num_convs, num_filters):
    # 构建序列模型

    blk = tf.keras.models.Sequential()
    # 遍历所有的卷积层

    for _ in range(num_convs):
        # 每个卷积层：num_filter个卷积核，卷积核大小为3*3，padding是same，激活函数是relu

        blk.add(tf.keras.layers.Conv2D(num_filters,kernel_size=3,
                                    padding='same',activation='relu'))
    # 卷积块最后是一个最大池化，窗口大小为2*2，步长为2

    blk.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
    return blk

# 定义VGG网络

def vgg(conv_arch):
    # 构建序列模型

    net = tf.keras.models.Sequential()
    # 根据conv_arch生成卷积部分

    for (num_convs, num_filters) in conv_arch:
        net.add(vgg_block(num_convs, num_filters))
    # 卷积块序列后添加全连接层

    net.add(tf.keras.models.Sequential([
        # 将特征图展成一维向量

        tf.keras.layers.Flatten(),
        # 全连接层：4096个神经元，激活函数是relu

        tf.keras.layers.Dense(4096, activation='relu'),
        # 随机失活

        tf.keras.layers.Dropout(0.5),
        # 全连接层：4096个神经元，激活函数是relu

        tf.keras.layers.Dense(4096, activation='relu'),
        # 随机失活

        tf.keras.layers.Dropout(0.5),
        # 全连接层：10个神经元，激活函数是softmax

        tf.keras.layers.Dense(10, activation='softmax')]))
    return net

# 网络实例化

net = vgg(conv_arch)

# 构造输入X，并将其送入到net网络中

X = tf.random.uniform((1,224,224,1))
y = net(X)
# 通过net.summay()查看网络的形状

net.summay()

四、GoogLeNet

1. Inception 块

# 定义Inception模块

class Inception(tf.keras.layers.Layer):
    # 输入参数为各个卷积的卷积核个数

    def __init__(self, c1, c2, c3, c4):
        super().__init__()
        # 线路1：1 x 1卷积层，激活函数是RELU，padding是same

        self.p1_1 = tf.keras.layers.Conv2D(
            c1, kernel_size=1, activation='relu', padding='same')
        # 线路2，1 x 1卷积层后接3 x 3卷积层,激活函数是RELU，padding是same

        self.p2_1 = tf.keras.layers.Conv2D(
            c2[0], kernel_size=1, padding='same', activation='relu')
        self.p2_2 = tf.keras.layers.Conv2D(c2[1], kernel_size=3, padding='same',
                                           activation='relu')
        # 线路3，1 x 1卷积层后接5 x 5卷积层,激活函数是RELU，padding是same

        self.p3_1 = tf.keras.layers.Conv2D(
            c3[0], kernel_size=1, padding='same', activation='relu')
        self.p3_2 = tf.keras.layers.Conv2D(c3[1], kernel_size=5, padding='same',
                                           activation='relu')
        # 线路4，3 x 3最大池化层后接1 x 1卷积层,激活函数是RELU，padding是same

        self.p4_1 = tf.keras.layers.MaxPool2D(
            pool_size=3, padding='same', strides=1)
        self.p4_2 = tf.keras.layers.Conv2D(
            c4, kernel_size=1, padding='same', activation='relu')
    # 完成前向传播过程

    def call(self, x):
        # 线路1

        p1 = self.p1_1(x)
        # 线路2

        p2 = self.p2_2(self.p2_1(x))
        # 线路3

        p3 = self.p3_2(self.p3_1(x))
        # 线路4

        p4 = self.p4_2(self.p4_1(x))
        # 在通道维上concat输出

        outputs = tf.concat([p1, p2, p3, p4], axis=-1)
        return outputs  

2. GoogLeNet模型

2.1 B1模块

第一模块使用一个64通道的7*7卷积层。

# 定义模型的输入

inputs = tf.keras.Input(shape=(224,224,3),name = "input")
# b1 模块
# 卷积层7*7的卷积核，步长为2，pad是same，激活函数RELU

x = tf.keras.layers.Conv2D(64, kernel_size=7, strides=2, padding='same', activation='relu')(inputs)
# 最大池化：窗口大小为3*3，步长为2，pad是same

x = tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x)

2.2 B2模块

第二模块使用2个卷积层：首先是64通道的1*1,卷积层，然后是将通道增大3倍的3*3卷积层

# b2 模块
# 卷积层1*1的卷积核，步长为2，pad是same，激活函数RELU

x = tf.keras.layers.Conv2D(64, kernel_size=1, padding='same', activation='relu')(x)
# 卷积层3*3的卷积核，步长为2，pad是same，激活函数RELU

x = tf.keras.layers.Conv2D(192, kernel_size=3, padding='same', activation='relu')(x)
# 最大池化：窗口大小为3*3，步长为2，pad是same

x = tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x)

2.3 B3模块

第三模块串联2个完整的Inception块。第一个Inception块的输出通道数为64+128+32+32=256。第二个Inception块输出通道数增至128+192+96+64=480。

# b3 模块
# Inception

x = Inception(64, (96, 128), (16, 32), 32)(x)
# Inception

x = Inception(128, (128, 192), (32, 96), 64)(x)
# 最大池化：窗口大小为3*3，步长为2，pad是same

x = tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x)

2.4 B4模块

增加辅助分类器是为了防止深度过深导致梯度消失；

def aux_classifier(x, filter_size):
    #x:输入数据，filter_size:卷积层卷积核个数，全连接层神经元个数
    # 池化层

    x = tf.keras.layers.AveragePooling2D(
        pool_size=5, strides=3, padding='same')(x)
    # 1x1 卷积层

    x = tf.keras.layers.Conv2D(filters=filter_size[0], kernel_size=1, strides=1,
                               padding='valid', activation='relu')(x)
    # 展平

    x = tf.keras.layers.Flatten()(x)
    # 全连接层1

    x = tf.keras.layers.Dense(units=filter_size[1], activation='relu')(x)
    # softmax输出层

    x = tf.keras.layers.Dense(units=10, activation='softmax')(x)
    return x

# b4 模块
# Inception

x = Inception(192, (96, 208), (16, 48), 64)(x)
# 辅助输出1

aux_output_1 = aux_classifier(x, [128, 1024])
# Inception

x = Inception(160, (112, 224), (24, 64), 64)(x)
# Inception

x = Inception(128, (128, 256), (24, 64), 64)(x)
# Inception

x = Inception(112, (144, 288), (32, 64), 64)(x)
# 辅助输出2

aux_output_2 = aux_classifier(x, [128, 1024])
# Inception

x = Inception(256, (160, 320), (32, 128), 128)(x)
# 最大池化

x = tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x)

2.5 B5模块

# b5 模块
# Inception

x = Inception(256, (160, 320), (32, 128), 128)(x)
# Inception

x = Inception(384, (192, 384), (48, 128), 128)(x)
# GAP

x = tf.keras.layers.GlobalAvgPool2D()(x)
# 输出层

main_outputs = tf.keras.layers.Dense(10,activation='softmax')(x)


# 使用Model来创建模型，指明输入和输出

model = tf.keras.Model(inputs=inputs, outputs=[main_outputs,aux_output_1，aux_output_2]) 
model.summary()

3. 延伸版本

3.1 InceptionV2

3.2 InceptionV3

五、ResNet

1. ResNet提出的原因

网络越深，获取的信息就越多，特征也越丰富。
但是在实践中，随着网络的加深，优化效果反而越差（反向传播梯度消失），测试数据和训练数据的准确- 率反而降低了。
针对这一问题，何恺明等人提出了残差网络（ResNet）在2015年的ImageNet图像识别挑战赛夺魁，并深刻影响了后来的深度神经网络的设计。

2. 残差块

假设F(x)代表某个只包含有两层的映射函数，x是输入，F(x)是输出。假设他们具有相同的维度。在训练的过程中我们希望能够通过修改网络中的w和b去拟合一个理想的H(x)(从输入到输出的一个理想的映射函数)。也就是我们的目标是修改F(x)中的w和b逼近H(x)。如果我们改变思路，用F(x)来逼近H(x)-x，那么我们最终得到的输出就变为F(x)+x（这里的加指的是对应位置上的元素相加，也就是element-wise addition），这里将直接从输入连接到输出的结构也称为shortcut，那整个结构就是残差块，ResNet的基础模块。

# 导入相关的工具包

import tensorflow as tf
from tensorflow.keras import layers, activations


# 定义ResNet的残差块

class Residual(tf.keras.Model):
    # 指明残差块的通道数，是否使用1*1卷积，步长

    def __init__(self, num_channels, use_1x1conv=False, strides=1):
        super(Residual, self).__init__()
        # 卷积层：指明卷积核个数，padding,卷积核大小，步长

        self.conv1 = layers.Conv2D(num_channels,
                                   padding='same',
                                   kernel_size=3,
                                   strides=strides)
        # 卷积层：指明卷积核个数，padding,卷积核大小，步长

        self.conv2 = layers.Conv2D(num_channels, kernel_size=3, padding='same')
        if use_1x1conv:
            self.conv3 = layers.Conv2D(num_channels,
                                       kernel_size=1,
                                       strides=strides)
        else:
            self.conv3 = None
        # 指明BN层

        self.bn1 = layers.BatchNormalization()
        self.bn2 = layers.BatchNormalization()

    # 定义前向传播过程

    def call(self, X):
        # 卷积，BN，激活

        Y = activations.relu(self.bn1(self.conv1(X)))
        # 卷积，BN

        Y = self.bn2(self.conv2(Y))
        # 对输入数据进行1*1卷积保证通道数相同

        if self.conv3:
            X = self.conv3(X)
        # 返回与输入相加后激活的结果

        return activations.relu(Y + X)

3. ResNet模型

ResNet网络中按照残差块的通道数分为不同的模块。第一个模块前使用了步幅为2的最大池化层，所以无须减小高和宽。之后的每个模块在第一个残差块里将上一个模块的通道数翻倍，并将高和宽减半。

下面我们来实现这些模块。注意，这里对第一个模块做了特别处理。

# ResNet网络中模块的构成
class ResnetBlock(tf.keras.layers.Layer):
    # 网络层的定义：输出通道数（卷积核个数），模块中包含的残差块个数，是否为第一个模块
    def __init__(self,num_channels, num_residuals, first_block=False):
        super(ResnetBlock, self).__init__()
        # 模块中的网络层
        self.listLayers=[]
        # 遍历模块中所有的层
        for i in range(num_residuals):
            # 若为第一个残差块并且不是第一个模块，则使用1*1卷积，步长为2（目的是减小特征图，并增大通道数）
            if i == 0 and not first_block:
                self.listLayers.append(Residual(num_channels, use_1x1conv=True, strides=2))
            # 否则不使用1*1卷积，步长为1 
            else:
                self.listLayers.append(Residual(num_channels))      
    # 定义前向传播过程
    def call(self, X):
        # 所有层依次向前传播即可
        for layer in self.listLayers.layers:
            X = layer(X)
        return X

ResNet的前两层跟之前介绍的GoogLeNet中的一样：在输出通道数为64、步幅为2的7*7 卷积层后接步幅为2的3*3的最大池化层。不同之处在于ResNet每个卷积层后增加了BN层,接着是所有残差模块，最后，与GoogLeNet一样，加入全局平均池化层（GAP）后接上全连接层输出。

# 构建ResNet网络

class ResNet(tf.keras.Model):
    # 初始化：指定每个模块中的残差快的个数

    def __init__(self,num_blocks):
        super(ResNet, self).__init__()
        # 输入层：7*7卷积，步长为2

        self.conv=layers.Conv2D(64, kernel_size=7, strides=2, padding='same')
        # BN层

        self.bn=layers.BatchNormalization()
        # 激活层

        self.relu=layers.Activation('relu')
        # 最大池化层

        self.mp=layers.MaxPool2D(pool_size=3, strides=2, padding='same')
        # 第一个block，通道数为64

        self.resnet_block1=ResnetBlock(64,num_blocks[0], first_block=True)
        # 第二个block，通道数为128

        self.resnet_block2=ResnetBlock(128,num_blocks[1])
        # 第三个block，通道数为256

        self.resnet_block3=ResnetBlock(256,num_blocks[2])
        # 第四个block，通道数为512

        self.resnet_block4=ResnetBlock(512,num_blocks[3])
        # 全局平均池化

        self.gap=layers.GlobalAvgPool2D()
        # 全连接层：分类

        self.fc=layers.Dense(units=10,activation=tf.keras.activations.softmax)
    # 前向传播过程

    def call(self, x):
        # 卷积

        x=self.conv(x)
        # BN

        x=self.bn(x)
        # 激活

        x=self.relu(x)
        # 最大池化

        x=self.mp(x)
        # 残差模块

        x=self.resnet_block1(x)
        x=self.resnet_block2(x)
        x=self.resnet_block3(x)
        x=self.resnet_block4(x)
        # 全局平均池化

        x=self.gap(x)
        # 全链接层

        x=self.fc(x)
        return x
# 模型实例化：指定每个block中的残差块个数 

mynet=ResNet([2,2,2,2])

# 观察模型架构

X = tf.random.uniform(shape=(1,  224, 224 , 1))
y = mynet(X)
mynet.summary()

六、图像增强方法

1. 常用的图像增强方法

图像增强（image augmentation）：
- 指通过剪切、旋转/反射/翻转变换、缩放变换、平移变换、尺度变换、对比度变换、噪声扰动、颜色变换等一种或多种组合数据增强变换的方式来增加数据集的大小。
常见的图像增强方式可以分为两类：
- 几何变换类
- 颜色变换类

2. tf.image进行图像增强

2.1 翻转和裁剪

# 左右翻转并显示

cat1 = tf.image.random_flip_left_right(cat)
plt.imshow(cat1）

# 上下翻转

cat2 = tf.image.random_flip_up_down(cat)
plt.imshow(cat2)

# 随机裁剪

cat3 = tf.image.random_crop(cat,(200,200,3))
plt.imshow(cat3)

2.2 颜色变换

# 亮度随机变化

cat4=tf.image.random_brightness(cat,0.5)
plt.imshow(cat4)

# 变化图像的色调

cat5 = tf.image.random_hue(cat,0.5)
plt.imshow(cat5)

3. 使用ImageDataGenerator()进行图像增强

ImageDataGenerator()是keras.preprocessing.image模块中的图片生成器，可以在batch中对数据进行增强，扩充数据集大小，增强模型的泛化能力。比如旋转，变形等，API如下所示:
keras.preprocessing.image.ImageDataGenerator( rotation_range=0, #整数。随机旋转的度数范围。 width_shift_range=0.0, #浮点数、宽度平移 height_shift_range=0.0, #浮点数、高度平移 brightness_range=None, # 亮度调整 shear_range=0.0, # 裁剪 zoom_range=0.0, #浮点数或 [lower, upper]。随机缩放范围 horizontal_flip=False, # 左右翻转 vertical_flip=False, # 垂直翻转 rescale=None # 尺度调整 )

# 获取数据集

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 将数据转换为4维的形式

x_train = X_train.reshape(X_train.shape[0],28,28,1)
x_test = X_test.reshape(X_test.shape[0],28,28,1)
# 设置图像增强方式：水平翻转

datagen = ImageDataGenerator(horizontal_flip=True)
# 查看增强后的结果

for X_batch,y_batch in datagen.flow(x_train,y_train,batch_size=9):
    plt.figure(figsize=(8,8)) 
    # 设定每个图像显示的大小
    # 产生一个3*3网格的图像

    for i in range(0,9):
        plt.subplot(330+1+i) 
        plt.title(y_batch[i])
        plt.axis('off')
        plt.imshow(X_batch[i].reshape(28,28),cmap='gray')
    plt.show()
    break

七、模型微调

1. 微调

迁移学习（transfer learning），将从源数据集学到的知识迁移到目标数据集上。
微调由以下4步构成。
- 在源数据集（如ImageNet数据集）上预训练一个神经网络模型，即源模型。
- 创建一个新的神经网络模型，即目标模型。它复制了源模型上除了输出层外的所有模型设计及其参数。我们假设这些模型参数包含了源数据集上学习到的知识，且这些知识同样适用于目标数据集。我们还假设源模型的输出层跟源数据集的标签紧密相关，因此在目标模型中不予采用。
- 为目标模型添加一个输出大小为目标数据集类别个数的输出层，并随机初始化该层的模型参数。
- 在目标数据集（如椅子数据集）上训练目标模型。我们将从头训练输出层，而其余层的参数都是基于源模型的参数微调得到的。
当目标数据集远小于源数据集时，微调有助于提升模型的泛化能力。

2. 热狗识别案例

2.1 获取数据集

# 获取数据集

import pathlib
train_dir = 'transferdata/train'
test_dir = 'transferdata/test'
# 获取训练集数据

train_dir = pathlib.Path(train_dir)
train_count = len(list(train_dir.glob('*/*.jpg')))
# 获取测试集数据

test_dir = pathlib.Path(test_dir)
test_count = len(list(test_dir.glob('*/*.jpg')))
# 创建imageDataGenerator进行图像处理

image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)
# 设置参数

BATCH_SIZE = 32
IMG_HEIGHT = 224
IMG_WIDTH = 224
# 获取训练数据

train_data_gen = image_generator.flow_from_directory(directory=str(train_dir),
                                                    batch_size=BATCH_SIZE,
                                                    target_size=(IMG_HEIGHT, IMG_WIDTH),
                                                    shuffle=True)
# 获取测试数据

test_data_gen = image_generator.flow_from_directory(directory=str(test_dir),
                                                    batch_size=BATCH_SIZE,
                                                    target_size=(IMG_HEIGHT, IMG_WIDTH),
                                                    shuffle=True)

import matplotlib.pyplot as plt
# 显示图像

def show_batch(image_batch, label_batch):
    plt.figure(figsize=(10,10))
    for n in range(15):
        ax = plt.subplot(5,5,n+1)
        plt.imshow(image_batch[n]）
        plt.axis('off')
# 随机选择一个batch的图像  

image_batch, label_batch = next(train_data_gen)
# 图像显示

show_batch(image_batch, label_batch)

2.2 模型构建与训练

# 加载预训练模型

ResNet50 = tf.keras.applications.ResNet50(weights='imagenet', input_shape=(224,224,3))
# 设置所有层不可训练

for layer in ResNet50.layers:
    layer.trainable = False
# 设置模型

net = tf.keras.models.Sequential()
# 预训练模型

net.add(ResNet50)
# 展开

net.add(tf.keras.layers.Flatten())
# 二分类的全连接层

net.add(tf.keras.layers.Dense(2, activation='softmax'))

# 模型编译：指定优化器，损失函数和评价指标

net.compile(optimizer='adam',
            loss='categorical_crossentropy',
            metrics=['accuracy'])
# 模型训练：指定数据，每一个epoch中只运行10个迭代，指定验证数据集

history = net.fit(
                    train_data_gen,
                    steps_per_epoch=10,
                    epochs=3,
                    validation_data=test_data_gen,
                    validation_steps=10
                    )