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)

裁剪给定图像的中心。 如果图像为 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。 如果图像在任一边的大小小于输出大小，则会在图像周围填充 0 然后进行中心裁剪。

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)

随机改变图像的亮度、对比度、饱和度和色调。 如果图像是 torch 张量，它应该具有[…, 3, H, W] 的形状，其中…表示任意数量的前置维度。 如果图像是 PIL 图像，则不支持模式“1”、“L”、“I”、“F”以及带有透明通道的模式。

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: Union[List[float], NoneType], contrast: Union[List[float], NoneType], saturation: Union[List[float], NoneType], hue: Union[List[float], NoneType]) → Tuple[torch.Tensor, Union[float, NoneType], Union[float, NoneType], Union[float, NoneType], Union[float, NoneType]]

获取将应用于图像的随机变换的参数。

Parameters:

• 亮度 (python:float元组(最小值,最大值)，可选) – 从中均匀选择亮度因子的范围。传入None以关闭此变换。
• 对比度 (元组，包含两个python:float值(最小值,最大值)，可选) – 对比度因子的选择范围。通过传入None来关闭此变换。
• 饱和度 (元组，包含两个python:float值(最小值,最大值)，可选) – 饱和度因子的选择范围。以均匀方式选择。传入None以关闭此转换。
• 色调 (Python 浮点数元组(最小值,最大值),可选) – 从中均匀选择色调因子的范围。 传入 None 以关闭此变换。

Returns:

用于应用随机变换的参数 及其随机顺序。

返回类型：

元组

class torchvision.transforms.FiveCrop(size)

裁剪给定图像的四个角和中央部分。 如果图像为 torch 张量，则期望其形状为 […, 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)

将图像转换为灰度图。 如果图像为 torch 张量，则期望其形状为 […, 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')

在图像的四边用给定的“填充”值进行填充。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示对于模式 reflect 和 symmetric 最多有 2 个前置维度， 对于模式 edge 最多有 3 个前置维度， 对于模式 constant 可以有任意数量的前置维度。

Parameters:

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

  填充类型。应为：constant、edge、reflect 或 symmetric。 默认为 constant。

  • 用常量值进行填充，该值通过fillvalue指定。

  • edge: pads with the last value at the edge of the image,

    如果输入的是一个5D的Torch张量，则会填充最后3个维度而不是最后2个维度。

  • 用反射图像的方式填充，边缘不重复最后一个值

    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, interpolation=<InterpolationMode.NEAREST: 'nearest'>, fill=0, fillcolor=None, resample=None)

保持图像中心不变的随机仿射变换。 如果图像是 torch 张量，它应该具有[…, H, W] 的形状，其中…表示任意数量的前置维度。

Parameters:

• 角度范围 (序列或数字) – 选择的角度范围。 如果角度是一个数字而不是像 (最小值, 最大值) 的序列，角度范围将是 (-角度, +角度)。设置为 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 中随机采样。默认情况下将保持原始比例。
• 错切变换 (序列或数字，可选) – 从指定范围内选择错切角度。 如果错切是一个数字，则沿x轴应用范围为(-shear, +shear)的错切变换。 否则，如果错切是一个包含2个值的序列，则沿x轴应用范围为(shear[0], shear[1])的错切变换。 否则，如果错切是一个包含4个值的序列，则沿x轴应用范围为(shear[0], shear[1])的错切变换，并沿y轴应用范围为(shear[2], shear[3])的错切变换。 默认情况下不会应用错切变换。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。默认为 InterpolationMode.NEAREST。 如果输入是张量，仅支持 InterpolationMode.NEAREST 和 InterpolationMode.BILINEAR。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。
• 填充 (序列或数字) – 转换后图像外部区域的像素填充值。默认为0。如果给定一个数字，则该值将分别用于所有波段。 如果输入是PIL图像，则此选项仅适用于Pillow>=5.0.0。
• fillcolor (序列或数字，可选) – 已废弃的参数，并将在v0.10.0版本中移除。 请使用fill参数代替。
• resample (int, optional) – 已废弃的参数，自 v0.10.0 起将被移除。 请改用 interpolation 参数。

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:

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

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

