torchvision.transforms

变换是常见的图像转换。它们可以使用Compose链接在一起。 此外，还有torchvision.transforms.functional模块。 功能变换提供了对转换的精细控制。 如果你需要构建更复杂的转换管道（例如在分割任务中），这非常有用。

所有变换都接受PIL图像、张量图像或张量图像批次作为输入。张量图像是一个具有 (C, H, W) 形状的张量，其中 C 是通道数，H 和 W 是图像的高度和宽度。张量图像批次是一个具有 (B, C, H, W) 形状的张量，其中 B 是批次中的图像数量。确定性或随机变换应用于张量图像批次时，会以相同的方式转换批次中的所有图像。

警告

自 v0.8.0 版本起，所有随机变换都使用 torch 默认的随机生成器来采样随机参数。 这是一个破坏向后兼容性的更改，用户应按照如下方式设置随机状态：

# Previous versions
# import random
# random.seed(12)

# Now
import torch
torch.manual_seed(17)

请记住，相同的种子值对于 torch 随机生成器和 Python 随机生成器不会产生相同的结果。

可编程转换

为了脚本转换，请使用torch.nn.Sequential而不是Compose。

transforms = torch.nn.Sequential(
    transforms.CenterCrop(10),
    transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
)
scripted_transforms = torch.jit.script(transforms)

确保只使用可脚本化的转换，即与torch.Tensor一起工作且不需要lambda函数或PIL.Image。

对于要与torch.jit.script一起使用的任何自定义转换，它们应该派生自torch.nn.Module。

变换的组合

class torchvision.transforms.Compose(transforms)

组合多个变换操作。此变换不支持 torchscript。 请参见下面的说明。

Parameters:转换 （Transform 对象列表） – 转换列表用于组合。

示例

>>> transforms.Compose([
>>>     transforms.CenterCrop(10),
>>>     transforms.ToTensor(),
>>> ])

注意

为了脚本转换，请如下使用torch.nn.Sequential。

>>> transforms = torch.nn.Sequential(
>>>     transforms.CenterCrop(10),
>>>     transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
>>> )
>>> scripted_transforms = torch.jit.script(transforms)

确保只使用可脚本化的转换，即可以处理torch.Tensor，不需要lambda函数或PIL.Image。

对PIL图像和torch.*Tensor的转换

class torchvision.transforms.CenterCrop(size)

裁剪给定图像的中心。 图像可以是 PIL 图像或 torch 张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:大小 (序列 或 整数) – 希望的裁剪输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会制作一个正方形裁剪 (size, size)。如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要裁剪的图像。 Returns:裁剪后的图像。 返回类型：PIL 图像或张量

class torchvision.transforms.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0)

随机改变图像的亮度、对比度和饱和度。

Parameters:

• 亮度 (float 或 python:float元组 (min, max)) – 调整亮度的程度。 亮度因子从[max(0, 1 - brightness), 1 + brightness]或给定的[min, max]中均匀选择。应为非负数。
• 对比度 (float 或 python:float 的元组 (min, max)) – 对比度抖动的程度。 contrast_factor 从[max(0, 1 - contrast), 1 + contrast]或给定的[min, max]中均匀选择。应该是非负数。
• 饱和度 (float 或 python:float元组 (min, max)) – 饱和度抖动的程度。 饱和度因子在[max(0, 1 - saturation), 1 + saturation]范围内均匀选择，或者在给定的[min, max]范围内。应为非负数。
• 色调 (float 或 python:float 的元组 (min, max)) – 色调抖动的程度。 hue_factor 从 [-hue, hue] 或给定的 [min, max] 中均匀选择。 应满足 0<= hue <= 0.5 或 -0.5 <= min <= max <= 0.5。

forward(img)

Parameters:图像 (PIL 图像或张量) – 输入图像。 Returns:颜色失真图像。 返回类型：PIL 图像或张量

static get_params(brightness, contrast, saturation, hue)

获取一个将应用于图像的随机变换。

参数与初始化函数的参数相同。

Returns:随机调整亮度、对比度和饱和度顺序的转换。

class torchvision.transforms.FiveCrop(size)

裁剪给定图像的四个角和中央部分。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

注意

此转换返回一个图像元组，可能存在输入和目标的数量不匹配的情况。您的数据集返回的输入和目标数量可能不一致。请参见下面的示例，了解如何处理这种情况。

Parameters:大小 (序列 或 整数) – 希望的裁剪输出大小。如果大小是一个 int 而不是像 (h, w) 这样的序列，则会制作一个大小为 (size, size) 的正方形裁剪。 如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。

示例

>>> 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

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要裁剪的图像。 Returns:5张图像的元组。图像可以是PIL图像或张量。

class torchvision.transforms.Grayscale(num_output_channels=1)

将图像转换为灰度图。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, 3, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:输出图像通道数 (int) – (1 或 3) 输出图像所需的通道数 Returns:

Grayscale version of the input.

• 如果 num_output_channels == 1 ：返回的图像是单通道
• 如果 num_output_channels == 3 ：返回的图像是3通道且r == g == b

返回类型：PIL 图像

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要转换为灰度图的图像。 Returns:灰度图像。 返回类型：PIL 图像或张量

class torchvision.transforms.Pad(padding, fill=0, padding_mode='constant')

