Keras中的图片生成器类ImageDataGenerator

tf.keras.preprocessing.image.ImageDataGenerator(
featurewise_center=False, 
samplewise_center=False,
featurewise_std_normalization=False,  
samplewise_std_normalization=False,
zca_whitening=False, 
zca_epsilon=1e-06, 
rotation_range=0, 
width_shift_range=0.0,
height_shift_range=0.0, 
brightness_range=None, 
shear_range=0.0, 
zoom_range=0.0,
channel_shift_range=0.0, 
fill_mode='nearest', 
cval=0.0,
horizontal_flip=False, 
vertical_flip=False, 
rescale=None,
preprocessing_function=None, 
data_format=None, 
validation_split=0.0,
dtype=None
)

参数	意义
Featurewise_ center	使生成每个图像均值为0，可替代图像归一化。具体来说，假设原数据集图像是x，当Featurewise_center和Samplewise_center连个参数设置为True时，以x为基础生成新数据时，每个图像都要先执行Xi = Xi - mean 其中mean是数据集图像的均值。数据集里有多个图像，均值mean可以有两种方法获得。当samplewise_center=True时，mean是每个图像的所有像素值的均值。这样生成的每一个图像的均值应该接近于0。当featurewise_center=True时，mean是所有图像的像素的均值。如果数据集里的图像有多个颜色通道，那么，ImageDataGenerator会为每个颜色通道计算一个均值，各个通道独立计算 Xi = Xi - mean 。 所以：如果想要在进行数据增强时还达到归一化的效果，就不要把featurewise_center和samplewise_center这两个参数都设置成True。
Samplewise_ center
Featurewise_std_ normalization	布尔值，将输入除以数据集的标准差以完成标准化。
Samplewise_std_ normalization	布尔值，将输入的每个样本除以其自身的标准差。
Zca_whiteng	zca白化的作用是针对图片进行PCA降维操作，减少图片的冗余信息，保留最重要的特征。
Zca_epsilon	zca白化参数的ε值，默认值是1e-6。
Ratation_range	角度随机旋转的范围，只需指定一个整数即可，在[0,指定角度]范围内的角度值，随机旋转图片。
Width_shift_ range	水平方向位置随机左右平移，其参数值可以是[0,1]之间的浮点数，表示原始图片中的信息无论怎么左右平移都有部分原始信息在变换后的图片中。但参数也可以大于1，此时图片平移距离为:图片尺寸的宽乘以这个参数。在变换后的图像中可能表示为全部信息是原始图像左右边界的像素信息。
Height_shift_ range	竖直方向位置随机上下平移，其参数值可以是[0,1]之间的浮点数，表示原始图片中的信息无论怎么上下平移都有部分原始信息在变换后的图片中。但参数也可以大于1，此时图片平移距离为:图片尺寸的高乘以这个参数。在变换后的图像中可能表示为全部信息是原始图像上下边界的像素信息。
Brightness_range	图像随机亮度增强，给定一个含两个float值的list或一个元组，亮度值取自上下限值间。
Share_range	随机错切变换，效果就是让所有点的x坐标(或者y坐标)保持不变，而对应的y坐标(或者x坐标)则按比例发生平移，且平移的大小和该点到x轴(或y轴)的垂直距离成正比。值表示，在逆时针方向上新图和原图之间的错切角度，单位是度。
Zoom_range	参数可以让图片在长或宽的方向随机进行放大，可以理解为某方向的resize，因此这个参数可以是一个数或者是一个list。当给出一个数时，图片同时在长宽两个方向进行同等程度的放缩操作；当给出一个list时，则代表[width_zoom_range, height_zoom_range]，即分别对长宽进行不同程度的放缩。而参数大于0小于1时，执行的是放大操作，当参数大于1时，执行的是缩小操作。
Channel_shift_ range	可以理解成随机改变图片的颜色，通过对颜色通道的数值偏移，改变图片的整体的颜色，这意味着是“整张图”呈现某一种颜色，像是加了一块有色玻璃在图片前面一样，因此它并不能单独改变图片某一元素的颜色，如黑色小狗不能变成白色小狗。当数值越大时，颜色变深的效果越强。
Fill_mode	填充模式，默认为最近原则，比如一张图片向右平移，那么最左侧部分会被临近的图案覆盖。共4中模式，即："constant", "nearest", "reflect" or "wrap"。四种填充形式如下： ● 'constant': kkkkkkkk|abcd|kkkkkkkk (cval=k) ● 'nearest': aaaaaaaa|abcd|dddddddd ● 'reflect': abcddcba|abcd|dcbaabcd ● 'wrap': abcdabcd|abcd|abcdabcd
cval	填充值，整型或浮点型。只有当fill_mode是constant时，才有效。
Horizontal_flip	随机对图片执行水平方向翻转操作，意味着不一定对所有图片都会执行水平翻转，每次生成均是随机选取图片进行翻转。
Vertical_flip	随机对图片执行竖直方向翻转操作，意味着不一定对所有图片都会执行竖直翻转，每次生成均是随机选取图片进行翻转。
rescale	对图片的每个像素值均乘上这个放缩因子，这个操作在所有其它变换操作之后执行，在一些模型当中，直接输入原图的像素值可能会落入激活函数的“死亡区”，因此设置放缩因子为1/255，把像素值放缩到0和1之间有利于模型的收敛，避免神经元“死亡”。
Preprocessing_ function	图片预处理，此功能对每一张输入图片都有效，在图像resize或增强执行后立即执行。如取值为random_crop_image，则对输入图像进行随机裁剪，裁剪后的图片和裁剪前图片的shape保持一致。
Data_format	图像数据的格式，有“channels_last”和“channels_first”两种形式，即分别对应图像数据的(samples, height, width, channels) 和(samples, channels, height, width)两种格式。默认是“channels_last”。
Validation_split	[0,1]之间的浮点型数据，分隔多少图像数据用于训练过程中的保留验证。
dtype	生成数据的数据类型，有‘float32’，‘float64’等。