在给定图像的随机位置裁剪图像。 如果图像为 torch 张量，则应具有[…, H, W] 形状，其中…表示任意数量的前置维度， 但如果使用非常数填充，则输入最多应有 2 个前置维度。

Parameters:

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

  填充类型。应为：constant、edge、reflect 或 symmetric。默认为 constant。

  • 用常量值进行填充，该值通过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]

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）随机将图像转换为灰度。 如果图像是 torch 张量，则期望其形状为 […, 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)

随机以给定的概率水平翻转给定图像。 如果图像为 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=<InterpolationMode.BILINEAR: 'bilinear'>, fill=0)

以给定的概率对给定图像执行随机透视变换。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• distortion_scale (float) – 参数用于控制扭曲程度，范围从 0 到 1。 默认值为 0.5。
• p (float) – 图像被转换的概率。默认值为 0.5。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。默认为 InterpolationMode.BILINEAR。 如果输入是张量，仅支持 InterpolationMode.NEAREST 和 InterpolationMode.BILINEAR。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。
• 填充 (序列或数字) – 转换后图像外部区域的像素填充值。默认为0。如果给定一个数字，则该值将分别用于所有波段。 如果输入是PIL图像，则此选项仅适用于Pillow>=5.0.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=<InterpolationMode.BILINEAR: 'bilinear'>)

随机裁剪给定图像的大小和宽高比。 如果图像为 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

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

Parameters:

• 大小 (int 或 序列) – 每条边的预期输出大小。如果大小是一个整数而不是像 (h, w) 这样的序列，则会生成一个正方形输出大小 (size, size)。如果提供了一个长度为 1 的序列，它将被解释为 (size[0], size[0])。在 torchscript 模式下，不支持单个整数作为大小，请使用长度为 1 的序列：[size, ]。
• 缩放比例 (python:float元组) – 裁剪前的图像缩放范围，相对于原始图像。
• 比例 (python:float元组) – 裁剪前的图像宽高比范围。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。 默认值为 InterpolationMode.BILINEAR。 如果输入是张量，只支持 InterpolationMode.NEAREST、InterpolationMode.BILINEAR 和 InterpolationMode.BICUBIC。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。

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, interpolation=<InterpolationMode.NEAREST: 'nearest'>, expand=False, center=None, fill=0, resample=None)

以角度旋转图像。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 角度范围 (序列或数字) – 选择的角度范围。 如果角度是一个数字而不是像 (最小值, 最大值) 这样的序列，角度范围将是 (-degrees, +degrees)。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。默认为 InterpolationMode.NEAREST。 如果输入是张量，仅支持 InterpolationMode.NEAREST 和 InterpolationMode.BILINEAR。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。
• 展开 (bool, 可选) – 可选的扩展标志。 如果为真，将输出扩展到足以容纳整个旋转图像的大小。 如果为假或省略，则输出图像与输入图像大小相同。 请注意，扩展标志假设围绕中心旋转且没有平移。
• 中心 (序列, 可选) – 可选的旋转中心，(x, y)。原点是图像的左上角。 默认为图像的中心。
• 填充 (序列或数字) – 旋转图像外部区域的像素填充值。默认值为0。如果给定一个数字，则该值将分别用于所有频带。如果输入是PIL图像，则此选项仅适用于Pillow>=5.2.0。
• resample (int, optional) – 已废弃的参数，自 v0.10.0 起将被移除。 请改用 interpolation 参数。

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)

随机以给定的概率垂直翻转给定图像。 如果图像为 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

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

forward(img)

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

class torchvision.transforms.Resize(size, interpolation=<InterpolationMode.BILINEAR: 'bilinear'>)

