jittor.transform

这里是Jittor的 数据变换 模块的API文档,您可以通过from jittor import transform来获取该模块。

class jittor.transform.CenterCrop(size)[源代码]

中心裁剪图像的类。本类用于创建一个中心裁剪变换。当使用此类的实例调用一张图像时,它将图像裁剪为指定的大小,并且裁剪的中心与图像的中心对齐。

参数:
  • size(int, tuple): 裁剪后的图像尺寸。

代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> center_crop = transform.CenterCrop(16)
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> center_crop(img).size
(16, 16)
class jittor.transform.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0)[源代码]

随机改变图像的亮度、对比度、饱和度和色调。该类用于对图像进行随机的颜色变换,以进行数据增强。这些变换包括亮度、对比度、饱和度和色调的调整。

参数:
  • brightness (float, tuple(min, max)): 要改变的亮度范围。亮度因子从 \([\max(0, 1 - brightness), 1 + brightness]\) 或给定的 \([min, max]\) 中均匀选择。应为非负数。默认值为 0,表示不改变亮度。

  • contrast (float, tuple(min, max)): 要改变的对比度范围。对比度因子从 \([\max(0, 1 - contrast), 1 + contrast]\) 或给定的 \([min, max]\) 中均匀选择。应为非负数。默认值为 0,表示不改变对比度。

  • saturation (float, tuple(min, max)): 要改变的饱和度范围。饱和度因子从 \([\max(0, 1 - saturation), 1 + saturation]\) 或给定的 \([min, max]\) 中均匀选择。应为非负数。默认值为 0,表示不改变饱和度。

  • hue (float, tuple(min, max)): 要改变的色调范围。色调因子从 \([-hue, hue]\) 或给定的 \([min, max]\) 中均匀选择。应满足 \(0\leq hue\leq 0.5\)\(-0.5 \leq min \leq max \leq 0.5\)。默认值为 0,表示不改变色调。

代码示例:
>>> from jittor.transform import ColorJitter
>>> from PIL import Image
>>> img = Image.open('''path_to_image.jpg''')
>>> transform = ColorJitter(brightness=0.2, contrast=0.3, saturation=0.4, hue=0.1)
>>> img_transformed = transform(img)
class jittor.transform.Compose(transforms)[源代码]

将多个图像变换组合在一起的类。该类将输入的变换列表依次应用到输入数据上。如果输入数据为单个对象,会依次通过每个变换;如果输入为多个对象(例如图像和对应标签),则每个变换都会接收相同的参数列表,并依次处理。

参数:
  • transforms (list): 需要组合的变换列表。

代码示例:
>>> from jittor import transform
>>> compose = transform.Compose([
    transform.Resize(224),
    transform.Gray(),
    transform.ImageNormalize(mean=[0.5], std=[0.5]),
])
>>> img_ = compose(img)
class jittor.transform.Crop(top, left, height, width)[源代码]

根据指定大小裁剪PIL图像。在初始化时需要指定裁剪区域的边界,之后可以作为一个可调用对象直接应用在图像上。

参数:
  • top (int): 裁剪区域顶部边界的像素索引

  • left (int): 裁剪区域左侧边界的像素索引

  • height (int): 裁剪区域高度

  • width (int): 裁剪区域宽度

代码示例:
>>> from jittor import transform
>>> cropper = transform.Crop(top=100, left=100, height=200, width=200)
>>> cropped_img = cropper(img)
class jittor.transform.FiveCrop(size)[源代码]

在给定的PIL图像四个角和中心各截取一幅大小为 size 的图片

参数:
  • size (sequence, int): 裁剪的期望输出大小。如果size是一个整数而不是像(h, w)这样的序列,会进行一个(size, size)的正方形裁剪

代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> five_crop = transform.FiveCrop(16)
>>> imgs = five_crop(img)
>>> imgs[0].size, imgs[1].size, imgs[2].size, imgs[3].size, imgs[4].size
((16, 16), (16, 16), (16, 16), (16, 16), (16, 16))
class jittor.transform.Gray(num_output_channels=1)[源代码]

将图像转换为灰度图的类。

参数:
  • num_output_channels (int, 可选): 输出通道数(1表示单通道灰度图,3表示三通道灰度图),默认值为1。

代码示例:
>>> from jittor import transform
>>> gray = transform.Gray()
>>> img_ = gray(img)
class jittor.transform.ImageNormalize(mean, std)[源代码]

