PyTorch源码解读（二）torchvision.transforms

PyTorch框架中有一个非常重要且好用的包：torchvision，该包主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms。这3个子包的具体介绍可以参考官网：https://pytorch.org/docs/master/torchvision/index.html
我的另外两篇博客对其他两个部分做了介绍分别为：

torchvision.datasetshttps://blog.csdn.net/sinat_42239797/article/details/93916790
torchvision.modelshttps://blog.csdn.net/sinat_42239797/article/details/94329987

这篇博客介绍torchvision.transformas。
torchvision.transforms这个包中包含resize、crop等常见的data augmentation操作，基本上PyTorch中的data augmentation操作都可以通过该接口实现。该包主要包含两个脚本：transformas.py和functional.py，前者定义了各种data augmentation的类，在每个类中通过调用functional.py中对应的函数完成data augmentation操作。
pytorch的图像变换模块主要由五部分构成，分别为：
Transforms on PIL Image、Transforms on torch.Tensor、Conversion Transforms、Generic Transforms、Functional Transforms
常见的变换Transforms on PIL Image、Transforms on torch.Tensor、Conversion Transforms它们可以使用链接在一起Compose。
先举一个常用操作的简单例子感受一下：

import torchvision
import torch
train_augmentation = torchvision.transforms.Compose([
                              torchvision.transforms.Resize(256),
                              torchvision.transforms.RandomCrop(224),                                                                            
                              torchvision.transofrms.RandomHorizontalFlip(),
                              torchvision.transforms.ToTensor(),
                              torch vision.Normalize([0.485, 0.456, -.406],[0.229, 0.224, 0.225])
                                                    ])

Class custom_dataread(torch.utils.data.Dataset):
    def __init__():
        ...
    def __getitem__():
        # use self.transform for input image
    def __len__():
        ...

train_loader = torch.utils.data.DataLoader(
    custom_dataread(transform=train_augmentation),
    batch_size = batch_size, shuffle = True,
    num_workers = workers, pin_memory = True) 

注意

 torchvision.transforms.ToTensor(),
torch vision.Normalize([0.485, 0.456, -.406],[0.229, 0.224, 0.225]

这两行使用使用时顺序不可以颠倒，原因是因为归一化需要是Tensor型的数据，所以要先将数据转化为Tensor型才可以进行归一化。
一般情况下我们将对图片的变换操作放到torchvision.transforms.Compose（）进行组组合变换。

Transforms on PIL Image

torchvision.transforms.CenterCrop（大小）

参数介绍
size（sequence 或int） - 作物的所需输出大小。如果size是int而不是像（h，w）这样的序列，则进行正方形裁剪（大小，大小）。

torchvision.transforms.ColorJitter（亮度= 0，对比度= 0，饱和度= 0，色调= 0 ）#随机更改图像的亮度，对比度和饱和度。

参数介绍
亮度（浮点数或python的元组：浮点数（最小值，最大值）） - 抖动亮度多少。从[max（0,1-brightness），1 + brightness]或给定[min，max]均匀地选择brightness_factor。应该是非负数。

对比度（浮点数或python的元组：浮点数（最小值，最大值）） - 抖动对比度多少。contrast_factor从[max（0,1-contrast），1 + contrast]或给定[min，max]中均匀选择。应该是非负数。
饱和度（浮点数或python的元组数：float （min ，max ）） - 饱和度抖动多少。饱和度_因子从[max（0,1-saturation），1 + saturation]或给定[min，max]中均匀选择。应该是非负数。

色调（浮点数或python的元组：浮点数（最小值，最大值）） - 抖动色调多少。从[-hue，hue]或给定的[min，max]中均匀地选择hue_factor。应该有0 <= hue <= 0.5或-0.5 <= min <= max <= 0.5。

torchvision.transforms.FiveCrop（大小）#将给定的PIL图像裁剪为四个角和中央裁剪

参数介绍
size（sequence 或int） - 作物的所需输出大小。如果大小是int 而不是像（h，w）这样的序列，则进行大小（大小，大小）的正方形裁剪。
例子：

transform = Compose([
FiveCrop(size), # this is a list of PIL Images
Lambda(lambda crops: torch.stack([ToTensor()(crop) for crop in crops])) # returns a 4D tensor
])
#In your test loop you can do the following:
input, target = batch # input is a 5d tensor, target is 2d
bs, ncrops, c, h, w = input.size()
result = model(input.view(-1, c, h, w)) # fuse batch size and ncrops
result_avg = result.view(bs, ncrops, -1).mean(1) # avg over crops

torchvision.transforms.RandomCrop（size，padding = None，pad_if_needed = False，fill = 0
                                   padding_mode ='constant' ）#在随机位置裁剪给定的PIL图像。

size（sequence 或int） - 作物的所需输出大小。如果size是int而不是像（h，w）这样的序列，则进行正方形裁剪（大小，大小）。

padding（int或sequence ，optional） - 图像每个边框上的可选填充。默认值为None，即无填充。如果提供长度为4的序列，则它用于分别填充左，上，右，下边界。如果提供长度为2的序列，则分别用于填充左/右，上/下边界。

pad_if_needed（boolean） - 如果小于所需大小，它将填充图像以避免引发异常。由于在填充之后完成裁剪，因此填充似乎是在随机偏移处完成的。

fill - 恒定填充的像素填充值。默认值为0.如果长度为3的元组，则分别用于填充R，G，B通道。仅当padding_mode为常量时才使用此值

padding_mode -填充类型。应该是：恒定，边缘，反射或对称。默认值是常量。

常量：具有常量值的焊盘，该值用填充指定

edge：填充图像边缘的最后一个值

反射：具有图像反射的垫（不重复边缘上的最后一个值）

填充[1,2,3,4]在反射模式下两侧有2个元素将导致[3,2,1,2,3,4,3,2]

对称：具有图像反射的垫（重复边缘上的最后一个值）

填充[1,2,3,4]在对称模式下两侧有2个元素将导致[2,1,1,2,3,4,4,3]

torchvision.transforms.RandomHorizontalFlip（p = 0.5 ）
                                 #以给定的概率随机水平翻转给定的PIL图像
                                  #p（浮动） - 图像被翻转的概率。默认值为0.5
torchvision.transforms.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), 
                                         interpolation=2)#将给定的PIL图像裁剪为随机大小和宽高比

