torchvision.transforms¶
转换是常见的图像转换。可以使用 .
大多数转换类都有一个等效的函数：functional
转换可以对
转换。
如果您必须构建更复杂的转换管道，这将非常有用
（例如，在分段任务的情况下）。
大多数转换同时接受 PIL 图像和张量图像，尽管有些转换仅 PIL 和一些转换仅张量。Conversion Transforms 可用于 与 PIL 图像相互转换。
接受张量图像的转换也接受批量张量
图像。张量图像是具有形状的张量，其中 是
通道数，分别是图像高度和宽度。一批
Tensor Images 是形状的张量，其中 是一个数字
批次中的图像。(C, H, W)CHW(B, C, H, W)B
张量图像值的预期范围由
张量 dtype 。具有 float dtype 的 Tensor 图像应具有
中的 值。具有整数 dtype 的张量图像应为
在其中 是最大值
可以用该 DTYPE 表示。[0, 1)[0, MAX_DTYPE]MAX_DTYPE
随机转换会将相同的转换应用于所有 图像，但它们将产生不同的转换 跨呼叫。对于跨调用的可重现转换，您可以使用函数转换。
以下示例说明了可用转换的用法：
警告
从 v0.8.0 开始，所有的随机变换都使用 torch 默认的随机生成器来采样随机参数。 这是一个向后兼容性的破坏性变化，用户应该按如下方式设置 random 状态：
# Previous versions
# import random
# random.seed(12)
# Now
import torch
torch.manual_seed(17)
请记住，torch 随机生成器和 Python 随机生成器的相同种子不会 产生相同的结果。
可编写脚本的转换¶
为了编写转换脚本，请使用 而不是 .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)
确保仅使用可编写脚本的转换，即使用 lambda 函数且不需要 lambda 函数或 .torch.TensorPIL.Image
对于要与 一起使用的任何自定义转换，它们应派生自 。torch.jit.scripttorch.nn.Module
转换的组合¶
-
类（转换）[来源]
torchvision.transforms.Compose¶ 将多个转换组合在一起。此转换不支持 torchscript。 请参阅下面的注释。
- 参数
transforms （list of objects） - 要组合的转换列表。
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)
确保仅使用可编写脚本的转换，即使用 不需要 lambda 函数或 .
torch.TensorPIL.Image
在 PIL Image 和 torch.*Tensor 上进行转换¶
-
class （size）[来源]
torchvision.transforms.CenterCrop¶ 在中心裁剪给定的图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。 如果图像大小小于沿任何边缘的输出大小，则图像将填充 0，然后居中裁剪。
- 参数
size （sequence or int） – 作物的所需输出大小。如果 size 是 int 而不是像 （h， w） 这样的序列，方形裁剪 （size， size） 是 䍬。如果提供长度为 1 的序列，则它将被解释为 （size[0]， size[0]）。
使用 的示例 ：
CenterCrop
-
类别（亮度=0，对比度=0，饱和度=0，色调=0）[来源]
torchvision.transforms.ColorJitter¶ 随机更改图像的亮度、对比度、饱和度和色相。 如果图像是 torch Tensor，则预期为 具有 [...， 3， H， W] 形状，其中 ...表示任意数量的前导维度。 如果 img 是 PIL 图像，则不支持模式 “1”、“L”、“I”、“F” 和透明模式（Alpha 通道）。
- 参数
brightness （float or tuple of python：float （min， max）） - 亮度抖动的程度。 brightness_factor 从 [max（0， 1 - brightness）， 1 + brightness] 中统一选择 或给定的 [min， max]。应为非负数。
contrast （float or tuple of python：float （min， max）） – 抖动对比度的程度。 contrast_factor 从 [max（0， 1 - contrast）， 1 + contrast] 中统一选择 或给定的 [min， max]。应为非负数。
saturation （float or tuple of python：float （min， max）） – 抖动饱和度的程度。 saturation_factor 从 [max（0， 1 - saturation）， 1 + saturation] 中统一选择 或给定的 [min， max]。应为非负数。
hue （float or tuple of python：float （min， max）） – 色调抖动的程度。 hue_factor 是从 [-hue， hue] 或给定的 [min， max] 中统一选择的。 应具有 0<= 色相 <= 0.5 或 -0.5 <= 最小值 <= 最大值 <= 0.5。
使用 的示例 ：
ColorJitter-
静态 （brightness： 可选[List[float]]， contrast： 可选[List[float]]， 饱和度： 可选[List[float]]， hue： 可选[List[float]]） → Tuple[torch.张量， 可选 [float]， 可选 [float]， 可选 [float]][源]
get_params¶ 获取要应用于图像的随机转换的参数。
- 参数
brightness （python：float 的元组 （min， max），可选） – 从中选择brightness_factor的范围 均匀。Pass None 以关闭转换。
contrast （tuple of python：float （min， max）， optional） - 选择contrast_factor的范围 均匀。Pass None 以关闭转换。
saturation （python：float 的元组 （min， max），可选） – 从中选择saturation_factor的范围 均匀。Pass None 以关闭转换。
hue （tuple of python：float （min， max），可选） – 从中统一选择hue_factor的范围。 Pass None 以关闭转换。
- 返回
用于应用随机化变换的参数 以及它们的随机顺序。
- 返回类型
-
class （size）[来源]
torchvision.transforms.FiveCrop¶ 将给定的图像裁剪为四个角，并进行中央裁剪。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导 尺寸
注意
此转换返回一个图像元组，并且 inputs 并定位您的 Dataset 返回。有关如何处理的示例，请参见下文 这。
- 参数
size （sequence or int） – 作物的所需输出大小。如果 size 是 （h， w） 等序列，则进行 size （size， size） 的方形裁剪。 如果提供长度为 1 的序列，则它将被解释为 （size[0]， size[0]）。
int
例
>>> 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
使用 的示例 ：
FiveCrop
-
类 （num_output_channels=1）[来源]
torchvision.transforms.Grayscale¶ 将图像转换为灰度。 如果图像是 torch Tensor，则预期为 具有 [...， 3， H， W] 形状，其中 ...表示任意数量的前导尺寸
- 参数
num_output_channels （int） – 输出图像所需的（1 或 3）个通道数
- 返回
输入的灰度版本。
如果 ：返回的图像是单通道
num_output_channels == 1如果 ： 返回的图像是 3 通道，其中 r == g == b
num_output_channels == 3
- 返回类型
太平船务图片
使用 的示例 ：
Grayscale
-
类 （padding， fill=0， padding_mode='constant'）[来源]
torchvision.transforms.Pad¶ 用给定的 “pad” 值在给定的图像的所有侧面填充。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示最多 2 个前导维度用于 Mode Reflect 和 Symmetric， 模态边最多 3 个前导尺寸， 以及 mode constant 的任意数量的前导维度
- 参数
填充（int 或 sequence）–
每个边框上的填充。如果提供了单个 int 用于填充所有边框。如果提供了长度为 2 的序列，则为填充 分别在 left/right 和 top/bottom 上。如果提供长度为 4 的序列 这分别是 left、top、right 和 bottom 边框的填充。
注意
在 torchscript 模式下，由于不支持单个 int 填充，请使用 长度 1： 。
[padding, ]fill （number or str or tuple） – 常量填充的像素填充值。默认值为 0。如果 length 3，分别用于填充 R、G、B 通道。 仅当 padding_mode 为 constant 时，才使用此值。 torch Tensor 仅支持 number。 PIL Image 仅支持 int 或 str 或 tuple value。
padding_mode （str） –
填充类型。应为：constant、edge、reflect 或 symmetric。 默认值为 constant。
常数：具有常数值的焊盘，该值由 fill 指定
edge：在图像边缘使用最后一个值进行填充。 如果输入 5D torch Tensor，则填充最后 3 个维度而不是最后 2 个
Reflect（反射）：使用图像反射填充，而不重复边缘上的最后一个值。 例如，在反射模式下，填充 [1， 2， 3， 4] 两侧有 2 个元素 将导致 [3， 2， 1， 2， 3， 4， 3， 2]
symmetric：带有图像反射的焊盘重复边缘上的最后一个值。 例如，在对称模式下，两侧有 2 个元素填充 [1， 2， 3， 4] 将产生 [2， 1， 1， 2， 3， 4， 4， 3]
使用 的示例 ：
Pad
-
class （degrees， translate=None， scale=None， shear=None， interpolation=<InterpolationMode.NEAREST： 'nearest'>， fill=0， fillcolor=None， resample=None）[来源]
torchvision.transforms.RandomAffine¶ 图像的随机仿射变换保持中心不变。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
degrees （sequence or number） （degrees （sequence or number） （度数或数字） – 可供选择的度数范围。 如果 degrees 是一个数字而不是序列，如 （min， max），则度的范围 将为 （-degrees， +degrees）。设置为 0 可停用旋转。
translate （tuple， optional） - 水平最大绝对分数的元组 和垂直翻译。例如 translate=（a， b），然后水平偏移 在 -img_width * a < dx < img_width * a 范围内随机采样，垂直偏移为 在 -img_height * b < dy < img_height * b 范围内随机采样。默认情况下不会翻译。
scale （tuple， optional） - 缩放因子间隔，例如 （a， b），则 scale 为 从范围 A <= scale <= b 中随机采样。默认情况下将保持原始比例。
shear （sequence or number， optional） – 可供选择的度数范围。 如果 shear 是一个数字，则为平行于范围内 x 轴的剪切 （-shear， +shear） 将应用。否则，如果 shear 是 2 个值的序列，则剪切平行于 x 轴的 范围 （shear[0]， shear[1]）。否则，如果 shear 是 4 个值的序列，则 将应用 x 轴剪切输入 （shear[0]， shear[1]） 和 y 轴剪切输入 （shear[2]， shear[3]）。 默认情况下不会应用剪切。
interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.NEARESTInterpolationMode.NEARESTInterpolationMode.BILINEARPIL.Image.NEARESTfill （sequence or number） （填充 （序列或数字） ） – 转换后的 Area 之外的像素填充值 图像。默认值为 。如果给定一个数字，则该值分别用于所有波段。
0fillColor （sequence or number， optional） – 已弃用的参数，将从 v0.10.0 开始删除。 请改用 parameter 。
fillresample （int， optional） – 已弃用的参数，将从 v0.10.0 开始删除。 请改用 parameter 。
interpolation
使用 的示例 ：
RandomAffine
-
类（转换，p=0.5）[来源]
torchvision.transforms.RandomApply¶ 随机应用具有给定概率的转换列表。
注意
为了编写转换脚本，请使用 list / tuple 作为输入，而不是 transforms，如下所示：
torch.nn.ModuleList>>> transforms = transforms.RandomApply(torch.nn.ModuleList([ >>> transforms.ColorJitter(), >>> ]), p=0.3) >>> scripted_transforms = torch.jit.script(transforms)
确保仅使用可编写脚本的转换，即使用 不需要 lambda 函数或 .
torch.TensorPIL.Image- 参数
transforms （sequence 或 torch.nn.Module） – 转换列表
p （float） – 概率
使用 的示例 ：
RandomApply
-
class （size， padding=None， pad_if_needed=False， fill=0， padding_mode='constant'）[来源]
torchvision.transforms.RandomCrop¶ 在随机位置裁剪给定的图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度， 但是，如果使用非常量填充，则输入最多应具有 2 个前导维度
- 参数
size （sequence or int） – 作物的所需输出大小。如果 size 是 int 而不是像 （h， w） 这样的序列，方形裁剪 （size， size） 是 䍬。如果提供长度为 1 的序列，则它将被解释为 （size[0]， size[0]）。
padding （int 或 sequence，可选） –
每个边框上的可选填充 的图像。默认值为 None。如果提供了单个 int 用于填充所有边框。如果提供了长度为 2 的序列，则为填充 分别在 left/right 和 top/bottom 上。如果提供长度为 4 的序列 这分别是 left、top、right 和 bottom 边框的填充。
注意
在 torchscript 模式下，由于不支持单个 int 填充，请使用 长度 1： 。
[padding, ]pad_if_needed （boolean） – 如果小于 所需的大小来避免引发异常。由于裁剪已完成 填充后，填充似乎以随机偏移量完成。
fill （number or str or tuple） – 常量填充的像素填充值。默认值为 0。如果 length 3，分别用于填充 R、G、B 通道。 仅当 padding_mode 为 constant 时，才使用此值。 torch Tensor 仅支持 number。 PIL Image 仅支持 int 或 str 或 tuple value。
padding_mode （str） –
填充类型。应为：constant、edge、reflect 或 symmetric。 默认值为 constant。
常数：具有常数值的焊盘，该值由 fill 指定
edge：在图像边缘使用最后一个值进行填充。 如果输入 5D torch Tensor，则填充最后 3 个维度而不是最后 2 个
Reflect（反射）：使用图像反射填充，而不重复边缘上的最后一个值。 例如，在反射模式下，填充 [1， 2， 3， 4] 两侧有 2 个元素 将导致 [3， 2， 1， 2， 3， 4， 3， 2]
symmetric：带有图像反射的焊盘重复边缘上的最后一个值。 例如，在对称模式下，两侧有 2 个元素填充 [1， 2， 3， 4] 将产生 [2， 1， 1， 2， 3， 4， 4， 3]
使用 的示例 ：
RandomCrop
-
等级 （P=0.1）[来源]
torchvision.transforms.RandomGrayscale¶ 将图像随机转换为灰度，概率为 p（默认为 0.1）。 如果图像是 torch Tensor，则预期为 具有 [...， 3， H， W] 形状，其中 ...表示任意数量的前导尺寸
- 参数
p （float） - 图像应转换为灰度的概率。
- 返回
输入图像的灰度版本，概率为 p 且未更改 与概率 （1-p）。 - 如果输入图像为 1 通道：灰度版本为 1 通道 - 如果输入图像为 3 通道：灰度版本为 3 通道，其中 r == g == b
- 返回类型
PIL 图像或张量
-
等级 （P=0.5）[来源]
torchvision.transforms.RandomHorizontalFlip¶ 以给定的概率随机水平翻转给定的图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导 尺寸
- 参数
p （float） - 图像被翻转的概率。默认值为 0.5
使用 的示例 ：
RandomHorizontalFlip
-
类 （distortion_scale=0.5， p=0.5， interpolation=<InterpolationMode.BILINEAR： 'bilinear'>， fill=0）[来源]
torchvision.transforms.RandomPerspective¶ 以给定的概率对给定图像执行随机透视变换。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
distortion_scale （float） – 控制失真程度的参数，范围从 0 到 1。 默认值为 0.5。
p （float） - 图像被转换的概率。默认值为 0.5。
interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.BILINEARInterpolationMode.NEARESTInterpolationMode.BILINEARPIL.Image.NEARESTfill （sequence or number） （填充 （序列或数字） ） – 转换后的 Area 之外的像素填充值 图像。默认值为 。如果给定一个数字，则该值分别用于所有波段。
0
使用 的示例 ：
RandomPerspective
-
类（大小，比例=（0.08,1.0），比率=（0.75,1.333333333333333），插值=<InterpolationMode.BILINEAR： 'bilinear'>）[来源]
torchvision.transforms.RandomResizedCrop¶ 裁剪图像的随机部分并将其调整为给定大小。
如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导尺寸
对原始图像进行裁剪：裁剪具有随机区域 （H * W） 和随机纵横比。此裁剪最终调整为给定的 大小。这通常用于训练 Inception 网络。
- 参数
size （int 或 sequence） –
每个边缘的 Crop 的预期输出大小。如果 size 是 int 而不是像 （h， w） 这样的序列，则方形输出大小为 䍬。如果提供长度为 1 的序列，则它将被解释为 （size[0]， size[0]）。
(size, size)注意
在 torchscript 模式下，由于不支持单个 int，因此请使用长度为 1 的序列：。
[size, ]scale （ python：float 的元组） – 指定裁剪随机区域的下限和上限， 在调整大小之前。比例是相对于原始图像的面积定义的。
ratio （tuple of python：float） – 裁剪的随机纵横比的下限和上限，之前 调整。
interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 和 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.BILINEARInterpolationMode.NEARESTInterpolationMode.BILINEARInterpolationMode.BICUBICPIL.Image.NEAREST
使用 的示例 ：
RandomResizedCrop
-
class （degrees， interpolation=<InterpolationMode.NEAREST： 'nearest'>， expand=False， center=None， fill=0， resample=None）[来源]
torchvision.transforms.RandomRotation¶ 按角度旋转图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
degrees （sequence or number） （degrees （sequence or number） （度数或数字） – 可供选择的度数范围。 如果 degrees 是一个数字而不是序列，如 （min， max），则度的范围 将为 （-degrees， +degrees）。
interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.NEARESTInterpolationMode.NEARESTInterpolationMode.BILINEARPIL.Image.NEARESTexpand （bool， optional） – 可选的扩展标志。 如果为 true，则扩展输出，使其足够大以容纳整个旋转的图像。 如果为 false 或省略，则使输出图像与输入图像的大小相同。 请注意，expand 标志假定绕中心旋转且无平移。
center （sequence， optional） – 可选的旋转中心 （x， y）。原点 是左上角。 默认值是图像的中心。
fill （sequence or number） （填充 （序列或数字） ） – 旋转区域之外区域的像素填充值 图像。默认值为 。如果给定一个数字，则该值分别用于所有波段。
0resample （int， optional） – 已弃用的参数，将从 v0.10.0 开始删除。 请改用 parameter 。
interpolation
使用 的示例 ：
RandomRotation
-
class （*args， **kwargs）[来源]
torchvision.transforms.RandomSizedCrop¶ 注意：此转换已弃用，取而代之的是 RandomResizedCrop。
-
等级 （P=0.5）[来源]
torchvision.transforms.RandomVerticalFlip¶ 以给定的概率随机垂直翻转给定的图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导 尺寸
- 参数
p （float） - 图像被翻转的概率。默认值为 0.5
使用 的示例 ：
RandomVerticalFlip
-
class （size， interpolation=<InterpolationMode.BILINEAR： 'bilinear'>， max_size=无， antialias=无）[来源]
torchvision.transforms.Resize¶ 将输入图像的大小调整为给定的大小。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导尺寸
警告
输出图像可能因其类型而异：缩减像素采样时，PIL 图像的插值 和 Tensors 略有不同，因为 PIL 应用了抗锯齿。这可能会导致显著差异 在网络性能中。因此，最好训练和提供具有相同输入的模型 类型。
- 参数
size （sequence 或 int） –
所需的输出大小。如果 size 是类似于 （h， w） 时，output size 将与此匹配。如果 size 是 int，则 图像的较小边缘将与此数字匹配。 即，如果 height > width，则 image 将被重新缩放为 （尺寸 * 高度 / 宽度、大小）。
注意
在 torchscript 模式下，由于不支持单个 int，因此请使用长度为 1 的序列：。
[size, ]interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 和 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.BILINEARInterpolationMode.NEARESTInterpolationMode.BILINEARInterpolationMode.BICUBICPIL.Image.NEARESTmax_size （int， optional） – 较长边允许的最大值 调整大小后的图像：如果图像的较长边缘较大 比按照 调整大小后 ，则 再次调整图像大小，使较长的边缘等于 。因此，可能会被否决，即 较小的边缘可能短于 。这仅支持 if 是 int （或 TorchScript 中长度为 1 的序列 模式）。
max_sizesizemax_sizesizesizesizeantialias （布尔值，可选） –
antialias 标志。如果是 PIL Image，则忽略该标志并消除锯齿 始终使用。如果为 Tensor，则标志默认为 False，并且只能为模式设置为 True。
imgimgInterpolationMode.BILINEAR警告
input 为 Tensor 的 option 不支持 autodiff 。
antialias=Trueimg
使用 的示例 ：
Resize
-
class （size， vertical_flip=False）[来源]
torchvision.transforms.TenCrop¶ 将给定的图像裁剪为四个角，并进行中央裁剪加上翻转的 这些（默认使用水平翻转）。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导 尺寸
注意
此转换返回一个图像元组，并且 inputs 并定位您的 Dataset 返回。有关如何处理的示例，请参见下文 这。
- 参数
例
>>> 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
-
类 （kernel_size， sigma=（0.1， 2.0））[来源]
torchvision.transforms.GaussianBlur¶ 使用随机选择的高斯模糊来模糊图像。 如果图像是 torch Tensor，则预期为 具有 [...， C， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
- 返回
输入图像的高斯模糊版本。
- 返回类型
PIL 图像或张量
使用 的示例 ：
GaussianBlur
-
等级 （P=0.5）[来源]
torchvision.transforms.RandomInvert¶ 以给定的概率随机反转给定图像的颜色。 如果 img 是 Tensor，则它应为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
- 参数
p （float） - 图像颜色反转的概率。默认值为 0.5
使用 的示例 ：
RandomInvert
-
类（比特，p=0.5）[来源]
torchvision.transforms.RandomPosterize¶ 通过减少 每个颜色通道的位数。如果图像是 torch Tensor，则应为 torch.uint8 类型， 并且它应具有 [...， 1 或 3， H， W] 形状，其中 ...表示任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
使用 的示例 ：
RandomPosterize
-
等级（阈值，p=0.5）[来源]
torchvision.transforms.RandomSolarize¶ 通过反转所有像素，以给定的概率随机曝光图像 值高于阈值。如果 img 是 Tensor，则它应为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
使用 的示例 ：
RandomSolarize
-
类 （sharpness_factor， p=0.5）[来源]
torchvision.transforms.RandomAdjustSharpness¶ 以给定的概率随机调整图像的清晰度。如果图像是 torch Tensor，则 它应具有 [...， 1 或 3， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
使用 的示例 ：
RandomAdjustSharpness
-
等级 （P=0.5）[来源]
torchvision.transforms.RandomAutocontrast¶ 以给定的概率随机自动对比给定图像的像素。 如果图像是 torch Tensor，则预期为 具有 [...， 1 或 3， H， W] 形状，其中 ...表示任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
- 参数
p （float） - 图像被自动对比的概率。默认值为 0.5
使用 的示例 ：
RandomAutocontrast
仅在 PIL 图像上变换¶
仅在 torch.*Tensor 上进行转换¶
-
类 （transformation_matrix， mean_vector）[来源]
torchvision.transforms.LinearTransformation¶ 使用方变换矩阵和计算mean_vector变换张量图像 离线。 此转换不支持 PIL Image。 给定 transformation_matrix 和 mean_vector，将使 torch.*Tensor 和 从中减去 mean_vector，然后计算点 product 替换为变换矩阵，然后将张量重塑为其 原形。
- 应用：
白化变换：假设 X 是一个以 0 为中心的列向量数据。 然后计算数据协方差矩阵 [D x D]，其中 torch.mm（X.t（）， X）， 对此矩阵执行 SVD 并将其作为 transformation_matrix 传递。
- 参数
transformation_matrix （Tensor） – 张量 [D x D]， D = C x H x W
mean_vector （Tensor） – 张量 [D]， D = C x H x W
-
类 （mean， std， inplace=False）[来源]
torchvision.transforms.Normalize¶ 使用平均值和标准差对张量图像进行归一化。 此转换不支持 PIL Image。 给定 mean： 和 std： 对于通道，此转换将对 input 的每个通道进行归一化，即
(mean[1],...,mean[n])(std[1],..,std[n])ntorch.*Tensoroutput[channel] = (input[channel] - mean[channel]) / std[channel]注意
这种转换的行为不合适，即它不会改变 Importing 张量。
- 参数
- mean （sequence） - 每个通道的均值序列。
std （sequence） - 每个通道的标准差序列。
inplace （bool，optional） – Bool 就地执行此操作。
使用 的示例 ：
Normalize
-
类 （p=0.5， scale=（0.02， 0.33）， ratio=（0.3， 3.3）， value=0， inplace=False）[来源]
torchvision.transforms.RandomErasing¶ 在 torch Tensor 图像中随机选择一个矩形区域并擦除其像素。 此转换不支持 PIL Image。 Zhong 等人的“Random Erasing Data Augmentation”。查看 https://arxiv.org/abs/1708.04896
- 参数
p – 执行随机擦除操作的概率。
scale – 擦除区域与输入图像的比例范围。
ratio – 擦除区域的纵横比范围。
value – 擦除值。默认值为 0。如果为单个 int，则用于 擦除所有像素。如果元组长度为 3，则用于擦除 R、G、B 通道。 如果 str 为 'random'，则擦除具有随机值的每个像素。
inplace – 布尔值，使此转换就地。默认值设置为 False。
- 返回
擦除的图像。
例
>>> transform = transforms.Compose([ >>> transforms.RandomHorizontalFlip(), >>> transforms.ToTensor(), >>> transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), >>> transforms.RandomErasing(), >>> ])
-
类 （dtype： torch.dtype）[来源]
torchvision.transforms.ConvertImageDtype¶ 将张量图像转换为给定的图像并相应地缩放值 该功能不支持 PIL Image。
dtype- 参数
dtype （torch.dpython：type） – 输出的所需数据类型
注意
从较小的整数转换为较大的整数时，最大值不会精确映射。 如果来回转换，则此不匹配不起作用。
dtype- 提高
RuntimeError – 尝试转换为 或 as 时 以及尝试转换为 。这些转化可能会导致 overflow 错误，因为浮点无法存储整个范围内的连续整数 整数 。
torch.float32torch.int32torch.int64torch.float64torch.int64dtypedtype
使用 的示例 ：
ConvertImageDtype
转换转换¶
-
class （mode=None）[来源]
torchvision.transforms.ToPILImage¶ 将 tensor 或 ndarray 转换为 PIL 图像。此转换不支持 torchscript。
转换形状为 C x H x W 的 torch.*Tensor 或形状为 H x W x C 添加到 PIL 图像，同时保留值范围。
- 参数
模式 （PIL.Image mode） – 输入数据的色彩空间和像素深度（可选）。 如果 is （默认），则对 input 数据进行了一些假设： - 如果输入有 4 个通道，则假定 为 。 - 如果输入有 3 个通道，则假定 为 。 - 如果输入有 2 个通道，则假定 为 。 - 如果输入有 1 个通道，则 由数据类型（即 、 、 ）确定。
modeNonemodeRGBAmodeRGBmodeLAmodeintfloatshort
使用 的示例 ：
ToPILImage
-
类 [来源]
torchvision.transforms.ToTensor¶ 将 or 转换为 tensor。此转换不支持 torchscript。
PIL Imagenumpy.ndarray转换范围内的 PIL 图像或 numpy.ndarray （H x W x C） [0， 255] 到Torch。形状为 （C x H x W） 在 [0.0， 1.0] 范围内的 FloatTensor 如果 PIL 图像属于以下模式之一（L、LA、P、I、F、RGB、YCbCr、RGBA、CMYK、1） 或者如果 numpy.ndarray 具有 dtype = np.uint8
在其他情况下，将返回张量而不进行缩放。
注意
由于输入图像缩放为 [0.0， 1.0]，因此在以下情况下不应使用此转换 变换目标图像蒙版。请参阅有关实现图像遮罩转换的参考资料。
泛型变换¶
AutoAugment 变换¶
AutoAugment 是一种常见的数据增强技术，可以提高图像分类模型的准确性。 尽管数据增强策略与他们训练的数据集直接相关，但实证研究表明， ImageNet 策略在应用于其他数据集时提供了显著的改进。 在 TorchVision 中，我们实施了在以下数据集上学习的 3 个策略： ImageNet 、 CIFAR10 和 SVHN 。 新转换可以独立使用，也可以与现有转换混合使用：
-
类 [来源]
torchvision.transforms.AutoAugmentPolicy¶ AutoAugment 策略在不同的数据集上学习。 可用策略包括 IMAGENET、CIFAR10 和 SVHN。
使用 的示例 ：
AutoAugmentPolicy
-
class （policy： torchvision.transforms.autoaugment.AutoAugmentPolicy = <AutoAugmentPolicy.IMAGENET： 'imagenet'>， interpolation： torchvision.transforms.functional.InterpolationMode = <InterpolationMode.NEAREST： 'nearest'>， fill： Optional[List[float]] = None）[源]
torchvision.transforms.AutoAugment¶ 基于 “AutoAugment： Learning Augmentation Strategies from Data” 的 AutoAugment 数据增强方法。 如果图像是 torch Tensor，则它应该是 torch.uint8 类型，并且是预期的 具有 [...， 1 或 3， H， W] 形状，其中 ...表示任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
- 参数
policy （AutoAugmentPolicy） – 由 定义的所需策略枚举。默认值为 。
torchvision.transforms.autoaugment.AutoAugmentPolicyAutoAugmentPolicy.IMAGENETinterpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。
torchvision.transforms.InterpolationModeInterpolationMode.NEARESTInterpolationMode.NEARESTInterpolationMode.BILINEARfill （sequence or number， optional） （序列或数字，可选） – 转换后的 Area 之外的像素填充值 图像。如果给定一个数字，则该值分别用于所有波段。
使用 的示例 ：
AutoAugment
函数转换¶
函数转换可让您对转换管道进行精细控制。 与上述转换相反，函数转换不包含随机数 generator 的参数。 这意味着您必须指定/生成所有参数，但函数式转换将为您提供 跨调用的可重现结果。
例： 您可以将具有相同参数的函数转换应用于多个图像，如下所示：
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
例： 您可以使用 Functional transform 来构建具有自定义行为的 transform 类：
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.InterpolationMode¶ 插值模式 可用的插值方法包括 、 和 。
nearestbilinearbicubicboxhamminglanczos
-
torchvision.transforms.functional.adjust_brightness(img：Torch。Tensor，brightness_factor：float） → torch。张量[来源]¶ 调整图像的亮度。
- 参数
img （PIL Image or Tensor） – 要调整的图像。 如果 img 是 torch Tensor，则预期为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。
brightness_factor （float） （浮动） – 调整亮度的程度。可以是 任何非负数。0 表示黑色图像，1 表示 原始图像 2 时，亮度增加 2 倍。
- 返回
亮度调整图像。
- 返回类型
PIL 图像或张量
-
torchvision.transforms.functional.adjust_contrast(img：Torch。Tensor，contrast_factor：float）→ torch。张量[来源]¶ 调整图像的对比度。
- 参数
img （PIL Image or Tensor） – 要调整的图像。 如果 img 是 torch Tensor，则预期为 [...， 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。
contrast_factor （float） （浮动） – 调整对比度的程度。可以是任何 非负数。0 表示纯灰色图像，1 表示 原始图像 （2） 将对比度提高 2 倍。
- 返回
对比度调整的图像。
- 返回类型
PIL 图像或张量
-
torchvision.transforms.functional.adjust_gamma(img：Torch。张量、gamma：浮点数、增益：浮点数 = 1） → torch。张量[来源]¶ 对图像执行 Gamma 校正。
也称为幂律变换。调整 RGB 模式下的强度 基于以下公式：
\[I_{\text{out}} = 255 \times \text{gain} \times \left(\frac{I_{\text{in}}}{255}\right)^{\gamma}\]有关更多详细信息，请参阅 Gamma 校正。
-
torchvision.transforms.functional.adjust_hue(img：Torch。Tensor，hue_factor：float）→ torch。张量[来源]¶ 调整图像的色相。
通过将图像转换为 HSV 和 周期性地改变色相通道 （H） 中的强度。 然后，图像将转换回原始图像模式。
hue_factor 是 H 通道中的偏移量，并且必须位于 区间 [-0.5， 0.5]。
有关更多详细信息，请参阅 Hue。
- 参数
img （PIL Image or Tensor） – 要调整的图像。 如果 img 是 torch Tensor，则预期为 [...， 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 如果 img 为 PIL 图像模式“1”，则不支持“L”、“I”、“F”和透明度模式（Alpha 通道）。
hue_factor （float） – 偏移色调通道的量。应为 [-0.5, 0.5].0.5 和 -0.5 表示 色调通道的完全反转 HSV 空间分别在正方向和负方向上。 0 表示无偏移。因此，-0.5 和 0.5 都会给出一个图像 替换为互补色，而 0 则提供原始图像。
- 返回
色相调整图像。
- 返回类型
PIL 图像或张量
-
torchvision.transforms.functional.adjust_saturation(img：Torch。Tensor，saturation_factor：float）→ torch。张量[来源]¶ 调整图像的颜色饱和度。
- 参数
img （PIL Image or Tensor） – 要调整的图像。 如果 img 是 torch Tensor，则预期为 [...， 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。
saturation_factor （float） （ （float） （浮点数） ） – 调整饱和度的程度。0 将 给出黑白图像，1 将给出原始图像，而 2 会将饱和度提高 2 倍。
- 返回
饱和度调整图像。
- 返回类型
PIL 图像或张量
-
torchvision.transforms.functional.adjust_sharpness(img：Torch。Tensor，sharpness_factor：float）→ torch。张量[来源]¶ 调整图像的清晰度。
- 参数
img （PIL Image or Tensor） – 要调整的图像。 如果 img 是 torch Tensor，则预期为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。
sharpness_factor （float） – 调整清晰度的程度。可以是 任何非负数。0 表示图像模糊，1 表示 原始图像，而 2 将清晰度提高 2 倍。
- 返回
清晰度调整图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
adjust_sharpness
-
torchvision.transforms.functional.affine(img：Torch。张量，角度：浮点，翻译：List[int]，缩放：浮点，剪切：List[float]，插值：torchvision.transforms.functional.InterpolationMode = <InterpolationMode.NEAREST： 'nearest'>，fill： 可选[List[float]] = 无，重新采样：可选[int] = 无，fillcolor： 可选[List[float]] = None） →Torch。张量[来源]¶ 对图像应用仿射变换，保持图像中心不变。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
img （PIL Image or Tensor） – 要转换的图像。
angle （number） - 顺时针方向的旋转角度，以 -180 和 180 之间的度为单位。
translate （ Sequence of python：Integers） – 水平和垂直平移 （旋转后平移）
scale （float） – 整体比例
shear （float or sequence） （剪切力 （浮点数或序列） ） – 剪切力值，以 -180 到 180 之间的度数表示，顺时针方向。 如果指定了序列，则第一个值对应于平行于 x 轴的剪切，而 第二个值对应于平行于 Y 轴的剪切。
interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.NEARESTInterpolationMode.NEARESTInterpolationMode.BILINEARPIL.Image.NEARESTfill （sequence 或 number，可选） –
变换后的 图像。如果给定一个数字，则该值分别用于所有波段。
注意
在 torchscript 模式下，不支持单个 int/float 值，请使用序列 长度为 1：。
[value, ]fillColor （sequence， int， float） – 已弃用的参数，自 v0.10.0 起将被删除。 请改用 parameter 。
fillresample （int， optional） – 已弃用的参数，将从 v0.10.0 开始删除。 请改用 parameter 。
interpolation
- 返回
转换后的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
affine
-
torchvision.transforms.functional.autocontrast(img：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ 通过重新映射图像的对比度来最大化图像的对比度 像素，以便最低的变为黑色，而最亮的 变为白色。
- 参数
img （PIL Image or Tensor） – 应用了自动对比度的图像。 如果 img 是 torch Tensor，则预期为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
- 返回
自动对比的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
autocontrast
-
torchvision.transforms.functional.center_crop(img：Torch。Tensor，output_size：List[int]） → torch。张量[来源]¶ 在中心裁剪给定的图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。 如果图像大小小于沿任何边缘的输出大小，则图像将填充 0，然后居中裁剪。
- 参数
img （PIL Image or Tensor） – 要裁剪的图像。
output_size （sequence or int） – 裁剪框的 （height， width） 。如果 int 或 sequence 具有单个 int，则 它用于两个方向。
- 返回
裁剪的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
center_crop
-
torchvision.transforms.functional.convert_image_dtype(图片：Torch。Tensor，dtype： torch.dtype = torch.float32） → torch。张量[来源]¶ 将张量图像转换为给定的图像并相应地缩放值 该功能不支持 PIL Image。
dtype- 参数
图像 （Torch.Tensor） – 要转换的图像
dtype （torch.dpython：type） – 输出的所需数据类型
- 返回
转换后的图像
- 返回类型
张肌
注意
从较小的整数转换为较大的整数时，最大值不会精确映射。 如果来回转换，则此不匹配不起作用。
dtype- 提高
RuntimeError – 尝试转换为 或 as 时 以及尝试转换为 。这些转化可能会导致 overflow 错误，因为浮点无法存储整个范围内的连续整数 整数 。
torch.float32torch.int32torch.int64torch.float64torch.int64dtypedtype
使用 的示例 ：
convert_image_dtype
-
torchvision.transforms.functional.crop(img：Torch。Tensor， top： int， left： int， height： int， width： int） → torch 的 Tensor， top： int， left： int， height： int.张量[来源]¶ 在指定位置和输出大小裁剪给定图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。 如果图像大小小于沿任何边缘的输出大小，则图像将填充 0，然后进行裁剪。
- 参数
- 返回
裁剪的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
crop
-
torchvision.transforms.functional.equalize(img：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ 通过应用 非线性映射到输入，以便创建均匀的 输出中灰度值的分布。
- 参数
img （PIL Image or Tensor） – 应用均衡的图像。 如果 img 是 torch Tensor，则预期为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 张量 dtype 必须为 ，并且值应为 。 如果 img 是 PIL Image，则预计它处于“P”、“L”或“RGB”模式。
torch.uint8[0, 255]- 返回
已均衡的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
equalize
-
torchvision.transforms.functional.erase(img：Torch。张量， i： int， j： int， h： int， w： int， v： torch.Tensor，就地：bool = False）→ torch。张量[来源]¶ 擦除具有给定值的输入 Tensor Image。 此转换不支持 PIL Image。
-
torchvision.transforms.functional.five_crop(img：Torch。张量，大小：List[int]） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张量][来源]¶ 将给定的图像裁剪为四个角，并进行中央裁剪。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导尺寸
注意
此转换返回一个图像元组，并且可能存在一个 输入和目标数量不匹配，您的回报。
Dataset- 参数
img （PIL Image or Tensor） – 要裁剪的图像。
size （sequence or int） – 作物的所需输出大小。如果 size 是 int 而不是像 （h， w） 这样的序列，方形裁剪 （size， size） 是 䍬。如果提供长度为 1 的序列，则它将被解释为 （size[0]， size[0]）。
- 返回
元组 （TL， TR， BL， BR， CENTER） 相应的左上、右上、左下、右下和居中裁剪。
- 返回类型
使用 的示例 ：
five_crop
-
torchvision.transforms.functional.gaussian_blur(img：Torch。张量，kernel_size：List[int]，sigma：可选[List[float]] = None）→ torch。张量[来源]¶ 按给定内核对图像执行高斯模糊处理。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
img （PIL Image or Tensor） – 要模糊的图像
kernel_size （python：ints 或 int 序列） –
Gaussian kernel 大小。可以是整数序列 like 或方形内核的单个整数。
(kx, ky)注意
在 torchscript 模式下kernel_size由于不支持单个 int，请使用 长度 1： 。
[ksize, ]sigma （python：floats 或 float 序列，可选）–
高斯核标准差。可以是 floats 序列（如）或单个浮点数来定义 在 X/Y 两个方向上具有相同的 sigma。如果为 None，则使用 as 计算它。 Default （默认值） 和 None （无）。
(sigma_x, sigma_y)kernel_sizesigma = 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8注意
在 torchscript 模式下，sigma 作为单个浮点数为 不支持，请使用长度为 1 的序列： .
[sigma, ]
- 返回
图像的 Gaussian Blurred 版本。
- 返回类型
PIL 图像或张量
使用 的示例 ：
gaussian_blur
-
torchvision.transforms.functional.hflip(img：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ 水平翻转给定的图像。
- 参数
img （PIL Image or Tensor） – 要翻转的图像。如果 img 是一个 Tensor，它应该为 [...， H， W] 格式， 哪里。。。表示它可以有任意数量的前导 尺寸。
- 返回
水平翻转的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
hflip
-
torchvision.transforms.functional.invert(img：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ 反转 RGB/灰度图像的颜色。
- 参数
img （PIL Image or Tensor） – 颜色反转的图像。 如果 img 是 torch Tensor，则预期为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
- 返回
彩色反转图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
invert
-
torchvision.transforms.functional.normalize(张量：Torch。张量，均值：List[float]，标准：List[float]，就地：bool = False）→ torch。张量[来源]¶ 使用平均值和标准差对浮点张量图像进行归一化。 此转换不支持 PIL Image。
注意
默认情况下，此转换的行为不合适，即它不会改变 Importing 张量。
- 参数
- 要归一化的大小为 （C， H， W） 或 （B， C， H， W） 的浮点张量图像。
- mean （sequence） - 每个通道的均值序列。
std （sequence） - 每个通道的标准差序列。
inplace （bool，optional） – Bool 使此操作就地进行。
- 返回
归一化张量图像。
- 返回类型
张肌
使用 的示例 ：
normalize
-
torchvision.transforms.functional.pad(img：Torch。张量，填充：List[int]，填充：int = 0，padding_mode：str = 'constant'）→ torch。张量[来源]¶ 用给定的 “pad” 值在给定的图像的所有侧面填充。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示最多 2 个前导维度用于 Mode Reflect 和 Symmetric， 模态边最多 3 个前导尺寸， 以及 mode constant 的任意数量的前导维度
- 参数
img （PIL Image or Tensor） – 要填充的图像。
填充（int 或 sequence）–
每个边框上的填充。如果提供了单个 int 用于填充所有边框。如果提供了长度为 2 的序列，则为填充 分别在 left/right 和 top/bottom 上。如果提供长度为 4 的序列 这分别是 left、top、right 和 bottom 边框的填充。
注意
在 torchscript 模式下，由于不支持单个 int 填充，请使用 长度 1： 。
[padding, ]fill （number or str or tuple） – 常量填充的像素填充值。默认值为 0。 如果 Tuples 长度为 3，则分别用于填充 R、G、B 通道。 仅当 padding_mode 为 constant 时，才使用此值。 torch Tensor 仅支持 number。 PIL Image 仅支持 int 或 str 或 tuple value。
padding_mode （str） –
填充类型。应为：constant、edge、reflect 或 symmetric。 默认值为 constant。
常数：具有常数值的焊盘，该值由 fill 指定
edge：在图像边缘使用最后一个值进行填充。 如果输入 5D torch Tensor，则填充最后 3 个维度而不是最后 2 个
Reflect（反射）：使用图像反射填充，而不重复边缘上的最后一个值。 例如，在反射模式下，填充 [1， 2， 3， 4] 两侧有 2 个元素 将导致 [3， 2， 1， 2， 3， 4， 3， 2]
symmetric：带有图像反射的焊盘重复边缘上的最后一个值。 例如，在对称模式下，两侧有 2 个元素填充 [1， 2， 3， 4] 将产生 [2， 1， 1， 2， 3， 4， 4， 3]
- 返回
填充图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
pad
-
torchvision.transforms.functional.perspective(img：Torch。张量，起点：List[List[int]]，端点：List[List[int]]，插值：torchvision.transforms.functional.InterpolationMode = <InterpolationMode.BILINEAR： 'bilinear'>，填充：可选[List[float]] = None） → torch。张量[来源]¶ 执行给定图像的透视变换。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
img （PIL Image or Tensor） – 要转换的图像。
startpoints （list of list of python：ints） – 包含四个列表的列表，每个列表包含两个整数，对应于原始图像的四个角。
[top-left, top-right, bottom-right, bottom-left]endpoints （list of list of python：ints） – 包含四个两个整数列表的列表，对应于转换后的图像的四个角。
[top-left, top-right, bottom-right, bottom-left]interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.BILINEARInterpolationMode.NEARESTInterpolationMode.BILINEARPIL.Image.NEARESTfill （sequence 或 number，可选） –
变换后的 图像。如果给定一个数字，则该值分别用于所有波段。
注意
在 torchscript 模式下，不支持单个 int/float 值，请使用序列 长度为 1：。
[value, ]
- 返回
转换后的 Image。
- 返回类型
PIL 图像或张量
使用 的示例 ：
perspective
-
torchvision.transforms.functional.pil_to_tensor(pic）[来源]¶ 将 a 转换为相同类型的张量。 此函数不支持 torchscript。
PIL Image有关更多详细信息，请参阅。
PILToTensor- 参数
pic （PIL Image） - 要转换为张量的图像。
- 返回
转换后的图像。
- 返回类型
张肌
-
torchvision.transforms.functional.posterize(img：Torch。Tensor， bits： int） → torch 的 Tensor 中。张量[来源]¶ 通过减少每个颜色通道的位数来色调分离图像。
- 参数
img （PIL Image or Tensor） – 使其颜色色调分离的图像。 如果 img 是 torch Tensor，它应该是 torch.uint8 类型，并且 它应为 [...， 1 或 3， H， W] 格式，其中 ...方法 它可以具有任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
bits （int） - 每个通道要保留的位数 （0-8）。
- 返回
色调分离图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
posterize
-
torchvision.transforms.functional.resize(img：Torch。张量，大小：List[int]，插值：torchvision.transforms.functional.InterpolationMode = <InterpolationMode.BILINEAR： 'bilinear'>，max_size：可选[int] = 无，抗锯齿：可选[bool] = 无）→ torch。张量[来源]¶ 将输入图像的大小调整为给定的大小。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导尺寸
警告
输出图像可能因其类型而异：缩减像素采样时，PIL 图像的插值 和 Tensors 略有不同，因为 PIL 应用了抗锯齿。这可能会导致显著差异 在网络性能中。因此，最好训练和提供具有相同输入的模型 类型。
- 参数
img （PIL Image or Tensor） – 要调整大小的图像。
size （sequence 或 int） –
所需的输出大小。如果 size 是类似于 （h， w） 时，输出大小将与此大小匹配。如果 size 是 int，则 图像的较小边缘将与此数字匹配，保持 纵横比。即，如果 height > width，则 image 将被重新缩放为 。
注意
在 torchscript 模式下，由于不支持单个 int，因此请使用长度为 1 的序列：。
[size, ]interpolation （InterpolationMode） – 由 定义的所需插值枚举。 默认值为 。如果 input 为 Tensor，则仅支持 和 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.BILINEARInterpolationMode.NEARESTInterpolationMode.BILINEARInterpolationMode.BICUBICPIL.Image.NEARESTmax_size （int， optional） – 较长边允许的最大值 调整大小后的图像：如果图像的较长边缘较大 比按照 调整大小后 ，则 再次调整图像大小，使较长的边缘等于 。因此，可能会被否决，即 较小的边缘可能短于 。这仅支持 if 是 int （或 TorchScript 中长度为 1 的序列 模式）。
max_sizesizemax_sizesizesizesizeantialias （布尔值，可选） –
antialias 标志。如果是 PIL Image，则忽略该标志并消除锯齿 始终使用。如果为 Tensor，则标志默认为 False，并且只能为模式设置为 True。
imgimgInterpolationMode.BILINEAR警告
input 为 Tensor 的 option 不支持 autodiff 。
antialias=Trueimg
- 返回
调整大小的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
resize
-
torchvision.transforms.functional.resized_crop(img：Torch。张量，顶部：int，左侧：int，高度：int，宽度：int，大小：List[int]，插值：torchvision.transforms.functional.InterpolationMode = <InterpolationMode.BILINEAR： 'bilinear'>） → torch。张量[来源]¶ 裁剪给定的图像并将其调整为所需的大小。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导尺寸
- 参数
img （PIL Image or Tensor） – 要裁剪的图像。（0,0） 表示图像的左上角。
top （int） – 裁剪框左上角的垂直分量。
left （int） – 裁剪框左上角的水平分量。
height （int） – 裁剪框的高度。
width （int） – 裁剪框的宽度。
size （sequence or int） – 所需的输出大小。与 .
resizeinterpolation （InterpolationMode） – 由 定义的所需插值枚举。 默认值为 。如果 input 为 Tensor，则仅支持 和 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.BILINEARInterpolationMode.NEARESTInterpolationMode.BILINEARInterpolationMode.BICUBICPIL.Image.NEAREST
- 返回
裁剪的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
resized_crop
-
torchvision.transforms.functional.rgb_to_grayscale(img：Torch。Tensor，num_output_channels：int = 1） → torch。张量[来源]¶ 将 RGB 图像转换为图像的灰度版本。 如果图像是 torch Tensor，则预期为 具有 [...， 3， H， W] 形状，其中 ...表示任意数量的前导尺寸
注意
请注意，此方法仅支持 RGB 图像作为输入。对于其他色彩空间中的输入， 请考虑将 meth：~torchvision.transforms.functional.to_grayscale 与 PIL Image 一起使用。
- 参数
img （PIL Image or Tensor） – 要转换为灰度的 RGB 图像。
num_output_channels （int） - 输出图像的通道数。值可以是 1 或 3。默认为 1。
- 返回
图像的灰度版本。
如果 num_output_channels = 1 ：返回的图像是单通道
如果 num_output_channels = 3 ： 返回的图像是 r = g = b 的 3 通道
- 返回类型
PIL 图像或张量
-
torchvision.transforms.functional.rotate(img：Torch。张量，角度：浮点，插值：torchvision.transforms.functional.InterpolationMode = <InterpolationMode.NEAREST： 'nearest'>，expand： bool = False，center： Optional[List[int]] = None，fill： Optional[List[float]] = None，resample： Optional[int] = None）→Torch。张量[来源]¶ 按角度旋转图像。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导维度。
- 参数
img （PIL Image or Tensor） – 要旋转的图像。
angle （number） - 逆时针旋转角度值，以度为单位。
interpolation （InterpolationMode） – 由 定义的所需插值枚举。默认值为 。 如果 input 为 Tensor，则仅支持 。 为了向后兼容，整数值（例如 ）仍然是可以接受的。
torchvision.transforms.InterpolationModeInterpolationMode.NEARESTInterpolationMode.NEARESTInterpolationMode.BILINEARPIL.Image.NEARESTexpand （bool， optional） – 可选的扩展标志。 如果为 true，则扩展输出图像，使其足够大以容纳整个旋转的图像。 如果为 false 或省略，则使输出图像与输入图像的大小相同。 请注意，expand 标志假定绕中心旋转且无平移。
center （sequence， optional） （center （sequence ， optional） （序列，可选） – 可选的旋转中心。原点 是左上角。 默认值是图像的中心。
fill （sequence 或 number，可选） –
变换后的 图像。如果给定一个数字，则该值分别用于所有波段。
注意
在 torchscript 模式下，不支持单个 int/float 值，请使用序列 长度为 1：。
[value, ]
- 返回
旋转的图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
rotate
-
torchvision.transforms.functional.solarize(img：Torch。Tensor，阈值：float）→ torch 的 Tensor 中。张量[来源]¶ 通过反转高于阈值的所有像素值来使 RGB/灰度图像曝光。
- 参数
img （PIL Image or Tensor） – 颜色反转的图像。 如果 img 是 torch Tensor，则预期为 [...， 1 或 3， H， W] 格式， 哪里。。。表示它可以具有任意数量的前导维度。 如果 img 是 PIL Image，则预计它处于“L”或“RGB”模式。
threshold （float） – 所有等于或高于此值的像素都将被反转。
- 返回
曝光图像。
- 返回类型
PIL 图像或张量
使用 的示例 ：
solarize
-
torchvision.transforms.functional.ten_crop(img：Torch。张量，大小：List[int]，vertical_flip：bool = False）→ List[torch.张量][来源]¶ 从给定图像生成 10 张裁剪图像。 将给定图像裁剪为四个角，中间裁剪加上 这些的 flipped 版本（默认使用水平翻转）。 如果图像是 torch Tensor，则预期为 具有 [...， H， W] 形状，其中 ...表示任意数量的前导尺寸
注意
此转换返回一个图像元组，并且可能存在一个 输入和目标数量不匹配，您的回报。
Dataset- 参数
- 返回
元组 （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 图像转换为图像的灰度版本。 此转换不支持 torch Tensor。
- 参数
img （PIL Image） – 要转换为灰度的 PIL 图像。
num_output_channels （int） - 输出图像的通道数。值可以是 1 或 3。默认值为 1。
- 返回
图像的灰度版本。
如果 num_output_channels = 1 ：返回的图像是单通道
如果 num_output_channels = 3 ： 返回的图像是 r = g = b 的 3 通道
- 返回类型
太平船务图片
使用 的示例 ：
to_grayscale
-
torchvision.transforms.functional.to_pil_image(pic， mode=None）[来源]¶ 将 tensor 或 ndarray 转换为 PIL 图像。此函数不支持 torchscript。
- 参数
pic （Tensor 或 numpy.ndarray） – 要转换为 PIL 图像的图像。
模式 （PIL.Image mode） – 输入数据的色彩空间和像素深度（可选）。
- 返回
图像转换为 PIL 图像。
- 返回类型
太平船务图片
使用 的示例 ：
to_pil_image
-
torchvision.transforms.functional.to_tensor(pic）[来源]¶ 将 or 转换为 tensor。 此函数不支持 torchscript。
PIL Imagenumpy.ndarray- 参数
pic （PIL Image 或 numpy.ndarray） - 要转换为张量的图像。
- 返回
转换后的图像。
- 返回类型
张肌