对图像进行标准化处理的类。给定n个通道的均值(mean[1], …, mean[n])和标准差(std[1], .., std[n]),此转换将标准化输入张量的每个通道,即:

\[output[channel] = (input[channel] - mean[channel]) / std[channel]\]
参数:
  • mean(list): 标准化使用的平均值列表

  • std(list): 标准化使用的标准差列表

代码示例:
>>> from jittor import transform
>>> img_normalize = transform.ImageNormalize(mean=[0.5], std=[0.5])
>>> img_ = img_normalize(img)
class jittor.transform.Lambda(lambd)[源代码]

此类用于将用户定义的lambda函数作为变换应用到对象上。

参数:
  • lambd (function): 用于变换的lambda函数。

代码示例:
>>> from jittor import transform
>>> lambda = transform.Lambda(lambda x: x + 10)
>>> result = lambda(5)
class jittor.transform.RandomAffine(degrees, translate=None, scale=None, shear=None, resample=False, fillcolor=0)[源代码]

随机仿射变换,输入保持中心不变。

参数:
  • degrees (序列或int) : 可供选择的度数范围。如果度数是数字而不是序列(min, max) ,则度数范围将为 (-degrees, +degrees)。

  • translate (元组, 可选): 例如 translate=(a, b),那么水平平移将在 img_width * a < dx < img_width * a 的范围内随机采样,垂直平移将在 -img_height * b < dy < img_height * b 的范围内随机采样。默认情况下不进行平移。默认值: None

  • scale (元组, 可选): 缩放因子区间,例如 (a, b),则缩放比例在 a <= scale <= b 的范围内随机采样。默认值: None

  • shear (序列, float或int, 可选): 从中选取剪切角度的范围。 如果 shear 是一个数字,则将应用范围是 (-shear, +shear) 并且平行于 x 轴的剪切;若是一个元组或列表且包含2个值,则应用范围是 (shear[0], shear[1]) 并且平行于 x 轴的剪切; 若是一个元组或列表且包含4个值,则应用 x 轴剪切范围 (shear[0], shear[1]) 以及y 轴剪切范围 (shear[2], shear[3])。默认情况下不应用剪切。默认值: None

  • resample ({PIL.Image.NEAREST, PIL.Image.BILINEAR, PIL.Image.BICUBIC}, 可选): 可选的重采样滤波器。请参阅 这里 以获取更多信息。默认值: False

  • fillcolor (元组或int, 可选): 对输出图像中变换区域外的区域填充的颜色(RGB 图像用元组表示,灰度图像用整数表示)。默认值: 0

代码示例:
>>> from jittor import transform
>>> random_affine = transform.RandomAffine(degrees=45)
>>> img_ = random_affine(img)
class jittor.transform.RandomApply(transforms, p=0.5)[源代码]

随机应用具有给定概率的变换列表。

参数:
  • transforms (list, tuple): 需要随机应用的变换操作列表

  • p (float): 概率,默认值是 0.5

代码示例:
>>> from jittor import transform
>>> transform_list = [transform.RandomHorizontalFlip(), transform.RandomCrop(size=(32, 32))] 
>>> random_apply = transform.RandomApply(transform_list, p=0.5)
>>> img_= random_apply(img)
class jittor.transform.RandomChoice(transforms)[源代码]

从给定的变换列表中随机选择一个变换应用于图像。

参数:
  • transforms (list, tuple): 变换列表。

代码示例:
>>> from jittor import transform
>>> transform_list = [transform.RandomHorizontalFlip(), transform.RandomCrop(size=(32, 32))] 
>>> random_choice = transform.RandomChoice(transform_list)
>>> img_ = random_choice(img)
class jittor.transform.RandomCrop(size)[源代码]

随机裁剪输入图像的类。

参数:
  • size (tuple, int): 欲裁剪的目标大小。如果是int,将裁剪出一个正方形;如果是tuple,则按照(tuple_height, tuple_width)的形式给出。

代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> random_crop = transform.RandomCrop(128)
>>> random_crop(img).size
(128, 128)
class jittor.transform.RandomCropAndResize(size, scale: tuple = (0.08, 1.0), ratio: tuple = (0.75, 1.3333333333333333), interpolation=2)[源代码]

对给定的PIL图像进行随机裁剪和尺寸调整。