#生成原始大小的随机大小（默认值：0.08到1.0）和随机宽高比（默认值：3/4到4/3）。这种作物最终调整到适当的大小。这通常用于训练Inception网络。
参数介绍：
参数
size - 每条边的预期输出大小

scale - 裁剪的原始尺寸的大小范围

ratio - 裁剪的原始宽高比的宽高比范围

interpolation - 默认值：PIL.Image.BILINEAR

torchvision.transforms.RandomRotation（degrees，resample = False，
                                       expand = False，center = None ）#按角度旋转图像

参数介绍：
degrees（sequence 或float或int） - 要选择的度数范围。如果degrees是一个数字而不是像（min，max）这样的序列，则度数范围将是（-degrees，+ degrees）。

resample（{PIL.Image.NEAREST ，PIL.Image.BILINEAR ，PIL.Image.BICUBIC} ，可选） - 可选的重采样过滤器。请参阅过滤器以获取更多信 如果省略，或者图像具有模式“1”或“P”，则将其设置为PIL.Image.NEAREST。

expand（bool，optional） - 可选的扩展标志。如果为true，则展开输出以使其足够大以容纳整个旋转图像。如果为false或省略，则使输出图像与输入图像的大小相同。请注意，展开标志假定围绕中心旋转而不进行平移。

center（2-tuple ，optional） - 可选的旋转中心。原点是左上角。默认值是图像的中心。

torchvision.transforms.RandomVerticalFlip（p = 0.5 ）#以给定的概率随机垂直翻转给定的PIL图像

p（浮动） - 图像被翻转的概率。默认值为0.5

torchvision.transforms.TenCrop（size，vertical_flip = False ）#将给定的PIL图像裁剪为四个角，中央裁剪加上这些的翻转版本（默认使用水平翻转）

注意：此转换返回图像元组，并且数据集返回的输入和目标数量可能不匹配。
参数介绍：
size（sequence 或int） - 作物的所需输出大小。如果size是int而不是像（h，w）这样的序列，则进行正方形裁剪（大小，大小）。

例子：

