五月 | 2021 | Python技术交流与分享

使用数据增强来提升模型的性能

1、导入模型

import os
import math
import numpy as np
import pickle as p
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
%matplotlib inline

import os

import math

import numpy as np

import pickle as p

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

%matplotlib inline

2、定义加载函数

def load_CIFAR_data(data_dir):
    """load CIFAR data"""
 
    images_train=[]
    labels_train=[]
    for i in range(5):
        f=os.path.join(data_dir,'data_batch_%d' % (i+1))
        print('loading ',f)
        # 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签
        image_batch,label_batch=load_CIFAR_batch(f)
        images_train.append(image_batch)
        labels_train.append(label_batch)
        Xtrain=np.concatenate(images_train)
        Ytrain=np.concatenate(labels_train)
        del image_batch ,label_batch
    
    Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
    print('finished loadding CIFAR-10 data')
    
    # 返回训练集的图像和标签，测试集的图像和标签
return (Xtrain,Ytrain),(Xtest,Ytest)

def load_CIFAR_data(data_dir):

"""load CIFAR data"""

images_train=[]

labels_train=[]

for i in range(5):

f=os.path.join(data_dir,'data_batch_%d' % (i+1))

print('loading ',f)

# 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签

image_batch,label_batch=load_CIFAR_batch(f)

images_train.append(image_batch)

labels_train.append(label_batch)

Xtrain=np.concatenate(images_train)

Ytrain=np.concatenate(labels_train)

del image_batch ,label_batch

Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))

print('finished loadding CIFAR-10 data')

# 返回训练集的图像和标签，测试集的图像和标签

return (Xtrain,Ytrain),(Xtest,Ytest)

3、定义批量加载函数

def load_CIFAR_batch(filename):
    """ load single batch of cifar """  
    with open(filename, 'rb')as f:
        # 一个样本由标签和图像数据组成
        #  (3072=32x32x3)
        # ...
        # 
        data_dict = p.load(f, encoding='bytes')
        images= data_dict[b'data']
        labels = data_dict[b'labels']
                
        # 把原始数据结构调整为: BCWH
        images = images.reshape(10000, 3, 32, 32)
        # tensorflow处理图像数据的结构：BWHC
        # 把通道数据C移动到最后一个维度
        images = images.transpose (0,2,3,1)
     
        labels = np.array(labels)
        
        return images, labels

def load_CIFAR_batch(filename):

""" load single batch of cifar """

with open(filename, 'rb')as f:

# 一个样本由标签和图像数据组成

# (3072=32x32x3)

# ...

data_dict = p.load(f, encoding='bytes')

images= data_dict[b'data']

labels = data_dict[b'labels']

# 把原始数据结构调整为: BCWH

images = images.reshape(10000, 3, 32, 32)

# tensorflow处理图像数据的结构：BWHC

# 把通道数据C移动到最后一个维度

images = images.transpose (0,2,3,1)

labels = np.array(labels)

return images, labels

4、加载数据