参数:
  • size (int, tuple): 输出图像的[高度,宽度]

  • scale (tuple): 裁剪区域的面积比例范围。默认值: (0.08, 1.0)

  • ratio (tuple): 裁剪图像的长宽比范围。默认值: (3.0/4.0, 4.0/3.0)

  • interpolation (InterpolationMode): 图像大小调整时采用的插值类型。默认使用双线性插值。默认值: PIL.Image.BILINEAR

代码示例:
>>> from jittor import transform
>>> import numpy as np  
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> transform = transform.RandomCropAndResize(128)
>>> transform(img).size
(133, 128)
class jittor.transform.RandomGray(p=0.1)[源代码]

随机将图片转换为灰度图。该类用于以给定的概率p随机将输入图像转换为灰度图像,转换后的图像可能保持不变或则转换为灰度图,这取决于一个随机事件。输出灰度图与输入图的通道数保持一致。

参数:
  • p (float): 图像被转换为灰度图的概率。默认值: 0.1

代码示例:
>>> from jittor import transform
>>> random_gray = transform.RandomGray()
>>> img_ = random_gray(img)
class jittor.transform.RandomHorizontalFlip(p=0.5)[源代码]

对图像进行随机水平翻转的变换类,以一定的概率水平翻转输入的图像。

参数:
  • p (float): 图像翻转的概率。默认值为0.5。

代码示例:
>>> from jittor import transform
>>> random_hflip = transform.RandomHorizontalFlip(0.6)
>>> img_ = random_hflip(img)
class jittor.transform.RandomOrder(transforms)[源代码]

对一系列的变换操作以随机的顺序进行应用。

参数:
  • transforms (list): 需要应用的变换操作的列表

代码示例:
>>> from jittor import transform
>>> transform_list = [transform.RandomHorizontalFlip(), transform.RandomCrop(size=(32, 32))] 
>>> random_order = transform.RandomOrder(transform_list)
>>> img_ = random_order(img)
class jittor.transform.RandomPerspective(distortion_scale=0.5, p=0.5, interpolation=3)[源代码]

对图像以一定的概率进行随机透视变换。

参数:
  • distortion_scale(float, 可选): 控制变形程度的比例系数,值域为 [0, 1]。默认值: 0.5

  • p (float, 可选): 图片被透视变换的概率。默认值: 0.5

  • interpolation (PIL.Image.Interpolation method, 可选): 插值方法。默认值: PIL.Image.BICUBIC

代码示例:
>>> from jittor import transform
>>> random_perspective = transform.RandomPerspective(distortion_scale=0.5, p=0.5)
>>> img_ = random_perspective(img)
class jittor.transform.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=2)[源代码]

对给定的PIL图像执行随机尺寸与宽高比的裁剪并将其调整为给定大小。 同 jittor.transform.RandomSizedCrop

参数:
  • size (int, tuple[int]): 裁剪后每边的期望输出尺寸。若为单一整数,输出将是正方形;若为(int, int)元组,则输出为指定的宽高。

  • scale (tuple[float], 可选): 原始尺寸裁剪范围。默认值: (0.08, 1.0)。

  • ratio (tuple[float], 可选): 原始宽高比裁剪范围。默认值: (3/4, 4/3)。

  • interpolation (PIL.Image.Interpolation method, 可选): 图像插值方法。默认值: PIL.Image.BILINEAR

代码示例:
>>> from jittor import transform
>>> random_resized_crop = transform.RandomResizedCrop(size=(224, 224))
>>> img_ = random_resized_crop(img)
class jittor.transform.RandomRotation(degrees, resample=False, expand=False, center=None, fill=None)[源代码]

对图像进行随机旋转。

参数:
  • degrees (sequence, float, int): 选择的角度范围,如果degrees是一个数字而不是像(min, max)这样的序列,角度的范围将为(-degrees, +degrees)。

  • resample ({PIL.Image.NEAREST, PIL.Image.BILINEAR, PIL.Image.BICUBIC}, 可选):可选的重采样滤波器。请参阅 链接 以获取更多信息。如果省略或图像的模式为1或P,则设置为 PIL.Image.NEAREST 。默认值: False

  • expand (bool, 可选): 可选的扩展标志。若为真,则扩展输出以使其足够大以容纳整个旋转后的图像;为假或省略,则使输出图像与输入图像的尺寸相同。请注意,扩展标志假定围绕中心旋转且不进行平移。默认值: False

  • center (2-tuple, 可选): 可选的旋转中心,原点是左上角。默认值: 图像的中心。默认值: None

  • fill (n-tuple, int, float, 可选): 旋转后图像之外区域的像素填充值。如果是整数或浮点数,分别用于所有通道。默认情况下,所有通道的值都为0。此选项仅在`pillow>=5.2.0`版本中可用。默认值: None