transform = Compose([
TenCrop(size), # this is a list of PIL Images
Lambda(lambda crops: torch.stack([ToTensor()(crop) for crop in crops])) # returns a 4D tensor
])
#In your test loop you can do the following:
input, target = batch # input is a 5d tensor, target is 2d
bs, ncrops, c, h, w = input.size()
result = model(input.view(-1, c, h, w)) # fuse batch size and ncrops
result_avg = result.view(bs, ncrops, -1).mean(1) # avg over crops

vertical_flip（bool） - 使用垂直翻转而不是水平翻转

torchvision.transforms.Grayscale（num_output_channels = 1 ）#将图像转换为灰度。

参数介绍：
num_output_channels（int） - （1或3）输出图像所需的通道数
返回：
输入的灰度版本。 - 如果num_output_channels == 1：返回的图像是单通道 - 如果num_output_channels == 3：返回的图像是3通道，r == g == b

torchvision.transforms.Pad（padding，fill = 0，padding_mode ='constant' ）#使用给定的“pad”值在所有面上填充给定的PIL图像

参数介绍：
padding（int或tuple） - 每个边框上的填充。如果提供单个int，则用于填充所有边框。如果提供长度为2的元组，则分别为左/右和上/下的填充。如果提供长度为4的元组，则分别为左，上，右和下边框的填充。

fill（int或tuple） - 常量填充的像素填充值。默认值为0.如果长度为3的元组，则分别用于填充R，G，B通道。
仅当padding_mode为常量时才使用此值padding_mode（str） -填充类型。应该是：恒定，边缘，反射或对称。默认值是常量。

常量：具有常量值的焊盘，该值用填充指定
edge：填充图像边缘的最后一个值
反射：具有图像反射的焊盘，而不重复边缘上的最后一个值
例如，在反射模式下在两侧填充2个元素的填充[1,2,3,4]将导致[3,2,1,2,3,4,3,2]
对称：具有图像反射的垫，重复边缘上的最后一个值
例如，在对称模式下填充两侧带有2个元素的[1,2,3,4]将导致[2,1,1,2,3,4,4,3]

torchvision.transforms.RandomAffine（degrees，translate = None，scale = None，shear = None，
                                     resample = False，fillcolor = 0 ）#图像保持中心不变的随机仿射变换

参数介绍：
degrees（sequence 或float或int） - 要选择的度数范围。如果degrees是一个数字而不是像（min，max）这样的序列，则度数范围将是（-degrees，+ degrees）。设置为0可停用旋转。

translate（元组，可选） - 水平和垂直平移的最大绝对分数元组。例如translate =（a，b），然后在范围-img_width * a

scale（元组，可选） - 缩放因子间隔，例如（a，b），然后从范围a <= scale <= b中随机采样缩放。默认情况下会保持原始比例。

shear（sequence 或float或int，optional） - 要选择的度数范围。如果degrees是一个数字而不是像（min，max）这样的序列，则度数范围将是（-degrees，+ degrees）。默认情况下不会应用剪切

resample（{PIL.Image.NEAREST ，PIL.Image.BILINEAR ，PIL.Image.BICUBIC} ，可选） - 可选的重采样过滤器。请参阅过滤器以获取更多信 如果省略，或者图像具有模式“1”或“P”，则将其设置PIL.Image.NEAREST。

fillcolor（tuple或int） - 输出图像中变换外部区域的可选填充颜色（RGB图像的元组和灰度的int）。（Pillow> = 5.0.0）

  torchvision.transforms.RandomApply(transforms, p=0.5)#随机应用给定概率的变换列表

参数介绍：
转换（列表或元组） - 转换列表
p（浮动） - 概率

torchvision.transforms.RandomChoice(transforms)#应用从列表中随机挑选的单个转换
torchvision.transforms.RandomGrayscale（p = 0.1 ）
              #将图像随机转换为灰度，概率为p（默认值为0.1）
              #p（float） - 图像应转换为灰度的概率
              #输入图像的灰度版本，概率为p，概率不变（1-p）。 - 如果输入图像为1通道：灰度版本为
              #通道 - 如果输入图像为3通道：灰度版本为3通道，r == g == b
torchvision.transforms.RandomOrder（transforms）   #以随机顺序应用转换列表
torchvision.transforms.RandomPerspective（distortion_scale = 0.5，p = 0.5，interpolation = 3 ）
                                          #以给定的概率随机执行给定PIL图像的透视变换                                                                 