将输入图像调整为给定大小。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 大小 (序列 或 整数) – 期望的输出大小。如果大小是一个序列如 (h, w)，输出大小将与这个匹配。如果大小是一个整数， 图像的较小边将与这个数字匹配。 即，如果高度 > 宽度，则图像将被重新缩放为 (size * 高度 / 宽度, size). 在torchscript模式下不支持单个整数作为大小，请使用长度为1的序列: [size, ]。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。 默认值为 InterpolationMode.BILINEAR。 如果输入是张量，只支持 InterpolationMode.NEAREST、InterpolationMode.BILINEAR 和 InterpolationMode.BICUBIC。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。

forward(img)

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

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

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

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

裁剪给定图像的四个角和中央区域，并生成这些裁剪图的水平翻转版本。 如果图像为 torch 张量，则其形状应为 […, 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))

对图像进行随机选择的高斯模糊处理。 如果图像是 torch 张量，则期望其具有[…, 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)

将张量图像与一个正方形变换矩阵和一个离线计算的均值向量进行转换。 此变换不支持PIL图像。 给定变换矩阵和均值向量，将展平的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)

用均值和标准差对张量图像进行归一化。 此变换不支持PIL图像。 给定均值：(mean[1],...,mean[n]) 和标准差：(std[1],..,std[n]) 对于 n 通道， 此变换将对输入的每个通道进行归一化，即， 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)

随机选择一个矩形区域，并在该区域内擦除像素。 此变换不支持PIL图像。 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:

• 图像 (张量) – 需要擦除的张量图像。
• 比例缩放 (序列) – 被擦除区域相对于输入图像的比例范围。
• 比例 (序列) – 裁剪区域的纵横比范围。
• 值 (列表, 可选) – 擦除的值。如果为 None，则解释为“随机”（每个像素用随机值擦除）。如果 len(value) 是 1，则解释为一个数字，即 value[0]。

Returns:

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

返回类型：

元组

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

将张量图像转换为指定的dtype并相应地调整值 此函数不支持PIL图像。

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

class torchvision.transforms.functional.InterpolationMode

插值模式

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

调整图像的亮度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• img 是 torch 张量，它应该采用 [..., 1 或 3, H, W] 格式， (如果) –
• ... 表示它可以有任意数量的前置维度。 (其中) –
• brightness_factor (float) – 如何调整亮度。可以是任何非负数。0 给出一个黑色图像，1 给出原始图像，而 2 将亮度增加一倍。

Returns:

调整亮度后的图像。

返回类型：

PIL 图像或张量

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

调整图像的对比度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• img 是 torch 张量，它应该采用 [..., 3, H, W] 格式， (如果) –
• ... 表示它可以有任意数量的前置维度。 (其中) –
• 对比度因子 (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图像。
• img 是 torch 张量，它应该采用 [..., 1 或 3, H, W] 格式， (如果) –
• ... 表示它可以有任意数量的前置维度。 (其中) –
• img 是 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 图像或张量) – 需要调整的图像。
• img 是 torch 张量，它应该采用 [..., 3, H, W] 格式， (如果) –
• ... 表示它可以有任意数量的前置维度。 (其中) –
• 图片为PIL图像模式"1"、"L"、"I"、"F"和具有透明度的模式 (如果) –
• 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 图像或张量) – 需要调整的图像。
• img 是 torch 张量，它应该采用 [..., 3, H, W] 格式， (如果) –
• ... 表示它可以有任意数量的前置维度。 (其中) –
• 饱和度因子 (float) – 调整饱和度的程度。0 将给出黑白图像，1 将给出原始图像，而 2 将将饱和度增强 2 倍。

Returns:

饱和度调整后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.adjust_sharpness(img: torch.Tensor, sharpness_factor: float) → torch.Tensor

调整图像的锐度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整的图像。
• img 是 torch 张量，它应该采用 [..., 1 或 3, H, W] 格式， (如果) –
• ... 表示它可以有任意数量的前置维度。 (其中) –
• sharpness_factor (float) – 调整清晰度的程度。可以是任何非负数。0给出模糊的图像，1给出原始图像，而2将清晰度增加一倍。

Returns:

锐度调整后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.affine(img: torch.Tensor, angle: float, translate: List[int], scale: float, shear: List[float], interpolation: torchvision.transforms.functional.InterpolationMode = <InterpolationMode.NEAREST: 'nearest'>, fill: Union[List[float], NoneType] = None, resample: Union[int, NoneType] = None, fillcolor: Union[List[float], NoneType] = None) → torch.Tensor

对图像进行仿射变换，保持图像中心不变。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要转换的图像。
• 角度 (数字) – 旋转角度以度为单位，在-180到180之间，顺时针方向。
• 翻译 (整数序列) – 水平和垂直平移（旋转后的平移）
• 缩放 (float) – 总体缩放
• shear (float 或 序列) – 剪切角度值以度为单位，范围在 -180 到 180 之间，顺时针方向。 如果指定了一个序列，第一个值对应于平行于 x 轴的剪切，而 第二个值对应于平行于 y 轴的剪切。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。默认为 InterpolationMode.NEAREST。 如果输入是张量，仅支持 InterpolationMode.NEAREST 和 InterpolationMode.BILINEAR。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。
• 填充 (序列或数字，可选) – 转换后图像外部区域的像素填充值。如果给定一个数字，则该值将分别用于所有通道。 在torchscript模式下不支持单个整数/浮点数值，请使用长度为1的序列：[value, ]。 如果输入是PIL图像，则此选项仅适用于Pillow>=5.0.0。
• 填充颜色 (序列, 整数, 浮点数) – 已废弃的参数，自 v0.10.0 起将被移除。 请改用 fill 参数。
• resample (int, optional) – 已废弃的参数，自 v0.10.0 起将被移除。 请改用 interpolation 参数。

Returns:

变换后的图像。

返回类型：

PIL 图像或张量

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

通过重新映射图像每个通道的像素来最大化图像对比度，使最低亮度变为黑色，最高亮度变为白色。

Parameters:图像 (PIL 图像或张量) – 应用自动对比度的图像。 如果图像为 torch 张量，它应采用[…, 1 或 3, H, W] 格式， 其中…表示它可以有任意数量的前置维度。 如果图像为 PIL 图像，它应采用“L”或“RGB”模式。 Returns:一张经过自动对比度调整的图像。 返回类型：PIL 图像或张量

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

裁剪给定图像的中心。 如果图像为 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。 如果图像在任一边的大小小于输出大小，则会在图像周围填充 0 然后进行中心裁剪。

Parameters:

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

Returns:

裁剪后的图像。

返回类型：

PIL 图像或张量

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

将张量图像转换为指定的dtype并相应地调整值 此函数不支持PIL图像。

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

在指定位置裁剪给定图像，并输出所需大小。 如果图像为 torch 张量，则期望其形状为 […, H, W]，其中 … 表示任意数量的前置维度。

Parameters:

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

Returns:

裁剪后的图像。

返回类型：

PIL 图像或张量

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

通过对输入应用非线性映射来均衡图像的直方图，从而在输出中创建灰度值的均匀分布。

Parameters:图像 (PIL 图像或张量) – 应用均衡化的图像。 如果图像为 torch 张量，它应采用[…, 1 或 3, H, W] 格式， 其中…表示它可以有任意数量的前置维度。 如果图像为 PIL 图像，它应采用模式“P”、“L”或“RGB”。 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

用给定的值擦除输入张量图像。 此变换不支持PIL图像。

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]