在图像的四边用给定的“pad”值进行填充。 该图像可以是 PIL 图像或 torch 张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 填充 (int 或 元组 或 列表) – 每条边界的填充。如果提供一个单一的整数，这将用于填充所有边界。如果提供长度为2的元组，这是左右和上下边界的填充。如果提供长度为4的元组，这是左、上、右和下边界的填充。在torchscript模式下，不支持作为单一整数的填充，请使用长度为1的元组或列表：[padding, ]。
• 填充 (int 或 tuple) – 常数填充的像素填充值。默认为 0。如果是一个长度为 3 的元组，则分别用于填充 R、G、B 通道。 此值仅在 padding_mode 为常数时使用
• padding_mode (字符串) –

  填充类型。应为：constant、edge、reflect 或 symmetric。 默认为 constant。模式 symmetric 尚不支持张量输入。

  • 用常量值进行填充，该值通过fillvalue指定。
  • 边缘：用图像边缘的最后一个值进行填充
  • 用反射图像的方式填充，边缘不重复最后一个值

    For example, padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2]

  • 对称：用图像的镜像反射进行填充，在边缘重复最后一个值

    For example, padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3]

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要填充的图像。 Returns:填充图像。 返回类型：PIL 图像或张量

class torchvision.transforms.RandomAffine(degrees, translate=None, scale=None, shear=None, resample=0, fillcolor=0)

保持中心不变的图像随机仿射变换。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 角度 (序列 或 浮点数 或 整数) – 选择的角度范围。 如果角度是一个数字而不是像 (min, max) 这样的序列，则角度范围将是 (-degrees, +degrees)。设置为 0 以停用旋转。
• translate (元组, 可选) – 水平和垂直平移的最大绝对分数的元组。例如 translate=(a, b)，则水平偏移在 -img_width * a < dx < img_width * a 的范围内随机采样，垂直偏移在 -img_height * b < dy < img_height * b 的范围内随机采样。默认情况下不会平移。
• scale (元组, 可选) – 缩放因子区间，例如 (a, b)，则 scale 从范围 a <= scale <= b 中随机采样。默认情况下将保持原始比例。
• shear (序列 或 浮点数 或 整数, 可选) – 选择的角度范围。 如果 shear 是一个数字，将应用 x 轴平行的剪切，在 (-shear, +shear) 范围内。 否则如果 shear 是一个包含 2 个值的元组或列表，将应用 x 轴平行的剪切，在 (shear[0], shear[1]) 范围内。 否则如果 shear 是一个包含 4 个值的元组或列表，将在 (shear[0], shear[1]) 范围内应用 x 轴剪切，并在 (shear[2], shear[3]) 范围内应用 y 轴剪切。 默认情况下不会应用剪切。
• 重采样 (int, 可选) – 一个可选的重采样滤波器。有关更多信息，请参见 滤波器。 如果省略，或者图像模式为“1”或“P”，则将其设置为 PIL.Image.NEAREST。 如果输入是张量，则仅支持 PIL.Image.NEAREST 和 PIL.Image.BILINEAR。
• 填充颜色 (元组 或 整数) – 可选的填充颜色（RGB图像为元组，灰度图像为整数）用于输出图像中变换区域之外的区域 (Pillow>=5.0.0)。此选项不支持Tensor输入。输出图像中变换区域之外的填充值始终为0。

forward(img)

img (PIL Image or Tensor): Image to be transformed.

Returns:仿射变换图像。 返回类型：PIL 图像或张量

static get_params(degrees: List[float], translate: Union[List[float], NoneType], scale_ranges: Union[List[float], NoneType], shears: Union[List[float], NoneType], img_size: List[int]) → Tuple[float, Tuple[int, int], float, Tuple[float, float]]

获取仿射变换的参数

Returns:传递给仿射变换的参数

class torchvision.transforms.RandomApply(transforms, p=0.5)

以指定的概率随机应用一组变换。

注意

为了脚本转换，请使用torch.nn.ModuleList作为输入，而不是像下面所示的transforms列表/元组:

>>> transforms = transforms.RandomApply(torch.nn.ModuleList([
>>>     transforms.ColorJitter(),
>>> ]), p=0.3)
>>> scripted_transforms = torch.jit.script(transforms)

确保只使用可脚本化的转换，即可以处理torch.Tensor，不需要lambda函数或PIL.Image。

Parameters:

• transforms (列表 或 元组 或 torch.nn.Module) – 转换列表
• p (float) – 概率

class torchvision.transforms.RandomCrop(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant')

在给定图像的随机位置裁剪图像。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:

• 大小 (序列 或 整数) – 希望的裁剪输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会制作一个正方形裁剪 (size, size)。如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。
• 填充 (int 或 序列, 可选) – 可选的图像各边填充。默认为 None。如果提供一个整数，这将用于填充所有边框。如果提供长度为 2 的元组，这将是左右和上下边框的填充。如果提供长度为 4 的元组，这将是左、上、右和下边框的填充。在 torchscript 模式下，不支持单个整数作为填充，使用长度为 1 的元组或列表：[padding, ]。
• pad_if_needed (布尔值) – 如果图像小于所需大小，则会进行填充以避免抛出异常。由于裁剪是在填充之后进行的，因此填充似乎是在随机偏移处完成的。
• 填充 (int 或 tuple) – 常数填充的像素填充值。默认为 0。如果是一个长度为 3 的元组，则分别用于填充 R、G、B 通道。 此值仅在 padding_mode 为常数时使用
• padding_mode (字符串) –

  填充类型。应为：constant、edge、reflect 或 symmetric。默认为 constant。 模式 symmetric 尚不支持张量输入。

  • constant: pads with a constant value, this value is specified with fill
  • edge: pads with the last value on the edge of the image
  • reflect: pads with reflection of image (without repeating the last value on the edge)

    padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2]

  • symmetric: pads with reflection of image (repeating the last value on the edge)

    padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3]

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要裁剪的图像。 Returns:裁剪后的图像。 返回类型：PIL 图像或张量

static get_params(img: torch.Tensor, output_size: Tuple[int, int]) → Tuple[int, int, int, int]

获取随机裁剪的参数 crop。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。
• output_size (元组) – 期望的裁剪输出大小。

Returns:

参数 (i, j, h, w) 将传递给 crop 以进行随机裁剪。

