transforms的操作

一、transforms的操作

1、transforms.RandomChoice

transforms.RandomChoice 是一个数据转换操作，用于从一系列的转换方法中随机选择一个进行数据增强。
参数：

• transforms：一个包含多个转换方法的列表或元组。

示例：

import torchvision.transforms as transforms

# 定义数据转换操作
transform = transforms.Compose([
    # 从以下转换方法中随机选择一个进行数据增强
    transforms.RandomChoice([
        transforms.RandomHorizontalFlip(),  # 随机水平翻转
        transforms.RandomVerticalFlip(),    # 随机垂直翻转
        transforms.RandomRotation(45),      # 随机旋转（角度为45度）
    ])
])

# 对图像进行数据增强
augmented_image = transform(image)

在上面的示例中，transforms.RandomChoice 从一个包含三个转换方法的列表中随机选择一个转换方法进行数据增强。可以选择的转换方法包括随机水平翻转、随机垂直翻转和随机旋转。最后，使用 transform 对图像进行数据增强，得到增强后的图像 augmented_image。

通过使用 transforms.RandomChoice，可以在一系列的数据转换方法中随机选择一个，从而增加数据的多样性和随机性。这有助于提高模型的鲁棒性和泛化能力。

2、transforms.RandomApply

transforms.RandomApply 是一个数据转换操作，根据给定的概率依次应用一组转换方法。

参数：

• transforms：一个包含多个转换方法的列表或元组。
• p：应用转换方法的概率，默认为 0.5。
  示例：

import torchvision.transforms as transforms
transform = transforms.Compose([
    transforms.RandomApply([
        transforms.RandomHorizontalFlip(),
        transforms.RandomVerticalFlip(),
        transforms.RandomRotation(45),
    ], p=0.5)
])
# 根据概率应用一组转换方法进行数据增强
augmented_image = transform(image)

在上面的示例中，transforms.RandomApply 接受一个包含三个转换方法的列表，以及一个概率值 p=0.5。这意味着在每次应用转换方法时，有 50% 的概率应用其中的一个转换方法。可以选择的转换方法包括随机水平翻转、随机垂直翻转和随机旋转。最后，使用 transform 对图像进行数据增强，得到增强后的图像 augmented_image。

通过使用 transforms.RandomApply，可以根据给定的概率依次应用一组转换方法。这有助于增加数据的多样性和随机性，提高模型的鲁棒性和泛化能力。

---

3、transforms.RandomOrder

transforms.RandomOrder 是一个数据转换操作，用于对一组转换方法进行随机顺序打乱。
参数：

• transforms：一个包含多个转换方法的列表或元组。
  示例：

import torchvision.transforms as transforms
transform = transforms.Compose([
    transforms.RandomOrder([
        transforms.RandomHorizontalFlip(),
        transforms.RandomVerticalFlip(),
        transforms.RandomRotation(45),
    ])
])
# 随机打乱一组转换方法的顺序进行数据增强
augmented_image = transform(image)

在上面的示例中，transforms.RandomOrder 接受一个包含三个转换方法的列表。这些转换方法包括随机水平翻转、随机垂直翻转和随机旋转。使用 transform 对图像进行数据增强时，会随机打乱转换方法的顺序，从而生成增强后的图像 augmented_image。
通过使用 transforms.RandomOrder，可以对一组转换方法进行随机顺序打乱。这有助于增加数据的多样性和随机性，提高模型的鲁棒性和泛化能力。

二、自定义transforms

自定义transforms要素：

1. 仅接收一个参数，返回一个参数
2. 注意上下游的输出与输入

以下是一个示例代码，展示了如何通过类实现自定义的转换方法，接收多个参数并返回一个参数：

class YourTransforms(object):
    def __init__(self, param1, param2, ...):
        # 初始化参数
        self.param1 = param1
        self.param2 = param2
        ...
    
    def __call__(self, img):
        # 在这里实现您的转换逻辑
        # 可以使用 self.param1, self.param2 等参数
        # img 是输入的图像
        
        # 转换操作
        # ...
        
        return img

在上面的示例中，YourTransforms 类接收多个参数 param1, param2, ... 并在 __init__ 方法中进行初始化。您可以根据需要定义和初始化自己的参数。
然后，在 __call__ 方法中实现您的转换逻辑。在这个方法中，您可以使用 self.param1, self.param2 等参数，并对输入的图像 img 进行转换操作。最后，返回转换后的图像。

使用自定义的转换方法时，您可以将其与其他转换方法一起使用，例如 torchvision.transforms.Compose。通过将自定义的转换方法添加到 Compose 中，可以按照指定的顺序应用多个转换方法。

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    YourTransforms(param1, param2, ...),
    ...
])