裁剪给定图像的四个角和中央部分。 如果图像为 torch 张量，则期望其具有[…, 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

对图像执行高斯模糊，给定内核。 如果图像是 torch 张量，则期望其具有[…, 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

水平翻转给定的图像。

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

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

反转 RGB/灰度图像的颜色。

Parameters:图像 (PIL 图像或张量) – 需要反转颜色的图像。 如果 img 是 torch 张量，它应采用[…, 1 或 3, H, W] 格式， 其中…表示它可以有任意数量的前置维度。 如果 img 是 PIL 图像，它应采用模式“L”或“RGB”。 Returns:颜色反转图像。 返回类型：PIL 图像或张量

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

用均值和标准差对张量图像进行标准化。 此变换不支持PIL图像。

注意

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

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

在图像的四边用给定的“填充”值进行填充。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示对于模式 reflect 和 symmetric 最多有 2 个前置维度， 对于模式 edge 最多有 3 个前置维度， 对于模式 constant 可以有任意数量的前置维度。

Parameters:

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

  填充类型。应为：constant、edge、reflect 或 symmetric。默认为 constant。

  • 用常量值进行填充，该值通过fillvalue指定。

  • edge: pads with the last value on the edge of the image,

    如果输入的是一个5D的Torch张量，则会填充最后3个维度而不是最后2个维度。

  • 以反射图像的方式填充（不在边缘重复最后一个值）

    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: torchvision.transforms.functional.InterpolationMode = <InterpolationMode.BILINEAR: 'bilinear'>, fill: Union[List[float], NoneType] = None) → torch.Tensor

对给定图像执行透视变换。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要转换的图像。
• 起始点 (整数列表的列表) – 包含四个整数列表，每个列表包含两个整数，对应原始图像的四个角。 [top-left, top-right, bottom-right, bottom-left]
• 端点 (整数列表的列表) – 包含四个整数列表，每个列表包含两个整数，对应于转换后图像的四个角。 [top-left, top-right, bottom-right, bottom-left] 的转换后图像。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。默认为 InterpolationMode.BILINEAR。 如果输入是张量，仅支持 InterpolationMode.NEAREST 和 InterpolationMode.BILINEAR。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。
• 填充 (序列或数字，可选) – 转换后图像外部区域的像素填充值。如果给定一个数字，则该值将分别用于所有通道。 在torchscript模式下不支持单个整数/浮点数值，请使用长度为1的序列：[value, ]。 如果输入是PIL图像，则此选项仅适用于Pillow>=5.0.0。

Returns:

变换后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.pil_to_tensor(pic)

将一个 PIL Image 转换为相同类型的张量。 此函数不支持torchscript。

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

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

torchvision.transforms.functional.posterize(img: torch.Tensor, bits: int) → torch.Tensor

通过减少每个颜色通道的位数来对图像进行色调化处理。

Parameters:

• 图像 (PIL 图像或张量) – 需要进行色调化的图像。 如果图像为 torch 张量，它应该是 torch.uint8 类型， 并且期望其格式为[…, 1 或 3, H, W]，其中…表示它可以有任意数量的前置维度。 如果图像为 PIL 图像，它应该处于“L”或“RGB”模式。
• 位数 (int) – 每个通道保留的位数（0-8）。

Returns:

poster 化图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.resize(img: torch.Tensor, size: List[int], interpolation: torchvision.transforms.functional.InterpolationMode = <InterpolationMode.BILINEAR: 'bilinear'>) → torch.Tensor

将输入图像调整为给定大小。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要调整大小的图像。
• 大小 (序列 或 整数) – 期望的输出大小。如果大小是一个序列如 (h, w)，则输出大小将与此匹配。如果大小是一个整数， 则图像的较小边将与此数字匹配，同时保持宽高比。即，如果高度 > 宽度，则图像将被重新缩放至 \(\left(\text{size} \times \frac{\text{height}}{\text{width}}, \text{size}\right)\). 在torchscript模式下不支持单个整数作为大小，请使用长度为1的序列：[size, ]。
• 插值法 (InterpolationMode) – 需要的由 torchvision.transforms.InterpolationMode 定义的插值枚举。 默认为 InterpolationMode.BILINEAR。如果输入是张量，仅支持 InterpolationMode.NEAREST， InterpolationMode.BILINEAR 和 InterpolationMode.BICUBIC。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。

Returns:

缩放后的图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.resized_crop(img: torch.Tensor, top: int, left: int, height: int, width: int, size: List[int], interpolation: torchvision.transforms.functional.InterpolationMode = <InterpolationMode.BILINEAR: 'bilinear'>) → torch.Tensor

裁剪给定的图像并将其调整为所需的大小。 如果图像为 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

显著用于RandomResizedCrop。

Parameters:

• 图像 (PIL 图像或张量) – 需要裁剪的图像。 (0,0) 表示图像的左上角。
• 顶部 (整数) – 裁剪框左上角的垂直组件。
• 左 (整数) – 作物框左上角的水平分量。
• 高度 (int) – 裁剪框的高度。
• 宽度 (int) – 裁剪框的宽度。
• 大小 (序列 或 整数) – 期望的输出大小。与 resize 具有相同的语义。
• 插值法 (InterpolationMode) – 需要的由 torchvision.transforms.InterpolationMode 定义的插值枚举。 默认为 InterpolationMode.BILINEAR。如果输入是张量，仅支持 InterpolationMode.NEAREST， InterpolationMode.BILINEAR 和 InterpolationMode.BICUBIC。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。

Returns:

裁剪后的图像。

返回类型：

PIL 图像或张量

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

将 RGB 图像转换为灰度图像版本。 如果图像是 torch 张量，则期望其具有 […, 3, 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, interpolation: torchvision.transforms.functional.InterpolationMode = <InterpolationMode.NEAREST: 'nearest'>, expand: bool = False, center: Union[List[int], NoneType] = None, fill: Union[List[float], NoneType] = None, resample: Union[int, NoneType] = None) → torch.Tensor

以角度旋转图像。 如果图像是 torch 张量，则期望其具有[…, H, W] 形状，其中…表示任意数量的前置维度。

Parameters:

• 图像 (PIL 图像或张量) – 需要旋转的图像。
• 角度 (数字) – 逆时针方向的旋转角度值，单位为度。
• 插值法 (InterpolationMode) – 需要的插值枚举，由 torchvision.transforms.InterpolationMode 定义。默认为 InterpolationMode.NEAREST。 如果输入是张量，仅支持 InterpolationMode.NEAREST 和 InterpolationMode.BILINEAR。 为了向后兼容，整数值（例如 PIL.Image.NEAREST）仍然可以接受。
• 展开 (bool, 可选) – 可选的扩展标志。 如果为真，将输出图像扩展到足以容纳整个旋转图像的大小。 如果为假或省略，则输出图像与输入图像大小相同。 请注意，扩展标志假设围绕中心旋转且没有平移。
• 中心 (序列, 可选) – 可选的旋转中心。原点是图像的左上角。 默认情况下是图像的中心。
• 填充 (序列或数字，可选) – 转换后图像外部区域的像素填充值。如果给定一个数字，则该值将分别用于所有通道。 在torchscript模式下不支持单个整数/浮点数值，请使用长度为1的序列：[value, ]。 如果输入是PIL图像，则此选项仅适用于Pillow>=5.2.0。

Returns:

旋转图像。

返回类型：

PIL 图像或张量

torchvision.transforms.functional.solarize(img: torch.Tensor, threshold: float) → torch.Tensor

通过反转所有高于阈值的像素值来对 RGB/灰度图像进行 Solarize 处理。

Parameters:

• 图像 (PIL 图像或张量) – 需要反转颜色的图像。 如果 img 是 torch 张量，它应采用[…, 1 或 3, H, W] 格式， 其中…表示它可以有任意数量的前置维度。 如果 img 是 PIL 图像，它应采用模式“L”或“RGB”。
• 阈值 (float) – 所有等于或高于此值的像素都将被反转。

Returns:

太阳化图像。

返回类型：

PIL 图像或张量

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

生成给定图像的十张裁剪图。 将给定图像裁剪为四个角和中央区域，并加上这些裁剪图的水平翻转版本。 如果图像为 torch 张量，则期望其形状为 […, 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)

将任何模式的PIL图像（如RGB、HSV、LAB等）转换为灰度图像。 此变换不支持torch张量。

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 图像。此函数不支持 TorchScript。

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

Parameters:

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

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

torchvision.transforms.functional.to_tensor(pic)

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

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

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

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

垂直翻转给定的图像。

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