返回类型：

元组

class torchvision.transforms.RandomGrayscale(p=0.1)

以概率 p（默认值为 0.1）随机将图像转换为灰度。 图像可以是 PIL 图像或张量，在这种情况下，它应具有[…, 3, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:p (float) – 图像应转换为灰度的概率。 Returns:输入图像的灰度版本，概率为 p，不变的概率为 (1-p)。 - 如果输入图像是单通道：灰度版本也是单通道 - 如果输入图像是三通道：灰度版本是三通道且 r == g == b 返回类型：PIL 图像或张量

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要转换为灰度图的图像。 Returns:随机灰度化图像。 返回类型：PIL 图像或张量

class torchvision.transforms.RandomHorizontalFlip(p=0.5)

随机以给定的概率水平翻转给定的图像。 图像可以是 PIL 图像或 torch 张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:p (float) – 图像被翻转的概率。默认值为 0.5

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要翻转的图像。 Returns:随机翻转的图像。 返回类型：PIL 图像或张量

class torchvision.transforms.RandomPerspective(distortion_scale=0.5, p=0.5, interpolation=2, fill=0)

以给定的概率对给定图像执行随机透视变换。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• distortion_scale (float) – 参数用于控制扭曲程度，范围从 0 到 1。 默认值为 0.5。
• p (float) – 图像被转换的概率。默认值为 0.5。
• 插值 (整数) – 插值类型。如果输入是Tensor，仅支持PIL.Image.NEAREST和 PIL.Image.BILINEAR。默认情况下，PIL.Image.BILINEAR用于PIL图像和Tensor。
• 填充 (n-元组 或 整数 或 浮点数) – 旋转图像外部区域的像素填充值。如果为整数或浮点数，则分别用于所有带。默认值为0。 此选项仅适用于pillow>=5.0.0。此选项不支持Tensor输入。输出图像中变换区域外部的填充值始终为0。

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要进行透视变换的图像。 Returns:随机变换后的图像。 返回类型：PIL 图像或张量

static get_params(width: int, height: int, distortion_scale: float) → Tuple[List[List[int]], List[List[int]]]

获取用于perspective的随机透视变换参数。

Parameters:

• 宽度 (int) – 图像的宽度。
• 高度 (整数) – 图像的高度。
• distortion_scale (float) – 参数用于控制扭曲程度，范围从 0 到 1。

Returns:

包含原始图像左上角、右上角、右下角、左下角的列表， 包含变换后图像左上角、右上角、右下角、左下角的列表。

class torchvision.transforms.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=2)

随机裁剪给定图像的大小和宽高比。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

随机裁剪原始图像的一部分（默认大小为原始大小的 0.08 到 1.0），并保持原始宽高比的一个随机比例（默认为 3/4 到 4/3）。最终将此裁剪部分调整到给定大小。 这种方法常用于训练 Inception 网络。

Parameters:

• 大小 (int 或 序列) – 每条边的预期输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会生成一个正方形输出大小 (size, size)。如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。
• 缩放比例 (python:float元组) – 原始尺寸裁剪范围
• 比例 (python:float元组) – 原始宽高比裁剪的宽高比范围。
• 插值 (整数) – 希望的插值枚举由 滤波器 定义。 默认是 PIL.Image.BILINEAR。如果输入是 Tensor，仅支持 PIL.Image.NEAREST, PIL.Image.BILINEAR 和 PIL.Image.BICUBIC。

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要裁剪和调整大小的图像。 Returns:随机裁剪并调整大小的图像。 返回类型：PIL 图像或张量

static get_params(img: torch.Tensor, scale: List[float], ratio: List[float]) → Tuple[int, int, int, int]

获取大小随机裁剪的 crop 的参数。

Parameters:

• 图像 (PIL 图像或张量) – 输入图像。
• 缩放比例 (列表) – 裁剪原尺寸的缩放范围
• 比例 (列表) – 原始宽高比裁剪的宽高比范围

Returns:

params (i, j, h, w) to be passed to crop for a random

大小的裁剪。

返回类型：

元组

class torchvision.transforms.RandomRotation(degrees, resample=False, expand=False, center=None, fill=None)

以指定的角度旋转图像。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:

• 角度 (序列 或 浮点数 或 整数) – 选择的角度范围。 如果角度是一个数字而不是像 (min, max) 这样的序列，则角度范围将是 (-degrees, +degrees)。
• 重采样 (int, 可选) – 可选的重采样滤波器。有关更多信息，请参见滤波器。 如果省略，或者图像模式为“1”或“P”，则设置为PIL.Image.NEAREST。 如果输入为张量，则仅支持PIL.Image.NEAREST和PIL.Image.BILINEAR。
• 展开 (bool, 可选) – 可选的扩展标志。 如果为真，将输出扩展到足以容纳整个旋转图像的大小。 如果为假或省略，则输出图像与输入图像大小相同。 请注意，扩展标志假设围绕中心旋转且没有平移。
• 中心 (列表 或 元组, 可选) – 可选的旋转中心，(x, y)。原点是图像的左上角。 默认为图像的中心。
• 填充 (n-元组 或 整数 或 浮点数) – 旋转图像外部区域的像素填充值。如果为整数或浮点数，则所有带分别使用该值。 默认情况下，所有带都为0。此选项仅适用于Pillow>=5.2.0。 此选项不支持Tensor输入。输出图像中变换区域外部的填充值始终为0。

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要旋转的图像。 Returns:旋转图像。 返回类型：PIL 图像或张量

static get_params(degrees: List[float]) → float

获取随机旋转的参数 rotate。

Returns:角度参数将传递给rotate以进行随机旋转。 返回类型：浮点型

class torchvision.transforms.RandomSizedCrop(*args, **kwargs)