代码示例:
>>> from jittor import transform
>>> random_rotation = transform.RandomRotation(degrees=45)
>>> rotated_image = random_rotation(input_image)
jittor.transform.RandomSizedCrop

RandomResizedCrop 的别名

class jittor.transform.RandomVerticalFlip(p=0.5)[源代码]

随机垂直翻转图像的类。该类以一定概率沿垂直方向翻转给定的图像。这是数据增强过程中的一个常用技术,旨在提高模型对图像方向变化的鲁棒性。

参数:
  • p (float, 可选): 图像翻转的概率。默认值: 0.5。

代码示例:
>>> from jittor.transform import RandomVerticalFlip
>>> from PIL import Image
>>> random_vflip = RandomVerticalFlip(0.6)
>>> img = Image.open('path/to/image.jpg')
>>> img_transformed = random_vflip(img)
class jittor.transform.Resize(size, mode=2)[源代码]

调整图像尺寸的类。

参数:
  • size (int或tuple): 想要调整到的目标尺寸。

  • mode (int, 可选): 调整尺寸时采用的插值方式。默认为 Image.BILINEAR,即双线性插值。

代码示例:
>>> from jittor import transform
>>> resize_transform = transform.Resize(224)
>>> img_ = resize_transform(img)
class jittor.transform.TenCrop(size, vertical_flip=False)[源代码]

将给定图像裁剪成四个角落和中心部分,以及这些部分的翻转版本(默认为水平翻转,可选择垂直翻转),共十张图片。

参数:
  • size (sequence, int): 裁剪的期望输出大小。如果size是一个整数而不是像(h, w)这样的序列,会进行一个(size, size)的正方形裁剪

  • vertical_flip (bool, 可选): 若为True,则使用垂直翻转。否则使用水平翻转。默认值: False

代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> ten_crop = transform.TenCrop(16)
>>> imgs = ten_crop(img)
>>> imgs[0].size, imgs[1].size, imgs[2].size, imgs[8].size, imgs[9].size 
((16, 16), (16, 16), (16, 16), (16, 16), (16, 16))
class jittor.transform.ToPILImage(mode=None)[源代码]

将张量或ndarray转换为PIL图像。该类将一个C x H x W 的张量或者一个H x W x C 型的numpy ndarray转换成 PIL Image ,同时根据mode调整value的范围。

初始化参数:
  • mode (PIL.Image mode , 可选): PIL图像模式,指定输入数据的颜色空间和像素深度。支持的模式参见PIL文档中 关于图像模式的介绍 。默认值: None

执行参数:
  • pic (Var, numpy.ndarray): 将被转换成PIL image 的 HWC 格式的 image。

代码示例:
>>> from jittor import transform
>>> transform = transform.ToPILImage('RGB')
>>> img_ = transform(img_var)
class jittor.transform.ToTensor[源代码]

将 PIL Image 或 numpy.ndarray 格式的图像转换为 Tensor。

ToTensor 类的实例是一个可调用对象,它可以将 PIL 库中的图像或者 numpy.ndarray 类型的数组转换为 Jittor 的 Tensor 格式。此操作通常用于数据预处理阶段。转换后的 Tensor 数据格式为 C x H x W,并且数据范围被归一化到 [0, 1]。

参数:
  • pic (PIL.Image, numpy.ndarray): 需要转换为 Tensor 的图像对象。如果是 PIL 图像,则应为 L, LA, RGB, RGBA, P, PA, I, I;16, I;16L, I;16B, I;16P, F 等模式之一。如果是 numpy.ndarray,则应为形状为 H x W x C,数据类型为 np.uint8 的数组。

返回值:
  • Var: 转换后的 Tensor,形状为 C x H x W,范围 [0.0, 1.0]。

代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> to_tensor = transform.ToTensor()
>>> tensor = to_tensor(img)
>>> print(tensor.dtype, tensor.shape)
float32 (3, 200, 200)
jittor.transform.adjust_brightness(img, brightness_factor)[源代码]

调整RGB图像的亮度。

参数:
  • img (PIL.Image.Image): 输入图像

  • brightness_factor (float): 调整亮度的程度。可以为任何非负数。0会得到一个黑色的图像,1会得到原始图像,2则会将亮度提高一倍

返回值:

PIL.Image.Image: 亮度调整后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> img_black = jt.transform.adjust_brightness(img, 0) 
>>> img_black.show() # 亮度调整为0,即全黑图
jittor.transform.adjust_contrast(img, contrast_factor)[源代码]

调整 RGB 图像的对比度。

参数:
  • img (Image.Image): 需要调整的图像。

  • contrast_factor (float): 调整对比度的程度。可以是任意非负数。0 会将图像转换为纯灰色,1 保持原图,2 增加两倍对比度。

返回值:

返回调整对比度后的图像。

代码示例:
>>> import numpy as np
>>> from PIL import Image
>>> from jittor import transform
>>> img = np.ones((100, 100, 3)).astype(np.uint8)
>>> img = Image.fromarray(img)
>>> img_adjusted = transform.adjust_contrast(img, 0.5)
jittor.transform.adjust_gamma(img, gamma, gain=1)[源代码]

图像的伽玛校正,也被称为幂律转换。更多详细信息,请参见 WIKI。基于以下公式对RGB模式的强度进行调整:

\[I_{\text{out}} = 255 \times \text{gain} \times (\frac{I_{\text{in}}}{255})^{\gamma}\]
参数:
  • img (PIL.Image.Image): 输入图像

  • gamma (float): 非负实数,即上述公式中的 \(\gamma\) 。 gamma大于1使阴影变暗,gamma小于1使暗区变亮。

  • gain (float, optional): 常数乘数,默认值: 1

返回值:

PIL.Image.Image: 伽马校正后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> jt.transform.adjust_gamma(img, 0.2).show() # 暗区变亮
jittor.transform.adjust_hue(img, hue_factor)[源代码]

调整图像的色调。先将图像转换为HSV空间,并在色调通道(H)中循环移动强度来调整的;然后,再转换回原始图像模式。 hue_factor 是H通道中的移动量,必须在`[-0.5,0.5]`内。更多详细信息,请参见 Hue

参数:
  • img (PIL.Image.Image): 输入图像

  • hue_factor (float): 色调通道移动量。取值应在[-0.5, 0.5]之间。0.5和-0.5分别在HSV空间中以正和负方向给出色调通道的完全反转。0表示无移动。因此,-0.5和0.5都会给出具有互补色的图像,而0则给出原始图像。

返回值:

PIL.Image.Image: 色调调整后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> img_complementary = jt.transform.adjust_hue(img, 0.5) 
>>> img_complementary.show() # 色调反转,即互补色图
jittor.transform.adjust_saturation(img, saturation_factor)[源代码]

调整图像饱和度。

参数:
  • img (PIL.Image.Image): 输入图像

  • saturation_factor (float): 调整饱和度的程度。0将产生黑白图像,1将给出原始图像,2将增强2倍的饱和度

返回值:

PIL.Image.Image: 饱和度调整后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> img_blackwhite = jt.transform.adjust_saturation(img, 0) 
>>> img_blackwhite.show() # 饱和度调整为0,即黑白图
jittor.transform.center_crop(img, output_size)[源代码]

对输入图像在中心处进行裁剪。

参数:
  • img (PIL.Image.Image): 输入图像

  • output_size (int, list) :裁剪框的(高度、宽度)。如果为整数或只有单个整数的序列,则高度和宽度都使用该整数

返回值:

PIL.Image.Image: 裁剪后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> jt.transform.center_crop(img, 100).size 
(100, 100) 
jittor.transform.crop(img, top, left, height, width)[源代码]

对图像进行裁剪,根据给定的边界参数从原始图像中裁剪出一个矩形区域。

参数:
  • img (Image.Image): 输入的 PIL 图像。

  • top (int): 裁剪框的上边界。

  • left (int): 裁剪框的左边界。

  • height (int): 裁剪框的高度。

  • width (int): 裁剪框的宽度。

返回值:
  • 返回裁剪后的图像。

代码示例:
>>> img = np.ones((100, 100, 3)).astype(np.uint8)
>>> img = Image.fromarray(img)
>>> img_cropped = crop(img, 10, 10, 100, 100)
jittor.transform.crop_and_resize(img, top, left, height, width, size, interpolation=2)[源代码]

裁剪后调整图像大小。

参数:
  • img (PIL.Image.Image): 输入图像

  • top (int): 裁剪框的顶部边界

  • left (int): 裁剪框的左边界

  • height (int): 裁剪框的高度

  • width (int): 裁剪框的宽度

  • size (list):裁剪之后图像要调整到的(高度, 宽度)

  • interpolation (int, optional): 调整大小所用的插值方法。默认值: PIL.Image.BILINEAR