参数介绍：
interpolation – Default- Image.BICUBIC
p（浮动） - 图像被透视变换的概率。默认值为0.5
distortion_scale（float） - 它控制失真程度，范围从0到1.默认值为0.5

transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
transforms.RandomErasing(),
])

torchvision.transforms.Resize（size，interpolation = 2 ）#将输入PIL图像的大小调整为给定大小

参数介绍：
size（sequence 或int） - 所需的输出大小。如果size是类似（h，w）的序列，则输出大小将与此匹配。如果size是int，则图像的较小边缘将与此数字匹配。即，如果高度>宽度，则图像将重新缩放为（尺寸*高度/宽度，尺寸）

interpolation（int，optional） - 所需的插值。默认是 PIL.Image.BILINEAR

Transforms on torch.Tensor

torchvision.transforms.Normalize（mean，std，inplace = False ）
#用平均值和标准偏差归一化张量图像。给定mean：(M1,...,Mn)和std：(S1,..,Sn)对于n通道，此变换将标准化输入的每个通道，torch.*Tensor即 input[channel] = (input[channel] - mean[channel]) / std[channel]

Conversion Transforms

torchvision.transforms.ToPILImage（mode = None ）# tensor或ndarray转换为PIL图像
                         #形状C x H x W或形状为H x W x C的numpy ndarray到PIL图像，同时保留值范围

参数介绍：
模式（PIL.Image模式） -输入数据的颜色空间和像素深度（可选）。如果mode是None（默认），则对输入数据做出一些假设：

如果输入有4个通道，mode则假定为RGBA。

如果输入有3个通道，mode则假定为RGB。

如果输入有2个通道，mode则假定为LA。

如果输入有1个通道时，mode是由数据类型确定（即int，float， short）。

torchvision.transforms.ToTensor

Convert a PIL Image or numpy.ndarray to tensor.
如果PIL图像属于，则将[0,255]范围内的PIL图像或numpy.ndarray（H x W x C）转换为[0.0,1.0]范围内的形状（C x H x W）的torch.FloatTensor到其中一种模式（L，LA，P，I，F，RGB，YCbCr，RGBA，CMYK，1）或者如果numpy.ndarray有dtype = np.uint8

Functional Transforms

功能转换为您提供了对转换管道的细粒度控制。与上面的转换相反，功能转换不包含其参数的随机数生成器。这意味着您必须指定/生成所有参数，但您可以重用功能转换。例如，您可以将功能转换应用于多个图像，如下所示：

import torchvision.transforms.functional as TF
import random

def my_segmentation_transforms(image, segmentation):
    if random.random() > 0.5:
        angle = random.randint(-30, 30)
        image = TF.rotate(image, angle)
        segmentation = TF.rotate(segmentation, angle)
    # more transforms ...
    return image, segmentation

11

 torchvision.transforms.functional.adjust_brightness（img，brightness_factor ）#调整图像的亮度，返回的是亮度调整后的PIL图像

参数设置：
img（PIL图像） - PIL要调整的图像。

brightness_factor（float） - 调整亮度多少。可以是任何非负数。0表示黑色图像，1表示原始图像，2表示亮度增加2倍。

torchvision.transforms.functional.adjust_contrast（img，contrast_factor ）#调整图像的对比度。

参数介绍：
img（PIL图像） - PIL要调整的图像。

contrast_factor（float） - 调整对比度多少。可以是任何非负数。0给出一个纯灰色图像，1表示原始图像，而2表示对比度增加2倍。

torchvision.transforms.functional.adjust_gamma（img，gamma，gain = 1 ）#对图像执行伽玛校正。

也称为幂律变换。RGB模式下的强度根据以下等式进行调整：

img（PIL图像） - PIL要调整的图像。

gamma（float） - 非负实数，与\伽玛等式中的 γ。大于1的伽玛使阴影变暗，而小于1的伽玛使暗区变亮。

gain (float) - 常数乘数。

torchvision.transforms.functional.adjust_hue（img，hue_factor ）#调整图像的色调。

注意
通过将图像转换为HSV并在色调通道（H）中循环移动强度来调整图像色调。然后将图像转换回原始图像模式。hue_factor是H通道的移位量，必须在[ -0.5,0.5 ]的区间内。
参数设置：
img（PIL图像） - PIL要调整的图像。