注意：此转换已被 RandomResizedCrop 取代。

class torchvision.transforms.RandomVerticalFlip(p=0.5)

随机以给定的概率垂直翻转给定的图像。 图像可以是 PIL 图像或 torch 张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:p (float) – 图像被翻转的概率。默认值为 0.5

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要翻转的图像。 Returns:随机翻转的图像。 返回类型：PIL 图像或张量

class torchvision.transforms.Resize(size, interpolation=2)

将输入图像调整为给定大小。 图像可以是 PIL 图像，也可以是 torch 张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 大小 (序列 或 整数) – 期望的输出大小。如果大小是一个序列如 (h, w)，输出大小将与此匹配。如果大小是一个整数， 图像的较小边将与此数字匹配。 即，如果高度 > 宽度，则图像将被重新缩放为 (size * 高度 / 宽度, size). 在torchscript模式下不支持单个整数作为填充，使用长度为1的元组或 列表：[size, ]。
• 插值 (int, 可选) – 希望的插值枚举由滤波器定义。 默认是PIL.Image.BILINEAR。如果输入是Tensor，仅支持PIL.Image.NEAREST、PIL.Image.BILINEAR 和PIL.Image.BICUBIC。

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要缩放的图像。 Returns:重缩放图像。 返回类型：PIL 图像或张量

class torchvision.transforms.Scale(*args, **kwargs)

注意：此转换已被弃用，建议使用 Resize。

class torchvision.transforms.TenCrop(size, vertical_flip=False)

裁剪给定图像的四个角和中央部分，并生成这些裁剪图的水平翻转版本。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

注意

此转换返回一个图像元组，可能存在输入和目标的数量不匹配的情况。您的数据集返回的输入和目标数量可能不一致。请参见下面的示例，了解如何处理这种情况。

Parameters:

• 大小 (序列 或 整数) – 希望的裁剪输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会制作一个正方形裁剪 (size, size)。如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。
• 垂直翻转 (bool) – 使用垂直翻转而不是水平翻转

示例

>>> 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

forward(img)

Parameters:图像 (PIL 图像或张量) – 需要裁剪的图像。 Returns:包含10张图像的元组。图像可以是PIL图像或张量。

class torchvision.transforms.GaussianBlur(kernel_size, sigma=(0.1, 2.0))

使用随机选择的高斯模糊来模糊图像。 图像可以是 PIL 图像，也可以是张量，在这种情况下，它应该具有[…, C, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:

• kernel_size (整数 或 序列) – 高斯核的大小。
• sigma (float 或 python:float 的元组 (min, max)) – 用于创建执行模糊处理的内核的标准差。如果是浮点数，则 sigma 是固定的。如果是浮点数的元组 (min, max)，则 sigma 将在给定范围内均匀随机选择。

Returns:

输入图像的高斯模糊版本。

返回类型：

PIL 图像或张量

forward(img: torch.Tensor) → torch.Tensor

Parameters:图像 (PIL 图像或张量) – 需要模糊的图像。 Returns:高斯模糊图像 返回类型：PIL 图像或张量

static get_params(sigma_min: float, sigma_max: float) → float

选择用于随机高斯模糊的 sigma 值。

Parameters:

• sigma_min (float) – 可以选择的模糊核的最小标准差。
• sigma_max (float) – 可以选择的最大标准差，用于模糊核。

Returns:

用于计算高斯模糊核的标准差。

返回类型：

浮点型

仅对PIL图像进行转换

class torchvision.transforms.RandomChoice(transforms)

从列表中随机选择一个变换进行应用。此变换不支持 TorchScript。

class torchvision.transforms.RandomOrder(transforms)

以随机顺序应用一组转换。此转换不支持 TorchScript。

仅对torch.*Tensor进行变换

class torchvision.transforms.LinearTransformation(transformation_matrix, mean_vector)

将张量图像与一个正方形变换矩阵和一个离线计算的均值向量进行转换。 给定变换矩阵和均值向量，将展平 torch.*Tensor，并从中减去均值向量，然后计算与变换矩阵的点积，最后将张量重塑为其原始形状。

Applications:

白化变换：假设 X 是一个零均值化的列向量数据。 然后计算数据协方差矩阵 [D x D]，使用 torch.mm(X.t(), X)， 对该矩阵进行奇异值分解，并将其作为变换矩阵传递。

Parameters:

• 变换矩阵 (张量) – 张量 [D x D], D = C x H x W
• 均值向量 (张量) – 张量 [D], D = C x H x W

forward(tensor: torch.Tensor) → torch.Tensor

Parameters:张量 (张量) – 用于白化的张量图像。 Returns:变换后的图像。 返回类型：张量

class torchvision.transforms.Normalize(mean, std, inplace=False)

用均值和标准差对张量图像进行归一化。 给定均值：(mean[1],...,mean[n]) 和标准差：(std[1],..,std[n]) 对于 n 通道，此变换将对输入的每个通道进行归一化 torch.*Tensor 即， output[channel] = (input[channel] - mean[channel]) / std[channel]

注意

此变换在原地之外进行，即它不会更改输入张量。

Parameters:

• 均值 (序列) – 每个通道的均值序列。
• std (序列) – 每个通道的标准差序列。
• 原地操作 (bool,可选) – 布尔值，用于使此操作就地进行。

forward(tensor: torch.Tensor) → torch.Tensor

Parameters:张量 (张量) – 需要归一化的张量图像。 Returns:归一化张量图像。 返回类型：张量

class torchvision.transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0, inplace=False)

随机选择图像中的一个矩形区域并擦除其像素。 ‘随机擦除数据增强’由Zhong等人提出。详见 https://arxiv.org/abs/1708.04896

Parameters:

• p – 随机擦除操作执行的概率。
• 比例 – 被擦除区域相对于输入图像的比例范围。
• 比例 – 删除区域的宽高比范围。
• 值 – 清除值。默认为0。如果是一个整数，则用于清除所有像素。如果是一个长度为3的元组，则分别用于清除R、G、B通道。 如果是一个字符串'random'，则用随机值清除每个像素。
• 就地 – 布尔值，用于使此转换就地进行。默认设置为False。

Returns:

擦除图像。

示例

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

forward(img)

Parameters:图像 (张量) – 需要擦除的张量图像。 Returns:擦除的张量图像。 返回类型：img (张量)

static get_params(img: torch.Tensor, scale: Tuple[float, float], ratio: Tuple[float, float], value: Union[List[float], NoneType] = None) → Tuple[int, int, int, int, torch.Tensor]

获取随机擦除的参数 erase。

Parameters:

• 图像 (张量) – 需要擦除的张量图像。
• scale (元组 或 列表) – 输入图像的擦除区域比例范围。
• 比例 (元组 或 列表) – 擦除区域的宽高比范围。
• 值 (列表, 可选) – 擦除的值。如果为 None，则解释为“随机”（每个像素用随机值擦除）。如果 len(value) 是 1，则解释为一个数字，即 value[0]。

Returns:

参数 (i, j, h, w, v) 将传递给 erase 用于随机擦除。

返回类型：

元组

class torchvision.transforms.ConvertImageDtype(dtype: torch.dtype) → None

将张量图像转换为指定的dtype并相应地调整值

Parameters:数据类型 (torch.dpython:type) – 输出所需的數據類型

注意

当从较小的整数转换为较大的整数时，dtype 最大值不会精确映射。 如果来回转换，这种不匹配不会产生影响。

Raises:RuntimeError – 当尝试将 torch.float32 转换为 torch.int32 或 torch.int64 以及尝试将 torch.float64 转换为 torch.int64 时。这些转换可能会导致溢出错误，因为浮点数 dtype 无法在整个整数范围内存储连续的整数。

转换变换

class torchvision.transforms.ToPILImage(mode=None)

将张量或 ndarray 转换为 PIL 图像。此转换不支持 TorchScript。

将形状为 C x H x W 的 torch.*Tensor 或形状为 H x W x C 的 numpy ndarray 转换为 PIL 图像，同时保持值范围。

Parameters:模式 (PIL.Image 模式) – 输入数据的颜色空间和像素深度（可选）。 如果 mode 是 None（默认），则对输入数据有一些假设： - 如果输入有 4 个通道，则 mode 假设为 RGBA。 - 如果输入有 3 个通道，则 mode 假设为 RGB。 - 如果输入有 2 个通道，则 mode 假设为 LA。 - 如果输入有 1 个通道，则 mode 由数据类型确定（即 int、float、short）。

class torchvision.transforms.ToTensor

将一个 PIL Image 或 numpy.ndarray 转换为张量。此转换不支持 TorchScript。

将范围在 [0, 255] 的 PIL 图像或 numpy.ndarray (H x W x C) 转换为范围在 [0.0, 1.0] 的形状为 (C x H x W) 的 torch.FloatTensor。 如果 PIL 图像属于以下模式之一 (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1)，或者如果 numpy.ndarray 的数据类型为 np.uint8，则进行转换。

在其他情况下，张量将以未缩放的形式返回。

注意

因为输入图像被缩放到 [0.0, 1.0]，此转换不应在变换目标图像掩码时使用。有关实现图像掩码变换的参考，请参见 参考文献。

通用变换

class torchvision.transforms.Lambda(lambd)

应用用户定义的 lambda 函数作为转换。此转换不支持 torchscript。

Parameters:lambda (函数) – 用于转换的 lambda/函数。

功能变换

功能变换为您提供对转换管道的精细控制。 与上述变换不同，功能变换不包含其参数的随机数生成器。 这意味着您必须指定/生成所有参数，但您可以重用功能变换。

你可以像这样对多张图片应用具有相同参数的功能转换：

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

你可以使用函数式转换来构建具有自定义行为的转换类：

import torchvision.transforms.functional as TF
import random

class MyRotationTransform:
    """Rotate by one of the given angles."""

    def __init__(self, angles):
        self.angles = angles

    def __call__(self, x):
        angle = random.choice(self.angles)
        return TF.rotate(x, angle)

rotation_transform = MyRotationTransform(angles=[-30, -15, 0, 15, 30])

torchvision.transforms.functional.adjust_brightness(img: torch.Tensor, brightness_factor: float) → torch.Tensor

调整图像的亮度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• brightness_factor (float) – 如何调整亮度。可以是任何非负数。0 给出一个黑色图像，1 给出原始图像，而 2 将亮度增加一倍。

Returns:

调整亮度后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.adjust_contrast(img: torch.Tensor, contrast_factor: float) → torch.Tensor

调整图像的对比度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• 对比度因子 (float) – 对比度调整的程度。可以是任何非负数。0 会给出一张纯灰色的图像，1 会给出原始图像，而 2 则将对比度增加一倍。

Returns:

调整对比度后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.adjust_gamma(img: torch.Tensor, gamma: float, gain: float = 1) → torch.Tensor

对图像进行伽马校正。

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

\[I_{\text{out}} = 255 \times \text{gain} \times \left(\frac{I_{\text{in}}}{255}\right)^{\gamma}\]

请参阅 伽玛校正 了解更多信息。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的PIL图像。
• gamma (float) – 非负实数，等同于方程中的 \(\gamma\)。 gamma 大于 1 会使阴影变暗， 而 gamma 小于 1 会使黑暗区域变亮。
• 增益 (float) – 常数乘数。

Returns:

伽马校正调整后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.adjust_hue(img: torch.Tensor, hue_factor: float) → torch.Tensor

调整图像的色相。