返回值:

PIL.Image.Image: 裁剪并且调整大小之后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> # 截取坐标为[10,90]x[10,90]的正方形并且缩小0.5倍
>>> jt.transform.crop_and_resize(img, 10, 10, 80, 80, [40, 40]).size 
(40, 40)
jittor.transform.gray(img, num_output_channels)[源代码]

将任意模式(如 RGB、HSV、LAB 等)的 PIL 图片转换为灰度版本。该函数支持将灰度图像转换为单通道或三通道图像。

参数:
  • img (PIL.Image.Image): 输入的 PIL 图片。

  • num_output_channels (int, 可选): 输出图片的通道数。值可以为 1 或 3。默认值: 1。

返回值:
  • 返回图片的灰度版本。如果 num_output_channels 为 1,返回单通道图像;如果为 3,返回三通道图像,其中 R、G、B 值相同。

代码示例:
>>> import numpy as np
>>> from PIL import Image
>>> from jittor.transform import gray
>>> img = np.ones((100, 100, 3)).astype(np.uint8)
>>> img = Image.fromarray(img)
>>> img_gray_1_channel = gray(img, 1)
>>> print(np.array(img_gray_1_channel).shape)
(100, 100)
>>> img_gray_3_channel = gray(img, 3)
>>> print(np.array(img_gray_3_channel).shape)
(100, 100, 3)
jittor.transform.hflip(img)[源代码]

对给定的图像进行水平翻转。

参数:
  • img (PIL.Image.Image): 输入图像

返回值:

PIL.Image.Image: 水平翻转后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> img_flipped = jt.transform.hflip(img) # 水平翻转
jittor.transform.image_normalize(img, mean, std)[源代码]

对图像进行归一化。

参数:
  • img (PIL Image.Image, jt.Var, np.ndarray): 输入的图像。如果输入的图像类型是 np.ndarray,则它应该具有形状 (C, H, W)

  • mean (list): 归一化的平均值

  • std (list): 归一化的标准差值

返回值:

归一化后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> mean = jt.ones(200,200) / 2
>>> std = jt.ones(200,200) / 2  
>>> jt.transform.image_normalize(img, mean, std)
jittor.transform.pil_to_tensor(pic)

将Image.Image对象转换为格式为CHW的np.array

参数:
  • pic (PIL.Image.Image): 输入图像

返回值:

经格式转换、规范化等操作后的np.array对象

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> arr = jt.transform.to_tensor(img) 
>>> type(arr), arr.shape
(<class 'numpy.ndarray'>, (3, 200, 200))
jittor.transform.resize(img, size, interpolation=2)[源代码]

调整图像的大小。

参数:
  • img (PIL.Image.Image): 输入图像。

  • size (list): 调整后的大小,格式为 [高, 宽]

  • interpolation (int,optional): 调整大小的插值方法类型。默认值: PIL.Image.BILINEAR

返回值:

PIL.Image.Image: 调整后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(3,4)
>>> img = Image.fromarray(data, 'L')                              
>>> img.size
(3, 4)
>>> jt.transform.resize(img, [2,3]).size  
(3, 2)
jittor.transform.to_pil_image(pic, mode=None)[源代码]

将一个jt.Var或np.ndarray转换为PIL Image对象

参数:
  • pic (Var, numpy.ndarray): 需要被转换为PIL Image的图像,应为HWC格式

  • mode (PIL.Image mode, optional): 输入数据的颜色空间和像素深度。默认值:None

返回值:

PIL Image: 转换后的PIL Image

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = jt.transform.to_pil_image(data) 
>>> img.show()
jittor.transform.to_tensor(pic)[源代码]

将Image.Image对象转换为格式为CHW的np.array

参数:
  • pic (PIL.Image.Image): 输入图像

返回值:

经格式转换、规范化等操作后的np.array对象

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> arr = jt.transform.to_tensor(img) 
>>> type(arr), arr.shape
(<class 'numpy.ndarray'>, (3, 200, 200))
jittor.transform.vflip(img)[源代码]

对给定的图像进行垂直翻转。

参数:
  • img (PIL.Image.Image): 输入图像

返回值:

PIL.Image.Image: 垂直翻转后的图像

代码示例:
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> img_vflipped = jt.transform.vflip(img) # 垂直翻转