hue_factor（float） - 移动色调通道多少钱。应该在[-0.5,0.5]。0.5和-0.5分别在HSV空间中正负方向完全反转色调通道。0表示没有班次。因此，-0.5和0.5都将给出具有互补色的图像，而0给出原始图像。
torchvision.transforms.functional.adjust_saturation（img，saturation_factor ）#调整图像的颜色饱和度
参数设置：
img（PIL图像） - PIL要调整的图像。

saturation_factor（float） - 调整饱和度多少。0将给出黑白图像，1将给出原始图像，而2将使饱和度提高2倍。

torchvision.transforms.functional.affine（img，angle，translate，scale，shear，resample = 0，fillcolor = None ）
                                                     #在图像保持图像中心不变的情况下应用仿射变换

参数设置：
img（PIL Image） - PIL要旋转的图像。

angle（float或int） - 旋转角度，单位为-180到180之间，顺时针方向。

translate（python的列表或元组：整数） - 水平和垂直翻译（旋转后翻译）

规模（浮动） - 整体规模

剪切（浮动） - 剪切角度值，以-180到180之间的度数，顺时针方向。

resample（PIL.Image.NEAREST或PIL.Image.BILINEAR或PIL.Image.BICUBIC，可选） - 可选的重采样过滤器。请参阅过滤器以获取更多信 如果省略，或者图像具有模式“1”或“P”，则将其设置为PIL.Image.NEAREST。

fillcolor（int） - 输出图像中变换外部区域的可选填充颜色。（Pillow> = 5.0.0）

torchvision.transforms.functional.crop（img，i，j，h，w ）#裁剪给定的PIL图像

参数设置：
img（PIL图像） - 要裁剪的图像。

i（int） - i in（i，j）中，即左上角的坐标。

j（int） - j in（i，j）即左上角的坐标。

h（int） - 裁剪图像的高度。

w（int） - 裁剪图像的宽度

torchvision.transforms.functional.erase（img，i，j，h，w，v ）#用给定值擦除输入Tensor Image，返回的是删除图像

参数设置：
img（Tensor Image） - 要擦除的尺寸（C，H，W）的张量图像

i（int） - i in（i，j）中，即左上角的坐标。

j（int） - j in（i，j）即左上角的坐标。

h（int） - 擦除区域的高度。

w（int） - 擦除区域的宽度。

v - 擦除值。

torchvision.transforms.functional.five_crop（img，size ）#将给定的PIL图像裁剪为四个角和中央裁剪

注意：
这个转换的回报图像的元组，并有可能在输入数不匹配，并针对您的Dataset回报。
参数设置：
size（sequence 或int） - 作物的所需输出大小。如果size是int而不是像（h，w）这样的序列，则进行正方形裁剪（大小，大小）。
返回的是元组（tl，tr，bl，br，center）对应的左上角，右上角，左下角，右下角和中心裁剪。

torchvision.transforms.functional.hflip（img ）#水平翻转给定的PIL图像，img（PIL图像） - 要翻转的图像
torchvision.transforms.functional.normalize（tensor，mean，std，inplace = False ）#用平均值和标准偏差归一化张量图像

参数设置：
tensor (Tensor) - 要标准化的尺寸（C，H，W）的张量图像。

mean（sequence） - 每个通道的均值序列。

std（sequence） - 每个通道的标准偏差序列

torchvision.transforms.functional.pad（img，padding，fill = 0，padding_mode ='constant' ）
                                           #使用指定的填充模式和填充值在所有面上填充给定的PIL图像

img（PIL图像） - 要填充的图像。

padding（int或tuple） - 每个边框上的填充。如果提供单个int，则用于填充所有边框。如果提供长度为2的元组，则分别为左/右和上/下的填充。如果提供长度为4的元组，则分别为左，上，右和下边框的填充。

fill - 恒定填充的像素填充值。默认值为0.如果长度为3的元组，则分别用于填充R，G，B通道。仅当padding_mode为常量时才使用此值

padding_mode -

填充类型。应该是：恒定，边缘，反射或对称。默认值是常量。

常量：具有常量值的焊盘，该值用填充指定

edge：填充图像边缘的最后一个值

反射：具有图像反射的垫（不重复边缘上的最后一个值）