通过将图像转换为HSV格式并循环移动色相通道（H）中的强度来调整图像色调。然后将图像转换回原始图像模式。

hue_factor 是 H 通道的位移量，必须在区间 [-0.5, 0.5] 内。

参见 Hue 以获取更多详细信息。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• hue_factor (float) – 色相通道偏移量。应在 [-0.5, 0.5] 范围内。0.5 和 -0.5 分别在 HSV 空间中正向和负向完全反转色相通道。 0 表示不偏移。因此，-0.5 和 0.5 都会生成互补颜色的图像，而 0 则会给出原始图像。

Returns:

色调调整后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.adjust_saturation(img: torch.Tensor, saturation_factor: float) → torch.Tensor

调整图像的颜色饱和度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• 饱和度因子 (float) – 调整饱和度的程度。0 将给出黑白图像，1 将给出原始图像，而 2 将将饱和度增强 2 倍。

Returns:

饱和度调整后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.affine(img: torch.Tensor, angle: float, translate: List[int], scale: float, shear: List[float], resample: int = 0, fillcolor: Union[int, NoneType] = None) → torch.Tensor

对图像进行仿射变换，保持图像中心不变。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要转换的图像。
• 角度 (float 或 int) – 旋转角度以度为单位，范围在 -180 到 180 之间，顺时针方向。
• translate (列表 或 python整数的元组) – 水平和垂直平移（旋转后的平移）
• 缩放 (float) – 总体缩放
• shear (float 或 tuple 或 list) – 剪切角度值以度为单位，范围从 -180 到 180，顺时针方向。 如果指定了元组或列表，则第一个值对应于平行于 x 轴的剪切，而 第二个值对应于平行于 y 轴的剪切。
• 重采样 (PIL.Image.NEAREST 或 PIL.Image.BILINEAR 或 PIL.Image.BICUBIC, 可选) – 一个可选的重采样滤波器。有关更多信息，请参见 滤波器。 如果省略，或者图像为 PIL Image 并且模式为 “1” 或 “P”，则将其设置为 PIL.Image.NEAREST。 如果输入为 Tensor，则仅支持 PIL.Image.NEAREST 和 PIL.Image.BILINEAR。
• 填充颜色 (int) – 可选的填充颜色，用于输出图像中变换区域之外的区域 (Pillow>=5.0.0)。 此选项不支持Tensor输入。输出图像中变换区域之外的填充值始终为0。

Returns:

变换后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.center_crop(img: torch.Tensor, output_size: List[int]) → torch.Tensor

裁剪给定图像的中心。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。
• output_size (序列 或 整数) – (高度, 宽度) 的裁剪框。如果为整数或包含单个整数的序列 则用于两个方向。

Returns:

裁剪后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.convert_image_dtype(image: torch.Tensor, dtype: torch.dtype = torch.float32) → torch.Tensor

将张量图像转换为指定的dtype并相应地调整值

Parameters:

• 图像 (torch.Tensor) – 需要转换的图像
• 数据类型 (torch.dpython:type) – 输出所需的數據類型

Returns:

转换后的图像

返回类型：

张量

注意

当从较小的整数转换为较大的整数时，dtype 最大值不会精确映射。 如果来回转换，这种不匹配不会产生影响。

Raises:RuntimeError – 当尝试将 torch.float32 转换为 torch.int32 或 torch.int64 以及尝试将 torch.float64 转换为 torch.int64 时。这些转换可能会导致溢出错误，因为浮点数 dtype 无法在整个整数范围内存储连续的整数。

torchvision.transforms.functional.crop(img: torch.Tensor, top: int, left: int, height: int, width: int) → torch.Tensor

在指定位置裁剪给定图像，并输出所需大小。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。 (0,0) 表示图像的左上角。
• 顶部 (整数) – 裁剪框左上角的垂直组件。
• 左 (整数) – 作物框左上角的水平分量。
• 高度 (int) – 裁剪框的高度。
• 宽度 (int) – 裁剪框的宽度。

Returns:

裁剪后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.erase(img: torch.Tensor, i: int, j: int, h: int, w: int, v: torch.Tensor, inplace: bool = False) → torch.Tensor

用给定的值擦除输入张量图像。

Parameters:

• 图像 (张量图像) – 尺寸为 (C, H, W) 的要擦除的张量图像
• i (int) – i 在 (i,j) 中，即左上角的坐标。
• j (int) – j 在 (i,j) 中，即左上角的坐标。
• h (int) – 擦除区域的高度。
• w (int) – 擦除区域的宽度。
• v – 清除值。
• 就地操作 (bool, 可选) – 用于就地操作。默认为False。

Returns:

擦除图像。

返回类型：

张量 图像

torchvision.transforms.functional.five_crop(img: torch.Tensor, size: List[int]) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]

裁剪给定图像的四个角和中央部分。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

注意

此转换返回图像元组，可能存在输入和目标数量不匹配的情况，而您的Dataset返回。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。
• 大小 (序列 或 整数) – 希望的裁剪输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会制作一个正方形裁剪 (size, size)。如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。

Returns:

tuple (tl, tr, bl, br, center)

左上角、右上角、左下角、右下角和中心裁剪。

返回类型：

元组

torchvision.transforms.functional.gaussian_blur(img: torch.Tensor, kernel_size: List[int], sigma: Union[List[float], NoneType] = None) → torch.Tensor

对图像进行高斯模糊处理，给定卷积核。 图像可以是 PIL 图像或张量，在这种情况下，它应具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要模糊的图像
• kernel_size (python整数序列 或 整数) – 高斯核大小。可以是整数序列 如 (kx, ky) 或一个单独的整数用于正方形核。 在torchscript模式下，单个整数作为kernel_size不被支持，请使用长度为1的元组或 列表：[ksize, ]。
• sigma (python序列中的浮点数 或 浮点数, 可选) – 高斯核的标准差。可以是像 (sigma_x, sigma_y) 这样的浮点数序列，或者一个单一的浮点数来定义X/Y方向相同的sigma。如果为None，则使用 kernel_size 作为 sigma = 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8 来计算。 默认值，None。在torchscript模式下，sigma作为单一浮点数不被支持，使用长度为1的元组或列表：[sigma, ]。

