使用tensorflow实现数据增强

目录

1、缩放

2、裁剪​​

3、翻转​​​

4、颜色变换

---

深度学习中对于图像类型的训练数据可以通过数据增强（Data Augmentation）的方法增加数据数量及数据复杂度，从而获得更好的训练效果。常用的数据增强的方法有：缩放，裁剪，旋转，翻转，颜色变换。当然，使用数据增强的前提是不改变原本图像的标签。比如在MNIST数据集中，原来标签是6的图像就不能使用上下翻转，因为6经过上下翻转后会变为9。

 

1、缩放

tf.image.resize_images(
    images,
    size,
    method=ResizeMethod.BILINEAR,
    align_corners=False
)

参数：
images：形状为[batch, height, width, channels]的4-D张量或形状为[height, width, channels]的3-D张量。
size：2个元素（new_height, new_width）的1维int32张量，表示图像的新大小。
method：ResizeMethod，默认为ResizeMethod.BILINEAR。
align_corners：布尔型，如果为True，则输入和输出张量的4个拐角像素的中心对齐，并且保留角落像素处的值；默认为False。

将图像在一定尺度内放大或缩小。如果原始图像的高宽比与尺寸不一致，那么经过调整大小的图像就会被扭曲。为了避免失真，可以使用tf.image.resize_image_with_pad。

import tensorflow as tf
import matplotlib.pyplot as plt
from PIL import Image
from numpy import uint8

with tf.Session() as sess:
    # 读取图像并显示
    original_image = Image.open('images/test.jpg')
    plt.title('original_image')
    plt.imshow(original_image)
    plt.show()

    # 将图像缩小至224X224
    reduced_image = tf.image.resize_images(original_image, [224, 224])
    # 将图像扩大至1024X768
    expanded_image = tf.image.resize_images(original_image, [768, 1024])
    
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())

    # 将tensor转换为numpy数组
    reduced_image = sess.run(reduced_image)
    # 将numpy数组转换为图像
    reduced_image=Image.fromarray(uint8(reduced_image))
    # 显示图像
    plt.title('reduced_image')
    plt.imshow(reduced_image)
    plt.show()
    # 保存图像
    reduced_image.save('images/reduced_image.jpg')
    
    expanded_image = sess.run(expanded_image)
    expanded_image=Image.fromarray(uint8(expanded_image))
    plt.title('expanded_image')
    plt.imshow(expanded_image)
    plt.show()
    expanded_image.save('images/expanded_image.jpg')

2、裁剪

tf.random_crop(
    value,
    size,
    seed=None,
    name=None
)

参数：
value：向裁剪输入张量。
size：一维张量，大小等级为 value。
seed：Python 整数。用于创建一个随机的种子。查看 tf.set_random_seed 的行为。
name：此操作的名称（可选）。

在原有图像上随机的裁剪出一块，1.12版本可以使用tf.image.random_crop。

import tensorflow as tf
import matplotlib.pyplot as plt
from PIL import Image
from numpy import uint8

with tf.Session() as sess:
    # 读取图像并显示
    original_image = Image.open('images/test.jpg')
    plt.title('original_image')
    plt.imshow(original_image)
    plt.show()
    
    # 随机裁剪图像
    crop_image = tf.random_crop(original_image,[224,224,3])
    
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    # 将tensor转换为numpy数组
    crop_image = sess.run(crop_image)
    # 将numpy数组转换为图像
    crop_image=Image.fromarray(uint8(crop_image))
    # 显示图像
    plt.title('crop_image')
    plt.imshow(crop_image)
    plt.show()
    # 保存图像
    crop_image.save('images/crop_image.jpg')  

3、翻转

对原图（随机）进行左右翻转或上下翻转。

左右翻转：

tf.image.flip_left_right(image)

参数：
image：形状为[batch, height, width, channels]的4-D张量或形状为[height, width, channels]的3-D张量。

tf.image.random_flip_left_right(
    image,
    seed=None
)

参数：
image：形状为[height, width, channels]的三维张量。
seed：一个Python整数，用于创建一个随机种子。

上下翻转：

tf.image.flip_up_down(image)

参数：
image：形状为[batch, height, width, channels]的4-D张量，或形状为[height, width, channels]的3-D张量。

tf.image.random_flip_up_down(
    image,
    seed=None
)

参数：
image：形状为[height, width, channels]的三维张量。
seed：一个Python整数，用于创建一个随机种子。

import tensorflow as tf
import matplotlib.pyplot as plt
from PIL import Image
from numpy import uint8