填充[1,2,3,4]在反射模式下两侧有2个元素将导致[3,2,1,2,3,4,3,2]

对称：具有图像反射的垫（重复边缘上的最后一个值）

填充[1,2,3,4]在对称模式下两侧有2个元素将导致[2,1,1,2,3,4,4,3]

torchvision.transforms.functional.perspective(img, startpoints, endpoints, interpolation=3)
                                                                  #执行给定PIL图像的透视变换

参数设置：
img（PIL图像） - 要转换的图像。

起始点 - 包含原始图像的[左上角，右上角，右下角，左下角]的列表

端点 - 包含变换图像的[左上角，右上角，右下角，左下角]的列表

interpolation - 默认 - Image.BICUBIC

torchvision.transforms.functional.resize（img，size，interpolation = 2 ）#将输入PIL图像的大小调整为给定大小

参数设置：mg（PIL图像） - 要调整大小的图像。

size（sequence 或int） - 所需的输出大小。
如果size是（h，w）之类的序列，则输出大小将与此匹配。
如果size是int，则图像的较小边缘将与保持纵横比的此数字匹配。
即，如果高度>宽度，则图像将重新缩放为 ：

interpolation（int，optional） - 所需的插值。默认是 PIL.Image.BILINEAR

 torchvision.transforms.functional.resized_crop（img，i，j，h，w，size，interpolation = 2 ）
                            #裁剪给定的PIL图像并将其调整为所需大小。特别是用于RandomResizedCrop

参数设置：
img（PIL图像） - 要裁剪的图像。

i（int） - i in （i，j）中，即左上角的坐标

j（int） - j in（i，j）即左上角的坐标

h（int） - 裁剪图像的高度。

w（int） - 裁剪图像的宽度。

size（sequence 或int） - 所需的输出大小。与语义相同resize。

interpolation（int，optional） - 所需的插值。默认是 PIL.Image.BILINEAR
torchvision.transforms.functional.rotate（img，angle，resample = False，expand = False，center = None ）#按角度旋转图像
参数设置：
img（PIL Image） - PIL要旋转的图像。

angle（float或int） - 以度数逆时针顺序。

resample（PIL.Image.NEAREST或PIL.Image.BILINEAR或PIL.Image.BICUBIC，可选） - 可选的重采样过滤器。如果省略，或者图像具有模式“1”或“P”，则将其设置为PIL.Image.NEAREST。

expand（bool，optional） - 可选的扩展标志。如果为true，则展开输出图像以使其足够大以容纳整个旋转图像。如果为false或省略，则使输出图像与输入图像的大小相同。请注意，展开标志假定围绕中心旋转而不进行平移。

center（2-tuple ，optional） - 可选的旋转中心。原点是左上角。默认值是图像的中心。

torchvision.transforms.functional.ten_crop（img，size，vertical_flip = False ）
                            #将给定的PIL图像裁剪成四个角，中央裁剪加上这些翻转版本（默认使用水平翻转）
                            #返回值为元组（tl，tr，bl，br，center，tl_flip，tr_flip，bl_flip，br_flip，center_flip）对应的左上角，右上角，左下角，右下角和中心裁剪，翻转图像相同

参数设置：
size（sequence 或int） - 作物的所需输出大小。如果size是int而不是像（h，w）这样的序列，则进行正方形裁剪（大小，大小）。

vertical_flip（bool） - 使用垂直翻转而不是水平翻转

torchvision.transforms.functional.to_grayscale（img，num_output_channels = 1 ）
                                                                  #将图像转换为图像的灰度版本

返回值：灰度版图像。
如果num_output_channels = 1：返回的图像是单通道

如果num_output_channels = 3：返回的图像是3通道，r = g = b
torchvision.transforms.functional.to_pil_image（pic，mode = None ）#将tensor或ndarray转换为PIL图像
参数设置：
pic（Tensor或numpy.ndarray） - 要转换为PIL图像的图像。

mode（PIL.Image mode） - 输入数据的颜色空间和像素深度（可选）

torchvision.transforms.functional.to_tensor（pic ）#Convert a PIL Image or numpy.ndarray to tensor.

参数设置：
pic（PIL Image 或numpy.ndarray） - 要转换为张量的图像
torchvision.transforms.functional.vflip（img ）#垂直翻转给定的PIL图像