data_dir = r'C:\Users\wumg\jupyter-ipynb\data\cifar-10-batches-py'
(x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1 2	data_dir = r'C:\Users\wumg\jupyter-ipynb\data\cifar-10-batches-py' (x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

把数据转换为dataset格式

train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

1 2	train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

5、定义数据增强方法

def convert(image, label):
    image = tf.image.convert_image_dtype(image, tf.float32)
    return image, label
 
def augment(image, label):
    image, label = convert(image, label)
    #image = tf.image.convert_image_dtype(image, tf.float32)
    image = tf.image.resize_with_crop_or_pad(image, 34,34) # 四周各加3像素
    image = tf.image.random_crop(image, size=[32,32,3]) # 随机裁剪成28*28大小
    image = tf.image.random_brightness(image, max_delta=0.5) # 随机增加亮度
    return image, label
 
batch_size = 64

augmented_train_batches = (train_dataset
                          #.take(num_examples)
                          .cache()
                         # .repeat()
                          .shuffle(5000)
                          .map(augment, num_parallel_calls=tf.data.experimental.AUTOTUNE)
                          .batch(batch_size)
                          .prefetch(tf.data.experimental.AUTOTUNE))
 
non_augmented_train_batches = (train_dataset
                              .cache()
                             # .repeat()
                              .shuffle(5000)
                              .map(convert, num_parallel_calls=tf.data.experimental.AUTOTUNE)
                              .batch(batch_size)
                              .prefetch(tf.data.experimental.AUTOTUNE))
 
validation_batches = (test_dataset 
                     .map(convert, num_parallel_calls=tf.data.experimental.AUTOTUNE)
                     .batch(2*batch_size))

def convert(image, label):

image = tf.image.convert_image_dtype(image, tf.float32)

return image, label

def augment(image, label):

image, label = convert(image, label)

#image = tf.image.convert_image_dtype(image, tf.float32)

image = tf.image.resize_with_crop_or_pad(image, 34,34) # 四周各加3像素

image = tf.image.random_crop(image, size=[32,32,3]) # 随机裁剪成28*28大小

image = tf.image.random_brightness(image, max_delta=0.5) # 随机增加亮度

return image, label

batch_size = 64

augmented_train_batches = (train_dataset

#.take(num_examples)

.cache()

# .repeat()

.shuffle(5000)

.map(augment, num_parallel_calls=tf.data.experimental.AUTOTUNE)

.batch(batch_size)

.prefetch(tf.data.experimental.AUTOTUNE))

non_augmented_train_batches = (train_dataset

.cache()

# .repeat()

.shuffle(5000)

.map(convert, num_parallel_calls=tf.data.experimental.AUTOTUNE)

.batch(batch_size)

.prefetch(tf.data.experimental.AUTOTUNE))

validation_batches = (test_dataset

.map(convert, num_parallel_calls=tf.data.experimental.AUTOTUNE)

.batch(2*batch_size))

6、构建模型

class MyCNN(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(
            filters=32,             # 卷积层神经元（卷积核）数目
            kernel_size=[3, 3],     # 感受野大小
            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=[3, 3],
            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=(8 * 8 * 64,))
        self.dense1 = tf.keras.layers.Dense(units=256, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=10)

    def call(self, inputs):
        x = self.conv1(inputs)                  # [batch_size, 32, 32, 3]
        x = self.pool1(x)                       # [batch_size, 32, 32, 32]
        x = self.conv2(x)                       # [batch_size, 16, 16, 64]
        x = self.pool2(x)                       # [batch_size, 8, 8, 64]
        x = self.flatten(x)                     # [batch_size, 8 * 8 * 64]
        x = self.dense1(x)                      # [batch_size, 256]
        x = self.dense2(x)                      # [batch_size, 10]
        output = tf.nn.softmax(x)
        return output
    def model01(self):
        x = tf.keras.Input(shape=(32, 32, 3))
        return tf.keras.Model(inputs=[x], outputs=self.call(x))

class MyCNN(tf.keras.Model):

def __init__(self):

super().__init__()

self.conv1 = tf.keras.layers.Conv2D(

filters=32, # 卷积层神经元（卷积核）数目

kernel_size=[3, 3], # 感受野大小

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=[3, 3],

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=(8 * 8 * 64,))

self.dense1 = tf.keras.layers.Dense(units=256, activation=tf.nn.relu)

self.dense2 = tf.keras.layers.Dense(units=10)

def call(self, inputs):

x = self.conv1(inputs) # [batch_size, 32, 32, 3]

x = self.pool1(x) # [batch_size, 32, 32, 32]

x = self.conv2(x) # [batch_size, 16, 16, 64]

x = self.pool2(x) # [batch_size, 8, 8, 64]

x = self.flatten(x) # [batch_size, 8 * 8 * 64]

x = self.dense1(x) # [batch_size, 256]

x = self.dense2(x) # [batch_size, 10]

output = tf.nn.softmax(x)

return output

def model01(self):

x = tf.keras.Input(shape=(32, 32, 3))

return tf.keras.Model(inputs=[x], outputs=self.call(x))

生成实例

model_no_augment = MyCNN()

1	model_no_augment = MyCNN()

查看模型详细结构

model_no_augment.model01().summary()

1	model_no_augment.model01().summary()

7、编译模型

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

1	model_no_augment.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])

8、训练模型

为便于比较，这里先不使用数据增强方法

epochs = 10
history_non_augment = model_no_augment.fit(non_augmented_train_batches,epochs=epochs,validation_data=validation_batches)

1 2	epochs = 10 history_non_augment = model_no_augment.fit(non_augmented_train_batches,epochs=epochs,validation_data=validation_batches)

9、查看运行结果

acc = history_non_augment.history['accuracy']
val_acc = history_non_augment.history['val_accuracy']
 
loss = history_non_augment.history['loss']
val_loss = history_non_augment.history['val_loss']
 
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1.1])
plt.title('Training and Validation Accuracy')
 
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([-0.1,1.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()

acc = history_non_augment.history['accuracy']

val_acc = history_non_augment.history['val_accuracy']

loss = history_non_augment.history['loss']

val_loss = history_non_augment.history['val_loss']

plt.figure(figsize=(8, 8))

plt.subplot(2, 1, 1)

plt.plot(acc, label='Training Accuracy')

plt.plot(val_acc, label='Validation Accuracy')

plt.legend(loc='lower right')

plt.ylabel('Accuracy')

plt.ylim([min(plt.ylim()),1.1])

plt.title('Training and Validation Accuracy')

plt.subplot(2, 1, 2)

plt.plot(loss, label='Training Loss')

plt.plot(val_loss, label='Validation Loss')

plt.legend(loc='upper right')

plt.ylabel('Cross Entropy')

plt.ylim([-0.1,1.0])

plt.title('Training and Validation Loss')

plt.xlabel('epoch')

plt.show()

运行结果

10、使用数据增强方法

model_augment = MyCNN()

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

history_with_augment = model_augment.fit(augmented_train_batches,epochs=epochs,validation_data=validation_batches)

model_augment = MyCNN()

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

history_with_augment = model_augment.fit(augmented_train_batches,epochs=epochs,validation_data=validation_batches)

11、查看使用数据增强的运行结果

acc = history_with_augment.history['accuracy']
val_acc = history_with_augment.history['val_accuracy']
 
loss = history_with_augment.history['loss']
val_loss = history_with_augment.history['val_loss']
 
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1.1])
plt.title('Training and Validation Accuracy')
 
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([-0.1,1.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()

acc = history_with_augment.history['accuracy']

val_acc = history_with_augment.history['val_accuracy']

loss = history_with_augment.history['loss']

val_loss = history_with_augment.history['val_loss']

plt.figure(figsize=(8, 8))

plt.subplot(2, 1, 1)

plt.plot(acc, label='Training Accuracy')

plt.plot(val_acc, label='Validation Accuracy')

plt.legend(loc='lower right')

plt.ylabel('Accuracy')

plt.ylim([min(plt.ylim()),1.1])

plt.title('Training and Validation Accuracy')

plt.subplot(2, 1, 2)

plt.plot(loss, label='Training Loss')

plt.plot(val_loss, label='Validation Loss')

plt.legend(loc='upper right')

plt.ylabel('Cross Entropy')

plt.ylim([-0.1,1.0])

plt.title('Training and Validation Loss')

plt.xlabel('epoch')

plt.show()

运行结果

12、结果分析

从不使用数据增强与使用数据增强方法的结果可以看出，使用数据增强方法后，模型性能有提升(未使用数据增强的验证精度为71%，使用数据增强方法后，验证精度提升到74%)，而且模型的泛化能力也有提高（使用数据增强方法后，训练与验证精度曲线靠得较近）。

这里介绍几种TensorFlow2提升模型性能的几种有效方法，如数据增强、使用经典网络、使用迁移学习、使用新架构等。

一、数据增强

数据增强是提升模型性能的常用方法之一，尤其当训练数据集较小时，通过数据增强方法，效果更加明确。通过数据增强不但可以增加数据量、丰富数据的多样性，从而有效提升模型的泛化能力。
TensorFlow2提供了多种数据增强方法，常用的几种方法为：
 有监督的数据增强：
1、使用tf.image的预处理
该方法一般基于dataset，然后把数据增强方法嵌入到map中
2、使用tf.keras.preprocessing.image.ImageDataGenerator
利用实时数据增强技术生成批量的张量图像数据
使用tf.keras.preprocessing.image.ImageDataGenerator，获取数据源的方法主要有：
（1）.flow(x, y)
（2）.flow_from_directory(directory)
3、使用tf.keras.layers.experimental.preprocessing
更多信息可参考官网：https://keras.io/guides/preprocessing_layers/
 无监督的数据增强
通过模型学习数据的分布，随机生成与训练数据集分布一致的图片，代表方法，GAN。
GAN模型包含两个网络，一个是生成网络（G），一个是判别网络（D），基本原理如下：
(1)G是一个生成图片的网络，它接收随机的噪声z，通过噪声生成图片，记做G(z)。
(2)D是一个判别网络，判别一张图片是不是“真实的”，即是真实的图片，还是由G生成的图片。其架构图如下：

下载所有实例使用数据（提取码为：fg29）
具体实例

二、使用现代经典模型

现代经典模型主要有: VGG、GoogLeNet、Inception、Xception、ResNet、MobileNet、DenseNet、NASNet等,各种网咯结构可参考：
https://blog.csdn.net/Forrest97/article/details/105630719

具体实例(待续)

三、利用迁移方法

Tensorflow.keras.application下载已经训练好的模型，包括如下预训练模型：
VGG、GoogLeNet、Inception、Xception、ResNet、MobileNet、DenseNet、NASNet等

具体实例(待续)

四、使用新架构如Transformer等

Transformer）模型在NLP领域取得了SOTA成绩，目前人们正把Transformer引用到CV领域，在图像识别、图像分类等领域取得不俗的表现。在目标检测（如DETR）、图像分类（如ViT）、图像分割（如SETR）都取得不错的效果。这里我们重点介绍ViT（Vision Transformer）。如何把Transformer引入CV领域？需要对CV中的图像做哪些处理？
NLP处理的语言数据是序列化的，而CV中处理的图像数据是三维的（height、width和channels）。所以需要通过某种方法将图像这种三维数据转化为序列化的数据。
Vision Transformer将CV和NLP领域知识结合起来，对原始图片进行分块，然后展平成序列，输入进原始Transformer模型的编码器Encoder部分，最后接入一个全连接层对图片进行分类。具体步骤为：
（1）原始图片（H,W,C）进行分块（patches）
进行一个类似卷积操作，把原始图片进行分块，分块数=H*W/P*P（P为块的大小）。
（2）展平每块（Flatten the patches）
把每块展平为一维向量，大小为：P*P*C（对应实例中的patch_dims）
（3）把展平后的块映射为更低维的向量
通过一个全连接层，把展平后块映射为一个更低维的向量(对应实例中的patch embedding)，其大小为D(对应实例中的projection_dim),这个维度在各层保存不变，主要为便于使用残差连接。
（4）在patch embedding基础上添加一个类标签
类似BERT的[class] token，在patch embedding的序列之前添加一个可学习的embedding向量xclass
（5）加上位置嵌入（Add positional embeddings）
低维的向量+位置嵌入,
（6）把（5）的结果作为标准transformer encoder的输入
（7）在一个大数据集上训练模型
（8）在下游数据集中，进行微调。
ViT架构图如下：

具体实例

五、练习

1、利用ResNet经典模型提升性能
2、使用keras的数据增强方法提升性能
3、viT中Transformer的输入数据的形状（shape）与哪些因素有关？包括哪些数据？如何生成Transformer的输入数据？

Python技术交流与分享

分享技术平台

月度归档：2021年05月

1、导入模型

2、定义加载函数

3、定义批量加载函数

4、加载数据

5、定义数据增强方法

6、构建模型

7、编译模型

8、训练模型

9、查看运行结果

10、使用数据增强方法

11、查看使用数据增强的运行结果

12、结果分析

一、数据增强

二、使用现代经典模型

三、利用迁移方法

四、使用新架构如Transformer等

五、练习