Returns:

高斯模糊版本的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.hflip(img: torch.Tensor) → torch.Tensor

水平翻转给定的 PIL 图像或张量。

Parameters:图像 (PIL 图像或张量) – 要翻转的图像。如果图像是张量，它应为[…, H, W]格式， 其中…表示它可以有任意数量的尾随维度。 Returns:水平翻转的图像。 返回类型：PIL 图像或张量

torchvision.transforms.functional.normalize(tensor: torch.Tensor, mean: List[float], std: List[float], inplace: bool = False) → torch.Tensor

用均值和标准差对张量图像进行标准化。

注意

此转换默认情况下在原地外进行，即它不会更改输入张量。

详见 Normalize 以获取更多详细信息。

Parameters:

• 张量 (张量) – 需要归一化的大小为 (C, H, W) 或 (B, C, H, W) 的张量图像。
• 均值 (序列) – 每个通道的均值序列。
• std (序列) – 每个通道的标准差序列。
• 原地计算 (bool,可选) – 布尔值，用于使此操作就地进行。

Returns:

归一化张量图像。

返回类型：

张量

torchvision.transforms.functional.pad(img: torch.Tensor, padding: List[int], fill: int = 0, padding_mode: str = 'constant') → torch.Tensor

在图像的四边用给定的“pad”值进行填充。 该图像可以是 PIL 图像或 torch 张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要填充的图像。
• 填充 (int 或 元组 或 列表) – 每条边界的填充。如果提供一个单一的整数，这将用于填充所有边界。如果提供长度为2的元组，这是左右和上下边界的填充。如果提供长度为4的元组，这是左、上、右和下边界的填充。在torchscript模式下，不支持作为单一整数的填充，请使用长度为1的元组或列表：[padding, ]。
• 填充 (int 或 str 或 tuple) – 常数填充模式下的像素填充值。默认值为 0。如果是一个长度为 3 的元组，则分别用于填充 R、G、B 通道。 此值仅在 padding_mode 为常数时使用。对于张量，仅支持 int 类型的值。
• padding_mode –

  填充类型。应为：constant、edge、reflect 或 symmetric。默认为 constant。 模式 symmetric 尚不支持张量输入。

  • 用常量值进行填充，该值通过fillvalue指定。
  • 边缘：用图像边缘的最后一个值进行填充
  • 以反射图像的方式填充（不在边缘重复最后一个值）

    padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2]

  • 对称：用图像的镜像填充（在边缘重复最后一个值）

    padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3]

Returns:

填充图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.perspective(img: torch.Tensor, startpoints: List[List[int]], endpoints: List[List[int]], interpolation: int = 2, fill: Union[int, NoneType] = None) → torch.Tensor

对给定图像执行透视变换。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要转换的图像。
• 起始点 (整数列表的列表) – 包含四个整数列表，每个列表包含两个整数，对应原始图像的四个角。 [top-left, top-right, bottom-right, bottom-left]
• 端点 (整数列表的列表) – 包含四个整数列表，每个列表包含两个整数，对应于转换后图像的四个角。 [top-left, top-right, bottom-right, bottom-left] 的转换后图像。
• 插值 (整数) – 插值类型。如果输入是Tensor，仅支持PIL.Image.NEAREST和 PIL.Image.BILINEAR。默认情况下，PIL.Image.BILINEAR用于PIL图像和Tensor。
• 填充 (n-元组 或 整数 或 浮点数) – 旋转图像外部区域的像素填充值。如果为整数或浮点数，则分别用于所有带。此选项仅适用于pillow>=5.0.0。此选项不支持张量输入。输出图像中变换区域外部的填充值始终为0。

Returns:

变换后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.pil_to_tensor(pic)

将一个 PIL Image 转换为相同类型的张量。

参见 PILToTensor 以获取更多详细信息。

Parameters:图片 (PIL 图像) – 需要转换为张量的图像。 Returns:转换后的图像。 返回类型：张量

torchvision.transforms.functional.resize(img: torch.Tensor, size: List[int], interpolation: int = 2) → torch.Tensor

将输入图像调整为给定大小。 图像可以是 PIL 图像，也可以是 torch 张量，在这种情况下，它应该具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整大小的图像。
• 大小 (序列 或 整数) – 期望的输出大小。如果大小是一个序列如 (h, w)，则输出大小将与此匹配。如果大小是一个整数， 则图像的较小边将与此数字匹配，同时保持宽高比。即，如果高度 > 宽度，则图像将被重新缩放至 \(\left(\text{size} \times \frac{\text{height}}{\text{width}}, \text{size}\right)\). 在torchscript模式下不支持单个整数作为大小，请使用长度为1的元组或 列表：[size, ]。
• 插值 (int, 可选) – 希望的插值枚举由滤波器定义。 默认是PIL.Image.BILINEAR。如果输入是Tensor，仅支持PIL.Image.NEAREST、PIL.Image.BILINEAR 和PIL.Image.BICUBIC。

Returns:

缩放后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.resized_crop(img: torch.Tensor, top: int, left: int, height: int, width: int, size: List[int], interpolation: int = 2) → torch.Tensor

裁剪给定的图像并将其调整为所需的大小。 图像可以是 PIL 图像或张量，在这种情况下，它应具有[…, H, W] 形状，其中…表示任意数量的前置维度。