with tf.Session() as sess:
    original_image = Image.open('images/test.jpg')
    plt.title('original_image')
    plt.imshow(original_image)
    plt.show()
    
    # 对图像进行水平翻转，如需要随机进行水平翻转请使用tf.image.random_flip_up_down
    horizontal_image = tf.image.flip_left_right(original_image)
    # 对图像进行水平翻转，如需要随机进行水平翻转请使用tf.image.random_flip_up_down
    vertical_image = tf.image.flip_up_down(original_image)
    
    horizontal_image = sess.run(horizontal_image)
    horizontal_image=Image.fromarray(uint8(horizontal_image))
    plt.title('horizontal_image')
    plt.imshow(horizontal_image)
    plt.show()
    horizontal_image.save('images/horizontal_image.jpg') 
    
    vertical_image = sess.run(vertical_image)
    vertical_image=Image.fromarray(uint8(vertical_image))
    plt.title('vertical_image')
    plt.imshow(vertical_image)
    plt.show()
    vertical_image.save('images/vertical_image.jpg')

4、颜色变换

TensorFlow 提供了以各种方式调整图像的功能：亮度，对比度，色调和饱和度。每个调整都可以用预定义的参数或从预定义的间隔中选取的随机参数完成。随机调整通常有助于扩大训练集并减少过度拟合。

亮度：

tf.image.random_brightness(
    image,
    max_delta,
    seed=None
)

参数：
image： 一个图像。
max_delta：float，必须是非负的。
seed：一个Python整数。用于创建一个随机种子。

对比度：

tf.image.random_contrast(
    image,
    lower,
    upper,
    seed=None
)

参数：
image：具有3个或更多维度的图像张量。
lower：浮点型，随机对比因子的下限。
upper：浮点型，随机对比因子的上限。
seed：一个Python整数，用于创建一个随机种子。

色调：

tf.image.random_hue(
    image,
    max_delta,
    seed=None
)

参数：
image：RGB图像，最后维度的大小必须为3。
max_delta：浮点型，随机增量的最大值。
seed：特定于操作的seed，它将与图层seed一起使用，以确定将在此操作中使用的实际seed。

饱和度：

tf.image.random_saturation(
    image,
    lower,
    upper,
    seed=None
)

参数：
image：RGB图像，最后维度的大小必须为3。
lower：浮点型，随机饱和因子的下界。
upper：浮点型，随机饱和因子的上界。
seed：特定于操作的seed，它将与图层seed一起使用，以确定将在此操作中使用的实际seed。

import tensorflow as tf
import matplotlib.pyplot as plt
from PIL import Image
from numpy import uint8

with tf.Session() as sess:
    original_image = Image.open('images/test.jpg')
    plt.figure(1)
    plt.title('original_image')
    plt.imshow(original_image)
    plt.show()
    
    # 通过随机因子调整图像的亮度
    random_brightness_image = tf.image.random_brightness(original_image, 0.5)
    
    # 通过随机因子调整图像的对比度
    random_contrast_image = tf.image.random_contrast(original_image, 0.1, 0.5 )
    
    # 通过随机因子调整RGB图像的色调
    random_hue_image = tf.image.random_hue(original_image, 0.5)
    
    # 通过随机因子调整RGB图像的饱和度
    random_saturation_image = tf.image.random_saturation(original_image, 0.3, 0.5)
    
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    
    random_brightness_image = sess.run(random_brightness_image)
    random_brightness_image=Image.fromarray(uint8(random_brightness_image))
    plt.title('random_brightness_image')
    plt.imshow(random_brightness_image)
    plt.show()
    random_brightness_image.save('images/random_brightness_image.jpg') 
    
    random_contrast_image = sess.run(random_contrast_image)
    random_contrast_image=Image.fromarray(uint8(random_contrast_image))
    plt.title('random_contrast_image')
    plt.imshow(random_contrast_image)
    plt.show()
    random_contrast_image.save('images/random_contrast_image.jpg')
    
    random_hue_image = sess.run(random_hue_image)
    random_hue_image=Image.fromarray(uint8(random_hue_image))
    plt.title('random_hue_image')
    plt.imshow(random_hue_image)
    plt.show()
    random_hue_image.save('images/random_hue_image.jpg')
    
    random_saturation_image = sess.run(random_saturation_image)
    random_saturation_image=Image.fromarray(uint8(random_saturation_image))
    plt.title('random_saturation_image')
    plt.imshow(random_saturation_image)
    plt.show()
    random_saturation_image.save('images/random_saturation_image.jpg')