举例说明：

使用.flow(x,y):

import tensorflow as tf
from tensorflow.keras import utils
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, 	MaxPool2D, Dropout, Flatten, Dense
from tensorflow.keras import Model

cifar10 = tf.keras.datasets.cifar10

# 定义分类别数和数据迭代轮次
num_classes = 10
epochs = 5

(x_train, y_train), (x_test, y_test) = cifar10.load_data()
y_train = utils.to_categorical(y_train, num_classes)
y_test = utils.to_categorical(y_test, num_classes)
datagen = ImageDataGenerator(
   			                 featurewise_center=True,
     			             featurewise_std_normalization=True,
    			             rotation_range=20,
   			                 width_shift_range=0.2,
    			             height_shift_range=0.2,
    			             horizontal_flip=True,
    			             validation_split=0.2)
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(x_train)


class Baseline(Model):
    def __init__(self):
        super(Baseline, self).__init__()
        self.c1 = Conv2D(filters=6, kernel_size=(5, 5), padding='same')  # 卷积层
        self.b1 = BatchNormalization()  # BN层
        self.a1 = Activation('relu')  # 激活层
        self.p1 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')  # 池化层
        self.d1 = Dropout(0.2)  # dropout层

        self.flatten = Flatten()
        self.f1 = Dense(128, activation='relu')
        self.d2 = Dropout(0.2)
        self.f2 = Dense(10, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)
        x = self.p1(x)
        x = self.d1(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.d2(x)
        y = self.f2(x)
        return y


model = Baseline()
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(
                                                  from_logits=False),
                                                  metrics=['sparse_categorical_accuracy']
)

# 训练模型
model.fit(datagen.flow(x_train, y_train, batch_size=32, subset='training'),
          validation_data=datagen.flow(x_train, y_train, batch_size=8, 
		  subset='validation'),
          steps_per_epoch=len(x_train) / 32, epochs=epochs)

# here's a more "manual" example
for e in range(epochs):
    print('Epoch', e)
    batches = 0
    for x_batch, y_batch in datagen.flow(x_train, y_train, batch_size=32):
        model.fit(x_batch, y_batch)
        batches += 1
        if batches >= len(x_train) / 32:
            # we need to break the loop by hand because
            # the generator loops indefinitely
            break

使用.flow_from_directory(directory):

train_datagen = ImageDataGenerator(
                                    rescale=1. / 255,
                                    shear_range=0.2,
                                    zoom_range=0.2,
                                    horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(
                                                    'data/train',
                                                    target_size=(150, 150),
                                                    batch_size=32,
                                                    class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
                                                        'data/validation',
                                                        target_size=(150, 150),
                                                        batch_size=32,
                                                        class_mode='binary')

model.fit(
            train_generator,
            steps_per_epoch=2000,
            epochs=50,
            validation_data=validation_generator,
            validation_steps=800)

使用图像和掩膜一起转换:

# we create two instances with the same arguments
data_gen_args = dict(featurewise_center=True,
                     featurewise_std_normalization=True,
                     rotation_range=90,
                     width_shift_range=0.1,
                     height_shift_range=0.1,
                     zoom_range=0.2)
image_datagen = ImageDataGenerator(**data_gen_args)
mask_datagen = ImageDataGenerator(**data_gen_args)
# Provide the same seed and keyword arguments to the fit and flow methods
seed = 1

image_generator = image_datagen.flow_from_directory(
                                                    'data/images',
                                                    class_mode=None,
                                                    seed=seed)
mask_generator = mask_datagen.flow_from_directory(
                                                  'data/masks',
                                                  class_mode=None,
                                                  seed=seed)
# combine generators into one which yields image and masks
train_generator = zip(image_generator, mask_generator)
model.fit(
          train_generator,
          steps_per_epoch=2000,
          epochs=50)