显著用于RandomResizedCrop。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。 (0,0) 表示图像的左上角。
• 顶部 (整数) – 裁剪框左上角的垂直组件。
• 左 (整数) – 作物框左上角的水平分量。
• 高度 (int) – 裁剪框的高度。
• 宽度 (int) – 裁剪框的宽度。
• 大小 (序列 或 整数) – 期望的输出大小。与 resize 具有相同的语义。
• 插值 (int, 可选) – 希望的插值枚举由滤波器定义。 默认是PIL.Image.BILINEAR。如果输入是Tensor，仅支持PIL.Image.NEAREST、PIL.Image.BILINEAR 和PIL.Image.BICUBIC。

Returns:

裁剪后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.rgb_to_grayscale(img: torch.Tensor, num_output_channels: int = 1) → torch.Tensor

将RGB图像转换为灰度图像。 该图像可以是PIL图像或张量，在这种情况下，它应具有[…, H, W]形状，其中…表示任意数量的前置维度。

注意

请注意，此方法仅支持RGB图像作为输入。对于其他颜色空间的输入， 请考虑使用meth:~torchvision.transforms.functional.to_grayscale与PIL Image。

Parameters:

• 图像 (PIL 图像或张量) – 要转换为灰度的RGB图像。
• 输出通道数 (int) – 输出图像的通道数。值可以为1或3。默认值为1。

Returns:

Grayscale version of the image.

如果 num_output_channels = 1 ：返回的图像为单通道

如果 num_output_channels = 3 ：返回的图像为 3 通道，且 r = g = b

返回类型：

PIL 图像或张量

torchvision.transforms.functional.rotate(img: torch.Tensor, angle: float, resample: int = 0, expand: bool = False, center: Union[List[int], NoneType] = None, fill: Union[int, NoneType] = None) → torch.Tensor

以指定的角度旋转图像。 图像可以是 PIL 图像或张量，在这种情况下，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要旋转的图像。
• 角度 (float 或 int) – 旋转角度值（以度为单位，逆时针方向）。
• 重采样 (PIL.Image.NEAREST 或 PIL.Image.BILINEAR 或 PIL.Image.BICUBIC, 可选) – 一个可选的重采样滤波器。有关更多信息，请参见 滤波器。 如果省略，或者图像模式为“1”或“P”，则设置为 PIL.Image.NEAREST。
• 展开 (bool, 可选) – 可选的扩展标志。 如果为真，将输出图像扩展到足以容纳整个旋转图像的大小。 如果为假或省略，则输出图像与输入图像大小相同。 请注意，扩展标志假设围绕中心旋转且没有平移。
• 中心 (列表 或 元组, 可选) – 可选的旋转中心。原点是图像的左上角。 默认是图像的中心。
• 填充 (n-元组 或 整数 或 浮点数) – 旋转图像外部区域的像素填充值。如果为整数或浮点数，则所有带分别使用该值。 默认情况下，所有带都为0。此选项仅适用于pillow>=5.2.0。 此选项不支持Tensor输入。输出图像中变换区域外部的填充值始终为0。

Returns:

旋转图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.ten_crop(img: torch.Tensor, size: List[int], vertical_flip: bool = False) → List[torch.Tensor]

生成给定图像的十张裁剪图。 将给定图像裁剪为四个角和中央区域，并加上这些裁剪图的水平翻转版本。 图像可以是 PIL 图像或张量，在这种情况下，它应具有[…, H, W] 形状，其中…表示任意数量的前置维度。

注意

此转换返回图像元组，可能存在输入和目标数量不匹配的情况，而您的Dataset返回。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。
• 大小 (序列 或 整数) – 希望的裁剪输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会制作一个正方形裁剪 (size, size)。如果提供了一个长度为 1 的元组或列表，它将被解释为 (size[0], size[0])。
• 垂直翻转 (bool) – 使用垂直翻转而不是水平翻转

Returns:

tuple (tl, tr, bl, br, center, tl_flip, tr_flip, bl_flip, br_flip, center_flip)

对应左上角、右上角、左下角、右下角和中心裁剪，以及翻转图像也是如此。

返回类型：

元组

torchvision.transforms.functional.to_grayscale(img, num_output_channels=1)

将任何模式（RGB、HSV、LAB 等）的 PIL 图像转换为其灰度版本图像。

Parameters:

• 图像 (PIL 图像) – 需要转换为灰度的PIL图像。
• 输出通道数 (int) – 输出图像的通道数。值可以为1或3。默认值为1。

Returns:

Grayscale version of the image.

如果 num_output_channels = 1 ：返回的图像为单通道

如果 num_output_channels = 3 ：返回的图像为 3 通道，且 r = g = b

返回类型：

PIL 图像

torchvision.transforms.functional.to_pil_image(pic, mode=None)

将张量或 ndarray 转换为 PIL 图像。

详见 ToPILImage 以获取更多详细信息。

Parameters:

• 图片 (张量或numpy.ndarray) – 要转换为PIL图像的图像。
• 模式 (PIL.Image 模式) – 输入数据的颜色空间和像素深度（可选）。

Returns:图像已转换为PIL图像。 返回类型：PIL 图像

torchvision.transforms.functional.to_tensor(pic)

将一个 PIL Image 或 numpy.ndarray 转换为张量。

参见 ToTensor 以获取更多详细信息。

Parameters:图片 (PIL 图像或numpy.ndarray) – 要转换为张量的图像。 Returns:转换后的图像。 返回类型：张量

torchvision.transforms.functional.vflip(img: torch.Tensor) → torch.Tensor

垂直翻转给定的 PIL 图像或 torch 张量。

Parameters:图像 (PIL 图像或张量) – 要翻转的图像。如果图像是张量，它应为[…, H, W]格式， 其中…表示它可以有任意数量的尾随维度。 Returns:垂直翻转的图像。 返回类型：PIL 图像