在上述代码中，我们将 YourTransforms 添加到 Compose 中，并在需要的位置传递所需的参数。这样，您就可以将自定义的转换方法与其他转换方法组合在一起，应用于图像数据的预处理或增强过程中。

椒盐噪声

椒盐噪声又称为脉冲噪声，是一种随机出现的白点或者黑点, 白点称为盐噪声，黑色为椒噪声
信噪比（Signal-Noise Rate, SNR）是衡量噪声的比例，图像中为图像像素的占比

要实现添加椒盐噪声的转换方法，可以使用以下代码：

import random
import numpy as np
import torchvision.transforms as transforms
class AddPepperNoise(object):
    def __init__(self, snr, p):
        self.snr = snr
        self.p = p
    def __call__(self, img):
        img_array = np.array(img)  # 将图像转换为 numpy 数组
        h, w, c = img_array.shape  # 获取图像的高度、宽度和通道数
        # 计算噪声点的数量
        noise_num = int(h * w * self.p)
        # 生成随机的噪声点的坐标
        noise_coords = [(random.randint(0, h-1), random.randint(0, w-1)) for _ in range(noise_num)]
        # 添加椒盐噪声
        for coord in noise_coords:
            if random.random() < 0.5:  # 50%的概率生成盐噪声（白色）
                img_array[coord[0], coord[1], :] = 255
            else:  # 50%的概率生成椒噪声（黑色）
                img_array[coord[0], coord[1], :] = 0
        # 计算信噪比
        signal_power = np.mean(img_array)  # 计算信号的平均值
        noise_power = signal_power / self.snr  # 计算噪声的平均值
        noise_std = np.sqrt(noise_power)  # 计算噪声的标准差
        # 添加高斯噪声
        noise = np.random.normal(0, noise_std, size=(h, w, c))
        img_array = np.clip(img_array + noise, 0, 255).astype(np.uint8)
        # 将 numpy 数组转换为图像
        img = transforms.ToPILImage()(img_array)
        return img

在上述代码中，我们定义了一个名为 AddPepperNoise 的类，该类接收两个参数 snr 和 p，分别表示信噪比和噪声点的概率。

在 __call__ 方法中，我们首先将输入的图像转换为 numpy 数组，并获取图像的高度、宽度和通道数。

然后，我们根据噪声点的概率 p 计算噪声点的数量，并生成随机的噪声点的坐标。
接下来，我们遍历噪声点的坐标，根据 50% 的概率生成盐噪声（白色）或椒噪声（黑色）。

计算信噪比时，我们首先计算信号的平均值 signal_power，然后根据信噪比 snr 计算噪声的平均值 noise_power，最后计算噪声的标准差 noise_std。

最后，我们使用 numpy.random.normal 生成高斯噪声，并将其添加到图像上。然后，我们使用 numpy.clip 将图像像素值限制在 0 到 255 之间，并将其转换为 uint8 类型的数组。最后，我们将数组转换回图像格式，并返回添加了椒盐噪声的图像。

您可以将 AddPepperNoise 类与其他转换方法一起使用，例如 torchvision.transforms.Compose，将其添加到数据转换操作的组合中，以应用该转换方法。

transform = transforms.Compose([
    transforms.ToTensor(),
    AddPepperNoise(snr, p),
    ...
])

在上述代码中，我们将 AddPepperNoise 添加到 Compose 中，并在需要的位置传递信噪比 snr 和噪声点的概率 p。这样，您就可以将添加椒盐噪声的转换方法与其他转换方法组合在一起，应用于图像数据的预处理过程中。

---

class Compose(object):
    def __call__(self, img):
        for t in self.transforms:  # 遍历转换方法列表
            img = t(img)  # 应用当前转换方法到图像
        return img  # 返回处理后的图像

上述代码定义了一个名为 Compose 的类，用于组合多个图像转换方法。

在 __call__ 方法中，我们遍历 self.transforms 列表中的每个转换方法 t，并将当前的图像 img 作为参数传递给转换方法。然后，将转换后的图像赋值给 img，继续应用下一个转换方法。

最后，返回经过所有转换方法处理后的图像 img。

通过使用 Compose 类，可以将多个图像转换方法组合在一起，并在预处理过程中依次应用这些转换方法，以实现更复杂的图像处理操作。

例如，可以使用以下代码将两个转换方法 transform1 和 transform2 组合在一起：

transform = Compose([
    transform1,
    transform2
])

然后，可以通过调用 transform(img) 方法来应用这两个转换方法到图像 img 上，得到处理后的图像。