mindspore-Ecosystem
/
mindspore
21
0
Fork 27
Code Issues Pull Requests 6 Projects Releases Wiki Activity

!31934 Modify mindspore.dataset chinese API contents 

Merge pull request !31934 from 刘勇琪/code_docs_modify_chinese_api
This commit is contained in:
i-robot 2022-03-29 07:20:15 +00:00 committed by Gitee
parent f8ebc03a8d 1469d57ea5
commit 86b4de336b
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
45 changed files with 282 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/api/api_python/dataset_transforms/mindspore.dataset.transforms.c_transforms.Fill.rst
View File

@ -7,7 +7,7 @@ mindspore.dataset.transforms.c_transforms.Fill
**参数：**
- **fill_value** (Union[string, bytes, int, float, bool]) - 用于填充Tensor的值。
- **fill_value** (Union[str, bytes, int, float, bool]) - 用于填充Tensor的值。
**异常：**

4
docs/api/api_python/dataset_transforms/mindspore.dataset.transforms.c_transforms.RandomApply.rst
View File

@ -11,9 +11,9 @@ mindspore.dataset.transforms.c_transforms.RandomApply
- **prob** (float, 可选) - 随机应用某个数据增强的概率，默认值：0.5。
**异常：**
- **TypeError** - 参数 `transforms` 类型不为list。
- **ValueError** - 参数 `transforms` 是空的list。
- **ValueError** - 参数 `transforms` 的长度为空。
- **TypeError** - 参数 `transforms` 的元素不是Python可调用对象或c_transforms模块中的数据处理操作。
- **TypeError** - 参数 `prob` 的类型不为float。
- **ValueError** - 参数 `prob` 的取值范围不为[0.0, 1.0]。

4
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.AutoContrast.rst
View File

@ -7,8 +7,8 @@ mindspore.dataset.vision.c_transforms.AutoContrast
**参数：**
- **cutoff** (float, 可选) - 输入图像直方图中最亮和最暗像素的百分比。该值必须在 [0.0, 50.0) 范围内, 默认值：0.0。
- **ignore** (Union[int, sequence], 可选) - 要忽略的背景像素值，忽略值必须在 [0, 255] 范围内, 默认值：None。
- **cutoff** (float, 可选) - 输入图像直方图中最亮和最暗像素的百分比。该值必须在 [0.0, 50.0) 范围内，默认值：0.0。
- **ignore** (Union[int, sequence], 可选) - 要忽略的背景像素值，忽略值必须在 [0, 255] 范围内，默认值：None。
**异常：**

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.BoundingBoxAugment.rst
View File

@ -3,16 +3,16 @@ mindspore.dataset.vision.c_transforms.BoundingBoxAugment
.. py:class:: mindspore.dataset.vision.c_transforms.BoundingBoxAugment(transform, ratio=0.3)
对图像的标注边界框(bounding box)区域随机应用给定的图像变换处理。
对图像的随机标注边界框区域，应用给定的图像变换处理。
**参数：**
- **transform** (TensorOperation) - 要应用的图像变换处理。
- **ratio** (float, 可选) - 应用图像变换处理的概率。范围：[0, 1], 默认值：0.3。
- **transform** (TensorOperation) - 对图像的随机标注边界框区域应用的变换处理。
- **ratio** (float, 可选) - 要应用变换的边界框的比例。范围：[0.0, 1.0]，默认值：0.3。
**异常：**
- **TypeError** - 如果 `transform` 不是 :class:`mindspore.dataset.vision.c_transforms` 模块中的图像处理操作。
- **TypeError** - 如果 `transform` 不是 :class:`mindspore.dataset.vision.c_transforms` 模块中的图像变换处理。
- **TypeError** - 如果 `ratio` 不是float类型。
- **ValueError** - 如果 `ratio` 不在 [0.0, 1.0] 范围内。
- **RuntimeError** - 如果给定的边界框无效。

4
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.CenterCrop.rst
View File

@ -8,8 +8,8 @@ mindspore.dataset.vision.c_transforms.CenterCrop
**参数：**
- **size** (Union[int, sequence]) - 裁剪区域大小。
如果 size 是整数，则返回大小为 (size, size) 的正方形裁剪。
如果 size 是一个长度为 2 的序列，它应该是 (高度, 宽度)。
如果 `size` 是整数，则返回一个裁剪尺寸大小为 (size, size) 的正方形。
如果 `size` 是一个长度为 2 的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
大小值必须大于 0。
**异常：**

6
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Crop.rst
View File

@ -7,10 +7,10 @@ mindspore.dataset.vision.c_transforms.Crop
**参数：**
- **coordinates** (sequence) - 裁剪区域的起始左上角坐标。 必须是两个值的序列，形式为（上，左）。
- **coordinates** (sequence) - 裁剪区域的起始左上角坐标。 必须是两个值的序列，形式为(上，左)。
- **size** (Union[int, sequence]) - 裁剪区域的大小。
如果 size 是整数，则返回大小为 (size, size) 的正方形裁剪。
如果 size 是一个长度为 2 的序列，它代表 (高度, 宽度)。
如果 `size` 是整数，则返回一个裁剪尺寸大小为 (size, size) 的正方形。
如果 `size` 是一个长度为 2 的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
大小值必须大于 0。
**异常：**

10
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.CutMixBatch.rst
View File

@ -3,14 +3,14 @@ mindspore.dataset.vision.c_transforms.CutMixBatch
.. py:class:: mindspore.dataset.vision.c_transforms.CutMixBatch(image_batch_format, alpha=1.0, prob=1.0)
对输入批次的图像和标签应用剪切混合转换。
请注意，在调用此操作符之前，您需要将标签制作为 one-hot 格式并进行批处理。
对输入批次的图像和标注应用剪切混合转换。
请注意，在调用此操作符之前，您需要将标注制作为 one-hot 格式并进行批处理。
**参数：**
- **image_batch_format** (ImageBatchFormat) - 图像批处理输出格式。可以是 [ImageBatchFormat.NHWC、ImageBatchFormat.NCHW] 中的任何一个。
- **alpha** (float, 可选) - β分布的超参数，必须大于 0, 默认值：1.0。
- **prob** (float, 可选) - 对每个图像应用CutMix处理的概率，范围：[0, 1], 默认值：1.0。
- **alpha** (float, 可选) - β分布的超参数，必须大于0，默认值：1.0。
- **prob** (float, 可选) - 对每个图像应用剪切混合处理的概率，范围：[0.0, 1.0]，默认值：1.0。
**异常：**
@ -18,5 +18,5 @@ mindspore.dataset.vision.c_transforms.CutMixBatch
- **TypeError** - 如果 `alpha` 不是float类型。
- **TypeError** - 如果 `prob` 不是 float 类型。
- **ValueError** - 如果 `alpha` 小于或等于 0。
- **ValueError** - 如果 `prob` 不在 [0, 1] 范围内。
- **ValueError** - 如果 `prob` 不在 [0.0, 1.0] 范围内。
- **RuntimeError** - 如果输入图像的shape不是 <H, W, C>。

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.CutOut.rst
View File

@ -8,7 +8,7 @@ mindspore.dataset.vision.c_transforms.CutOut
**参数：**
- **length** (int) - 每个正方形区域的边长，必须大于 0。
- **num_patches** (int, 可选) - 要从图像中切出的正方形区域数，必须大于0, 默认值：1。
- **num_patches** (int, 可选) - 要从图像中切出的正方形区域数，必须大于0，默认值：1。
**异常：**

5
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Decode.rst
View File

@ -3,12 +3,11 @@ mindspore.dataset.vision.c_transforms.Decode
.. py:class:: mindspore.dataset.vision.c_transforms.Decode(rgb=True)
以 RGB 模式（默认）或 BGR 模式（选项已弃用）解码输入图像。
对输入图像进行解码。
**参数：**
- **rgb** (bool，可选) - 解码输入图像的模式, 默认值：True。
如果 True 表示解码图像的格式为 RGB，否则为 BGR（选项已弃用）。
- **rgb** (bool，可选) - 解码输入图像的模式。若为True，将输入解码为RGB图像；否则为BGR图像(已弃用)。默认值：True。
**异常：**

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Equalize.rst
View File

@ -3,7 +3,7 @@ mindspore.dataset.vision.c_transforms.Equalize
.. py:class:: mindspore.dataset.vision.c_transforms.Equalize()
对输入图像应用直方图均衡。
对输入图像进行直方图均衡化。
**异常：**

14
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.GaussianBlur.rst
View File

@ -8,17 +8,17 @@ mindspore.dataset.vision.c_transforms.GaussianBlur
**参数：**
- **kernel_size** (Union[int, sequence]) - 要使用的高斯核的大小。该值必须是正数和奇数。
如果只提供一个整数，内核大小将为 (size, size)。
如果只提供一个整数，高斯核大小将为 (kernel_size, kernel_size)。
如果提供了整数序列，则它必须是表示（宽度、高度）的 2 个值的序列。
- **sigma** (Union[float, sequence], 可选) - 要使用的高斯核的标准差, 默认值：None。该值必须是正数。
如果仅提供浮点数，则 sigma 将为 (sigma, sigma)。
如果提供了一系列浮点数，则它必须是代表宽度和高度的 sigma 的 2 个值的序列。
如果为None，sigma采用的值为 ((kernel_size - 1) * 0.5 - 1) * 0.3 + 0.8。
- **sigma** (Union[float, sequence], 可选) - 要使用的高斯核的标准差，该值必须是正数，默认值：None。
如果仅提供浮点数，则 `sigma` 将为 (sigma, sigma)。
如果提供了浮点序列，则它必须是表示（宽度、高度）的 2 个值的序列。
如果为None， `sigma` 采用的值为 ((kernel\underline{} size - 1) * 0.5 - 1) * 0.3 + 0.8。
**异常：**
- **TypeError** - 如果 `kernel_size` 不是整型或整型序列类型。
- **TypeError** - 如果 `sigma` 不是浮点或浮点序列类型。
- **TypeError** - 如果 `kernel_size` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `sigma` 不是float或Sequence[float]类型。
- **ValueError** - 如果 `kernel_size` 不是正数和奇数。
- **ValueError** - 如果 `sigma` 不是正数。
- **RuntimeError** - 如果输入图像的shape不是 <H, W> 或 <H, W, C>。

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.HWC2CHW.rst
View File

@ -3,7 +3,7 @@ mindspore.dataset.vision.c_transforms.HWC2CHW
.. py:class:: mindspore.dataset.vision.c_transforms.HWC2CHW()
将输入图像从形状 (H, W, C) 转置为形状 (C, H, W)。 输入图像应为 3 通道图像。
将输入图像的shape从 <H, W, C> 转换为 <C, H, W>。输入图像应为 3 通道图像。
**异常：**

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Invert.rst
View File

@ -3,7 +3,7 @@ mindspore.dataset.vision.c_transforms.Invert
.. py:class:: mindspore.dataset.vision.c_transforms.Invert()
在 RGB 模式下对输入图像应用像素反转, 计算方式为（255 - pixel）。
在 RGB 模式下对输入图像应用像素反转，计算方式为（255 - pixel）。
**异常：**

6
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.MixUpBatch.rst
View File

@ -3,11 +3,11 @@ mindspore.dataset.vision.c_transforms.MixUpBatch
.. py:class:: mindspore.dataset.vision.c_transforms.MixUpBatch(alpha=1.0)
对输入批次的图像和标签应用混合转换。从批处理中随机抽取两个图像，其中一个图像乘以随机权重 (lambda)，另一个图像乘以 (1 - lambda), 并相加。该处理将会同时应用于label。
对输入批次的图像和标注应用混合转换。从批处理中随机抽取两个图像，其中一个图像乘以随机权重 (lambda)，另一个图像乘以 (1 - lambda)，并相加。该处理将会同时应用于one-hot标注。
上述的 lambda 是根据指定的参数 `alpha` 生成的。 计算方式为在 [alpha, 1] 范围内随机生成两个系数 x1，x2 ，然后 lambda = (x1 / (x1 + x2))。
上述的 lambda 是根据指定的参数 `alpha` 生成的。计算方式为在 [alpha, 1] 范围内随机生成两个系数 x1，x2 ，然后 lambda = (x1 / (x1 + x2))。
请注意，在调用此处理之前，您需要将label制作成 one-hot 格式并进行batch操作。
请注意，在调用此处理之前，您需要将标注制作成 one-hot 格式并进行batch操作。
**参数：**

5
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Normalize.rst
View File

@ -4,12 +4,13 @@ mindspore.dataset.vision.c_transforms.Normalize
.. py:class:: mindspore.dataset.vision.c_transforms.Normalize(mean, std)
根据均值和标准差对输入图像进行归一化。
此处理将使用以下公式对输入图像进行归一化：output[channel] = (input[channel] - mean[channel]) / std[channel]，其中 channel 代表通道索引，channel >= 1。
**参数：**
- **mean** (sequence) - 图像每个通道的均值组成的列表或元组。 平均值必须在 [0.0, 255.0] 范围内。
- **std** (sequence) - 图像每个通道的标准差组成的列表或元组。 标准偏差值必须在 (0.0, 255.0] 范围内。
- **mean** (sequence) - 图像每个通道的均值组成的列表或元组。平均值必须在 [0.0, 255.0] 范围内。
- **std** (sequence) - 图像每个通道的标准差组成的列表或元组。标准差值必须在 (0.0, 255.0] 范围内。
**异常：**

10
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.NormalizePad.rst
View File

@ -3,13 +3,13 @@ mindspore.dataset.vision.c_transforms.NormalizePad
.. py:class:: mindspore.dataset.vision.c_transforms.NormalizePad(mean, std, dtype="float32")
根据均值和标准差对输入图像进行归一化，然后用零值填充一个额外的通道。
根据均值和标准差对输入图像进行归一化，然后填充一个全零的额外通道。
**参数：**
- **mean** (sequence) - 图像每个通道的均值组成的列表或元组。 平均值必须在 (0.0, 255.0] 范围内。
- **std** (sequence) - 图像每个通道的标准差组成的列表或元组。 标准偏差值必须在 (0.0, 255.0] 范围内。
- **dtype** (str, 可选) - 设置归一化图像的输出数据类型, 默认值："float32"。
- **mean** (sequence) - 图像每个通道的均值组成的列表或元组。平均值必须在 (0.0, 255.0] 范围内。
- **std** (sequence) - 图像每个通道的标准差组成的列表或元组。标准差值必须在 (0.0, 255.0] 范围内。
- **dtype** (str, 可选) - 输出图像的数据类型，默认值："float32"。
**异常：**
@ -17,5 +17,5 @@ mindspore.dataset.vision.c_transforms.NormalizePad
- **TypeError** - 如果 `std` 不是sequence类型。
- **TypeError** - 如果 `dtype` 不是str类型。
- **ValueError** - 如果 `mean` 不在 [0.0, 255.0] 范围内。
- **ValueError** - 如果 `mean` 不在范围内 (0.0, 255.0]。
- **ValueError** - 如果 `std` 不在范围内 (0.0, 255.0]。
- **RuntimeError** - 如果输入图像的shape不是 <H, W, C>。

12
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Pad.rst
View File

@ -3,20 +3,20 @@ mindspore.dataset.vision.c_transforms.Pad
.. py:class:: mindspore.dataset.vision.c_transforms.Pad(padding, fill_value=0, padding_mode=Border.CONSTANT)
根据填充参数填充图像。
填充图像。
**参数：**
- **padding** (Union[int, sequence]) - 填充图像的像素数。
- **padding** (Union[int, sequence]) - 图像各边填充的像素数。
如果 `padding` 是一个整数，代表为图像的所有方向填充该值大小的像素。
如果 `padding` 是一个包含2个值的元组或列表，第一个值会用于填充图像的左侧和上侧，第二个值会用于填充图像的右侧和下侧。
如果 `padding` 是一个包含4个值的元组或列表，则分别填充图像的左侧、上侧、右侧和下侧。
填充值必须为非负值。
- **fill_value** (Union[int, tuple], 可选) - 填充的像素值，仅在 `padding_mode` 取值为Border.CONSTANT时有效。
如果是3元组，则分别用于填充R、G、B通道。
如果是3元素元组，则分别用于填充R、G、B通道。
如果是整数，则用于所有 RGB 通道。
`fill_value` 值必须在 [0, 255] 范围内, 默认值：0。
- **padding_mode** (Border, 可选) - 边界填充方式, 默认值：Border.CONSTANT。可以是 [Border.CONSTANT、Border.EDGE、Border.REFLECT、Border.SYMMETRIC] 中的任何一个。
- **padding_mode** (Border, 可选) - 边界填充方式。可以是 [Border.CONSTANT、Border.EDGE、Border.REFLECT、Border.SYMMETRIC] 中的任何一个，默认值：Border.CONSTANT。
- **Border.CONSTANT** - 使用常量值进行填充。
- **Border.EDGE** - 使用各边的边界像素值进行填充。
@ -25,8 +25,8 @@ mindspore.dataset.vision.c_transforms.Pad
**异常：**
- **TypeError** - 如果 `padding` 不是整型或整型序列类型。
- **TypeError** - 如果 `fill_value` 不是整型或整型元组类型。
- **TypeError** - 如果 `padding` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `fill_value` 不是int或Tuple[int]类型。
- **TypeError** - 如果 `padding_mode` 不是 :class:`mindspore.dataset.vision.Border` 的类型。
- **ValueError** - 如果 `padding` 为负数。
- **ValueError** - 如果 `fill_value` 不在 [0, 255] 范围内。

34
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomAffine.rst
View File

@ -8,35 +8,35 @@ mindspore.dataset.vision.c_transforms.RandomAffine
**参数：**
- **degrees** (Union[int, float, sequence]) - 旋转度数的范围。
如果 `degrees` 是一个数字，它代表旋转范围是（-degrees，degrees）。
如果 `degrees` 是一个数字，它代表旋转范围是(-degrees, degrees)。
如果 `degrees` 是一个序列，它代表旋转是 (min, max)。
- **translate** (sequence, 可选) - 一个序列(tx_min, tx_max, ty_min, ty_max)用于表示水平（tx）方向和垂直（ty）方向的最小/最大平移范围，取值范围 [-1.0, 1.0], 默认值：None。
- **translate** (sequence, 可选) - 一个序列(tx_min, tx_max, ty_min, ty_max)用于表示水平(tx)方向和垂直(ty)方向的最小/最大平移范围，取值范围 [-1.0, 1.0]，默认值：None。
水平和垂直偏移分别从以下范围中随机选择：(tx_min*width, tx_max*width) 和 (ty_min*height, ty_max*height)。
如果 `translate` 是一个包含2个值的元组或列表，则 (translate[0], translate[1]) 表示水平（X）方向的随机平移范围。
如果 `translate` 是一个包含4个值的元组或列表，则 (translate[0], translate[1]) 表示水平（X）方向的随机平移范围, (translate[2], translate[3]) 表示垂直（Y）方向的随机平移范围。
如果为空，则不对图像进行任何平移。
- **scale** (sequence, 可选) - 图像的比例因子的随机范围，必须为非负数, 默认值：None，使用原始比例。
- **shear** (Union[int, float, sequence], 可选) - 图像的剪切因子的随机范围，必须为正数, 默认值：None。
如果 `translate` 是一个包含2个值的元组或列表，则 (translate[0], translate[1]) 表示水平(X)方向的随机平移范围。
如果 `translate` 是一个包含4个值的元组或列表，则 (translate[0], translate[1]) 表示水平(X)方向的随机平移范围，(translate[2], translate[3])表示垂直(Y)方向的随机平移范围。
如果为None，则不对图像进行任何平移。
- **scale** (sequence, 可选) - 图像的比例因子的随机范围，必须为非负数，使用原始比例，默认值：None。
- **shear** (Union[int, float, sequence], 可选) - 图像的剪切因子的随机范围，必须为正数，默认值：None。
如果是数字，则应用在 (-shear, +shear) 范围内平行于 X 轴的剪切。
如果 `shear` 是一个包含2个值的元组或列表，则在 (shear[0],shear[1]) 范围内进行水平（X）方向的剪切变换。
如果 `shear` 是一个包含4个值的元组或列表，则在 (shear[0],shear[1]) 范围内进行水平（X）方向的剪切变换, 并在(shear[2], shear[3]) 范围内进行垂直（Y）方向的剪切变换。
如果为空，则不应用任何剪切。
- **resample** (Inter, 可选) - 图像插值方式, 默认值：Inter.NEAREST。它可以是 [Inter.BILINEAR、Inter.NEAREST、Inter.BICUBIC] 中的任何一个。
如果 `shear` 是一个包含2个值的元组或列表，则在 (shear[0],shear[1]) 范围内进行水平(X)方向的剪切变换。
如果 `shear` 是一个包含4个值的元组或列表，则在 (shear[0],shear[1]) 范围内进行水平(X)方向的剪切变换，并在(shear[2], shear[3])范围内进行垂直(Y)方向的剪切变换。
如果为None，则不应用任何剪切。
- **resample** (Inter, 可选) - 图像插值方式。它可以是 [Inter.BILINEAR、Inter.NEAREST、Inter.BICUBIC] 中的任何一个，默认值：Inter.NEAREST。
- **Inter.BILINEAR**: 双线性插值。
- **Inter.NEAREST**: 最近邻插值。
- **Inter.BICUBIC**: 双三次插值。
- **fill_value** (Union[int, tuple], 可选) - 用于填充输出图像中变换之外的区域。元组中必须有三个值，取值范围是[0, 255], 默认值：0。
- **fill_value** (Union[int, tuple], 可选) - 用于填充输出图像中变换之外的区域。元组中必须有三个值，取值范围是[0, 255]，默认值：0。
**异常：**
- **TypeError** - 如果 `degrees` 不是整型、浮点或序列类型。
- **TypeError** - 如果 `translate` 不是序列类型。
- **TypeError** - 如果 `scale` 不是序列类型。
- **TypeError** - 如果 `shear` 不是整型、浮点或序列类型。
- **TypeError** - 如果 `degrees` 不是int、float或sequence类型。
- **TypeError** - 如果 `translate` 不是sequence类型。
- **TypeError** - 如果 `scale` 不是sequence类型。
- **TypeError** - 如果 `shear` 不是int、float或sequence类型。
- **TypeError** - 如果 `resample` 不是 :class:`mindspore.dataset.vision.Inter` 的类型。
- **TypeError** - 如果 `fill_value` 不是整型或整型元组类型。
- **TypeError** - 如果 `fill_value` 不是int或Tuple[int]类型。
- **ValueError** - 如果 `degrees` 为负数。
- **ValueError** - 如果 `translate` 不在范围 [-1.0, 1.0] 内。
- **ValueError** - 如果 `scale` 为负数。

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomColor.rst
View File

@ -3,15 +3,15 @@ mindspore.dataset.vision.c_transforms.RandomColor
.. py:class:: mindspore.dataset.vision.c_transforms.RandomColor(degrees=(0.1, 1.9))
随机调整输入图像的颜色。此操作仅适用于 3 通道彩色图像。
随机调整输入图像的颜色。此操作仅适用于 3 通道RGB图像。
**参数：**
- **degrees** (sequence, 可选) - 随机颜色调整度数的范围，必须为非负数。 它应该是（min, max）格式。
如果min=max，则代表颜色变化步长固定, 默认值：（0.1，1.9）。
- **degrees** (sequence, 可选) - 色彩调节系数的范围，必须为非负数。它应该是(min, max)格式。
如果min与max相等，则代表色彩变化步长固定，默认值：(0.1，1.9)。
**异常：**
- **TypeError** - 如果 `degrees` 不是浮点序列类型。
- **TypeError** - 如果 `degrees` 不是Sequence[float]类型。
- **ValueError** - 如果 `degrees` 为负数。
- **RuntimeError** - 如果输入图像的shape不是 <H, W, C>。

26
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomColorAdjust.rst
View File

@ -7,25 +7,25 @@ mindspore.dataset.vision.c_transforms.RandomColorAdjust
**参数：**
- **brightness** (Union[float, list, tuple], 可选) - 亮度调整因子, 默认值：(1, 1)。不能为负。
- **brightness** (Union[float, list, tuple], 可选) - 亮度调整因子。不能为负，默认值：(1, 1)。
如果是浮点数，则从 [max(0, 1-brightness), 1+brightness] 范围内统一选择因子。
如果它是一个序列，则代表是范围 [min, max], 从此范围中选择调整因子。
- **contrast** (Union[float, list, tuple], 可选) - 对比度调整因子, 默认值：(1, 1)。不能为负。
如果它是一个序列，则代表是范围 [min, max]，从此范围中选择调整因子。
- **contrast** (Union[float, list, tuple], 可选) - 对比度调整因子。不能为负，默认值：(1, 1)。
如果是浮点数，则从 [max(0, 1-contrast), 1+contrast] 范围内统一选择因子。
如果它是一个序列，则代表是范围 [min, max], 从此范围中选择调整因子。
- **saturation** (Union[float, list, tuple], 可选) - 饱和度调整因子, 默认值：(1, 1)。不能为负。
如果它是一个序列，则代表是范围 [min, max]，从此范围中选择调整因子。
- **saturation** (Union[float, list, tuple], 可选) - 饱和度调整因子。不能为负，默认值：(1, 1)。
如果是浮点数，则从 [max(0, 1-saturation), 1+saturation] 范围内统一选择因子。
如果它是一个序列，则代表是范围 [min, max], 从此范围中选择调整因子。
- **hue** (Union[float, list, tuple], 可选) - 色调调整因子, 默认值：(0, 0)。
如果是浮点数，则代表是范围 [-hue, hue], 从此范围中选择调整因子。注意取值应为 0 <= `hue` <= 0.5。
如果它是一个序列，则代表是范围 [min, max], 从此范围中选择调整因子。注意取值范围是 -0.5 <= min <= max <= 0.5。
如果它是一个序列，则代表是范围 [min, max]，从此范围中选择调整因子。
- **hue** (Union[float, list, tuple], 可选) - 色调调整因子，默认值：(0, 0)。
如果是浮点数，则代表是范围 [-hue, hue]，从此范围中选择调整因子。注意 `hue` 取值应为[0, 0.5]。
如果它是一个序列，则代表是范围 [min, max]，从此范围中选择调整因子。注意取值范围min和max是 [-0.5, 0.5] 范围内的浮点数，并且min小于等于max。
**异常：**
- **TypeError** - 如果 `brightness` 不是浮点或浮点序列类型。
- **TypeError** - 如果 `contrast` 不是浮点或浮点序列类型。
- **TypeError** - 如果 `saturation` 不是浮点或浮点序列类型。
- **TypeError** - 如果 `hue` 不是浮点或浮点序列类型。
- **TypeError** - 如果 `brightness` 不是float或Sequence[float]类型。
- **TypeError** - 如果 `contrast` 不是float或Sequence[float]类型。
- **TypeError** - 如果 `saturation` 不是float或Sequence[float]类型。
- **TypeError** - 如果 `hue` 不是float或Sequence[float]类型。
- **ValueError** - 如果 `brightness` 为负数。
- **ValueError** - 如果 `contrast` 为负数。
- **ValueError** - 如果 `saturation` 为负数。

26
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomCrop.rst
View File

@ -9,20 +9,20 @@ mindspore.dataset.vision.c_transforms.RandomCrop
**参数：**
- **size** (Union[int, sequence]) - 裁剪图像的输出大小。大小值必须为正。
如果 size 是整数，则返回大小为 (size, size) 的正方形裁剪。
如果 size 是一个长度为 2 的序列，它应该是 (高度, 宽度)。
- **padding** (Union[int, sequence], 可选) - 填充图像的像素数。填充值必须为非负值, 默认值：None。
- **size** (Union[int, sequence]) - 裁剪图像的输出尺寸大小。大小值必须为正。
如果 size 是整数，则返回一个裁剪尺寸大小为 (size, size) 的正方形。
如果 size 是一个长度为 2 的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **padding** (Union[int, sequence], 可选) - 图像各边填充的像素数。填充值必须为非负值，默认值：None。
如果 `padding` 不为 None，则首先使用 `padding` 填充图像。
如果 `padding` 是一个整数，代表为图像的所有方向填充该值大小的像素。
如果 `padding` 是一个包含2个值的元组或列表，第一个值会用于填充图像的左侧和上侧，第二个值会用于填充图像的右侧和下侧。
如果 `padding` 是一个包含4个值的元组或列表，则分别填充图像的左侧、上侧、右侧和下侧。
- **pad_if_needed** (bool, 可选) - 如果输入图像高度或者宽度小于 `size` 指定的输出图像大小，是否进行填充。默认值：False，不填充。
- **fill_value** (Union[int, tuple], 可选) - 边框的像素强度，仅对padding_mode Border.CONSTANT有效。
如果是3元组，则分别用于填充R、G、B通道。
- **pad_if_needed** (bool, 可选) - 如果输入图像高度或者宽度小于 `size` 指定的输出图像大小，是否进行填充。默认值：False。
- **fill_value** (Union[int, tuple], 可选) - 边框的像素强度，仅当 `padding_mode` 为 Border.CONSTANT 时有效。
如果是3元素元组，则分别用于填充R、G、B通道。
如果是整数，则用于所有RGB通道。
fill_value 值必须在 [0, 255] 范围内, 默认值：0。
- **padding_mode** (Border, 可选) - 边界填充方式, 默认值：Border.CONSTANT。它可以是 [Border.CONSTANT、Border.EDGE、Border.REFLECT、Border.SYMMETRIC] 中的任何一个。
`fill_value` 值必须在 [0, 255] 范围内，默认值：0。
- **padding_mode** (Border, 可选) - 边界填充方式。它可以是 [Border.CONSTANT、Border.EDGE、Border.REFLECT、Border.SYMMETRIC] 中的任何一个，默认值：Border.CONSTANT。
- **Border.CONSTANT** - 使用常量值进行填充。
- **Border.EDGE** - 使用各边的边界像素值进行填充。
@ -31,10 +31,10 @@ mindspore.dataset.vision.c_transforms.RandomCrop
**异常：**
- **TypeError** - 如果 `size` 不是整型或整型序列类型。
- **TypeError** - 如果 `padding` 不是整型或整型序列类型。
- **TypeError** - 如果 `pad_if_needed` 不是布尔类型。
- **TypeError** - 如果 `fill_value` 不是整型或整型序列类型。
- **TypeError** - 如果 `size` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `padding` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `pad_if_needed` 不是bool类型。
- **TypeError** - 如果 `fill_value` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `padding_mode` 不是 :class:`mindspore.dataset.vision.Border` 的类型。
- **ValueError** - 如果 `size` 不是正数。
- **ValueError** - 如果 `padding` 为负数。

25
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomCropDecodeResize.rst
View File

@ -3,16 +3,16 @@ mindspore.dataset.vision.c_transforms.RandomCropDecodeResize
.. py:class:: mindspore.dataset.vision.c_transforms.RandomCropDecodeResize(size, scale=(0.08, 1.0), ratio=(3. / 4., 4. / 3.), interpolation=Inter.BILINEAR, max_attempts=10)
"裁剪"、"解码"和"调整大小"的组合处理。该算子将在随机位置裁剪输入图像，以 RGB 模式对裁剪后的图像进行解码，并调整解码图像的大小。针对 JPEG 图像进行了优化, 可以获得更好的性能。
"裁剪"、"解码"和"调整尺寸大小"的组合处理。该算子将在随机位置裁剪输入图像，以 RGB 模式对裁剪后的图像进行解码，并调整解码图像的尺寸大小。针对 JPEG 图像进行了优化, 可以获得更好的性能。
**参数：**
- **size** (Union[int, sequence]) - 调整后图像的输出大小。大小值必须为正。
如果 size 是整数，则返回大小为 (size, size) 的正方形裁剪。
如果 size 是一个长度为 2 的序列，它应该是 (高度, 宽度)。
- **scale** (list, tuple, 可选) - 要裁剪的原始大小的各个大小的范围[min, max)，必须为非负数, 默认值：（0.08, 1.0）。
- **ratio** (list, tuple, 可选) - 宽高比的范围 [min, max) 裁剪，必须为非负数, 默认值：(3. / 4., 4. / 3.)。
- **interpolation** (Inter, 可选) - resize算子的图像插值模式, 默认值：Inter.BILINEAR。它可以是 [Inter.BILINEAR、Inter.NEAREST、Inter.BICUBIC、Inter.AREA、Inter.PILCUBIC] 中的任何一个。
- **size** (Union[int, sequence]) - 调整后图像的输出尺寸大小。大小值必须为正。
如果 size 是整数，则返回一个裁剪尺寸大小为 (size, size) 的正方形。
如果 size 是一个长度为 2 的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **scale** (Union[list, tuple], 可选) - 要裁剪的原始尺寸大小的各个尺寸的范围[min, max)，必须为非负数，默认值：(0.08, 1.0)。
- **ratio** (Union[list, tuple], 可选) - 宽高比的范围 [min, max) 裁剪，必须为非负数，默认值：(3. / 4., 4. / 3.)。
- **interpolation** (Inter, 可选) - resize算子的图像插值方式。它可以是 [Inter.BILINEAR、Inter.NEAREST、Inter.BICUBIC、Inter.AREA、Inter.PILCUBIC] 中的任何一个，默认值：Inter.BILINEAR。
- **Inter.BILINEAR**: 双线性插值。
- **Inter.NEAREST**: 最近邻插值。
@ -20,16 +20,15 @@ mindspore.dataset.vision.c_transforms.RandomCropDecodeResize
- **Inter.AREA**: 像素区域插值。
- **Inter.PILCUBIC**: Pillow库中实现的双三次插值，输入需为3通道格式。
- **max_attempts** (int, 可选) - 提出有效crop_area 的最大尝试次数, 默认值：10。
如果超过，则回退到使用 center_crop 代替。 max_attempts 值必须为正数。
- **max_attempts** (int, 可选) - 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪， `max_attempts` 值必须为正数，默认值：10。
**异常：**
- **TypeError** - 如果 `size` 不是整型或整型序列类型。
- **TypeError** - 如果 `scale` 不是元组类型。
- **TypeError** - 如果 `ratio` 不是元组类型。
- **TypeError** - 如果 `size` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `scale` 不是tuple或list类型。
- **TypeError** - 如果 `ratio` 不是tuple或list类型。
- **TypeError** - 如果 `interpolation` 不是 :class:`mindspore.dataset.vision.Inter` 的类型。
- **TypeError** - 如果 `max_attempts` 不是整型类型。
- **TypeError** - 如果 `max_attempts` 不是int类型。
- **ValueError** - 如果 `size` 不是正数。
- **ValueError** - 如果 `scale` 为负数。
- **ValueError** - 如果 `ratio` 为负数。

28
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomCropWithBBox.rst
View File

@ -3,24 +3,24 @@ mindspore.dataset.vision.c_transforms.RandomCropWithBBox
.. py:class:: mindspore.dataset.vision.c_transforms.RandomCropWithBBox(size, padding=None, pad_if_needed=False, fill_value=0, padding_mode=Border.CONSTANT)
对输入图像进行随机位置裁剪并相应地调整边界框。
在输入图像的随机位置进行裁剪并相应地调整边界框。
**参数：**
- **size** (Union[int, sequence]) - 裁剪图像的输出大小。大小值必须为正。
如果 size 是整数，则返回大小为 (size, size) 的正方形裁剪。
如果 size 是一个长度为 2 的序列，它应该是 (高度, 宽度)。
- **padding** (Union[int, sequence], 可选) - 填充图像的像素数。填充值必须非负值, 默认值：None。
- **size** (Union[int, sequence]) - 裁剪图像的输出尺寸大小。大小值必须为正。
如果 size 是整数，则返回一个裁剪尺寸大小为 (size, size) 的正方形。
如果 size 是一个长度为 2 的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **padding** (Union[int, sequence], 可选) - 填充图像的像素数。填充值必须非负值，默认值：None。
如果 `padding` 不为 None，则首先使用 `padding` 填充图像。
如果 `padding` 是一个整数，代表为图像的所有方向填充该值大小的像素。
如果 `padding` 是一个包含2个值的元组或列表，第一个值会用于填充图像的左侧和上侧，第二个值会用于填充图像的右侧和下侧。
如果 `padding` 是一个包含4个值的元组或列表，则分别填充图像的左侧、上侧、右侧和下侧。
- **pad_if_needed** (bool, 可选) - 如果输入图像高度或者宽度小于 `size` 指定的输出图像大小，是否进行填充。默认值：False，不填充。
- **fill_value** (Union[int, tuple], 可选) - 边框的像素强度，仅对padding_mode Border.CONSTANT有效。
如果是3元组，则分别用于填充R、G、B通道。
- **pad_if_needed** (bool, 可选) - 如果输入图像高度或者宽度小于 `size` 指定的输出图像大小，是否进行填充。默认值：False。
- **fill_value** (Union[int, tuple], 可选) - 边框的像素强度，仅当 `padding_mode` 为 Border.CONSTANT 时有效。
如果是3元素元组，则分别用于填充R、G、B通道。
如果是整数，则用于所有 RGB 通道。
fill_value 值必须在 [0, 255] 范围内, 默认值：0。
- **padding_mode** (Border, 可选) - 边界填充方式, 默认值：Border.CONSTANT。它可以是 [Border.CONSTANT、Border.EDGE、Border.REFLECT、Border.SYMMETRIC] 中的任何一个。
`fill_value` 值必须在 [0, 255] 范围内，默认值：0。
- **padding_mode** (Border, 可选) - 边界填充方式。它可以是 [Border.CONSTANT、Border.EDGE、Border.REFLECT、Border.SYMMETRIC] 中的任何一个，默认值：Border.CONSTANT。
- **Border.CONSTANT** - 使用常量值进行填充。
- **Border.EDGE** - 使用各边的边界像素值进行填充。
@ -29,10 +29,10 @@ mindspore.dataset.vision.c_transforms.RandomCropWithBBox
**异常：**
- **TypeError** - 如果 `size` 不是整型或整型序列类型。
- **TypeError** - 如果 `padding` 不是整型或整型序列类型。
- **TypeError** - 如果 `pad_if_needed` 不是布尔类型。
- **TypeError** - 如果 `fill_value` 不是整型或整型序列类型。
- **TypeError** - 如果 `size` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `padding` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `pad_if_needed` 不是bool类型。
- **TypeError** - 如果 `fill_value` 不是int或Sequence[int]类型。
- **TypeError** - 如果 `padding_mode` 不是 :class:`mindspore.dataset.vision.Border` 的类型。
- **ValueError** - 如果 `size` 不是正数。
- **ValueError** - 如果 `padding` 为负数。

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomHorizontalFlip.rst
View File

@ -3,7 +3,7 @@ mindspore.dataset.vision.c_transforms.RandomHorizontalFlip
.. py:class:: mindspore.dataset.vision.c_transforms.RandomHorizontalFlip(prob=0.5)
以给定的概率水平随机翻转输入图像。
对输入图像按给定的概率进行水平随机翻转。
**参数：**

4
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomHorizontalFlipWithBBox.rst
View File

@ -3,11 +3,11 @@ mindspore.dataset.vision.c_transforms.RandomHorizontalFlipWithBBox
.. py:class:: mindspore.dataset.vision.c_transforms.RandomHorizontalFlipWithBBox(prob=0.5)
以给定的概率水平随机翻转输入图像并相应地调整边界框。
对输入图像按给定的概率进行水平随机翻转并相应地调整边界框。
**参数：**
- **prob** (float, 可选) - 图像被翻转的概率，必须在 [0, 1] 范围内, 默认值：0.5。
- **prob** (float, 可选) - 图像被翻转的概率，必须在 [0, 1] 范围内，默认值：0.5。
**异常：**

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomPosterize.rst
View File

@ -3,15 +3,15 @@ mindspore.dataset.vision.c_transforms.RandomPosterize
.. py:class:: mindspore.dataset.vision.c_transforms.RandomPosterize(bits=(8, 8))
随机减少输入图像每个颜色通道的位数。
随机减少输入图像每个RGB通道的位数。
**参数：**
- **bits** (float, 可选) - 随机位数压缩的范围。位值必须在 [1,8] 范围内，并且在给定范围内至少包含一个整数值。它必须是 (min, max) 或整数格式。
如果min=max，那么它是一个单一的位数压缩操作, 默认值：(8, 8)。
- **bits** (Union[int, Sequence[int]], 可选) - 随机位数压缩的范围。位值必须在 [1,8] 范围内，并且在给定范围内至少包含一个整数值。它必须是 (min, max) 或整数格式。
如果min与max相等，那么它是一个单一的位数压缩操作，默认值：(8, 8)。
**异常：**
- **TypeError** - 如果 `bits` 不是整型或整型序列类型。
- **TypeError** - 如果 `bits` 不是int或Sequence[int]类型。
- **ValueError** - 如果 `bits` 不在 [1, 8] 范围内。
- **RuntimeError** - 如果输入图像的shape不是 <H, W> 或 <H, W, C>。

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomResize.rst
View File

@ -3,16 +3,14 @@ mindspore.dataset.vision.c_transforms.RandomResize
.. py:class:: mindspore.dataset.vision.c_transforms.RandomResize(size)
使用随机选择的插值模式调整输入图像的大小。
对输入图像使用随机选择的 :class:`mindspore.dataset.vision.Inter` 插值方式去调整它的尺寸大小。
**参数：**
- **size** (Union[int, sequence]) - 调整后图像的输出大小。 大小值必须为正。
如果 size 是整数，则图像的较小边缘将调整为具有相同图像纵横比的该值。
如果 size 是一个长度为 2 的序列，它应该是 (高度, 宽度)。
- **size** (Union[int, sequence]) - 调整后图像的输出尺寸大小。大小值必须为正。若输入整型，则放缩至(size, size)大小；若输入2元素序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
**异常：**
- **TypeError** - 如果 `size` 不是整型或整型序列类型。
- **TypeError** - 如果 `size` 不是int或Sequence[int]类型。
- **ValueError** - 如果 `size` 不是正数。
- **RuntimeError** - 如果输入图像的shape不是 <H, W> 或 <H, W, C>。

6
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomResizeWithBBox.rst
View File

@ -3,14 +3,14 @@ mindspore.dataset.vision.c_transforms.RandomResizeWithBBox
.. py:class:: mindspore.dataset.vision.c_transforms.RandomResizeWithBBox(size)
使用随机选择的插值模式来调整输入图像的大小，并相应地调整边界框的大小。
对输入图像使用随机选择的 :class:`mindspore.dataset.vision.Inter` 插值方式去调整它的尺寸大小，并相应地调整边界框的尺寸大小。
**参数：**
- **size** (Union[int, sequence]) - 调整后图像的输出大小。如果 `size` 是一个整数，图像的短边将被调整为 `size` 大小，并依据短边的调整比例相应调整图像长边的大小。如果 `size` 是一个长度为2的序列，其输入格式应该为 (height, width)。
- **size** (Union[int, sequence]) - 调整后图像的输出尺寸大小。若输入整型，则放缩至(size, size)大小；若输入2元素序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
**异常：**
- **TypeError** - 当 `size` 的类型不为整型或整型序列。
- **TypeError** - 当 `size` 的类型不为int或Sequence[int]类型。
- **ValueError** - 当 `size` 不为正数。
- **RuntimeError** - 当输入图像的shape不为<H, W>或<H, W, C>。

24
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomResizedCrop.rst
View File

@ -3,32 +3,32 @@ mindspore.dataset.vision.c_transforms.RandomResizedCrop
.. py:class:: mindspore.dataset.vision.c_transforms.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(3. / 4., 4. / 3.), interpolation=Inter.BILINEAR, max_attempts=10)
对输入图像进行随机裁剪，并使用指定的插值模式调整裁剪后的图像为指定的大小。
对输入图像进行随机裁剪，并使用指定的 :class:`mindspore.dataset.vision.Inter` 插值方式去调整为指定的尺寸大小。
.. note:: 如果输入图像不止一张，需要保证输入的多张图像大小一致。
.. note:: 如果输入图像不止一张，需要保证输入的多张图像尺寸大小一致。
**参数：**
- **size** (Union[int, sequence]) - 图像的输出大小。 如果 `size` 是整数，则返回大小为 (size, size) 的正方形图像。 如果 `size` 是一个长度为2的序列，其输入格式应该为 (height, width)。
- **scale** (list, tuple, optional) - 裁剪子图的大小相对原图比例的随机选取范围，需要在[min, max)区间，默认值：(0.08, 1.0)。
- **ratio** (list, tuple, optional) - 裁剪子图的宽高比的随机选取范围，需要在[min, max)区间，默认值：(3./4., 4./3.)。
- **interpolation** (Inter mode, optional) - 调整大小采用的的图像插值模式。它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.PILCUBIC] 中的任何一个，默认值：Inter.BILINEAR。
- **size** (Union[int, sequence]) - 图像的输出尺寸大小。若输入整型，则放缩至(size, size)大小；若输入2元素序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **scale** (Union[list, tuple], 可选) - 裁剪子图的尺寸大小相对原图比例的随机选取范围，需要在[min, max)区间，默认值：(0.08, 1.0)。
- **ratio** (Union[list, tuple], 可选) - 裁剪子图的宽高比的随机选取范围，需要在[min, max)区间，默认值：(3./4., 4./3.)。
- **interpolation** (Inter, 可选) - 插值方式。它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.PILCUBIC] 中的任何一个，默认值：Inter.BILINEAR。
- Inter.BILINEAR，双线性插值。
- Inter.NEAREST，最近邻插值。
- Inter.BICUBIC，双三次插值。
- Inter.AREA，像素区域插值。
- Inter.PILCUBIC，与 `pillow` 中实现的双三次插值效果一致，输入应为3通道格式。
- Inter.PILCUBIC，Pillow库中实现的双三次插值，输入应为3通道格式。
- **max_attempts** (int, optional): 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪，默认值：10。
- **max_attempts** (int, 可选): 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪，默认值：10。
**异常：**
- **TypeError** - 当 `size` 的类型不为整型或整型序列。
- **TypeError** - 当 `scale` 的类型不为元组。
- **TypeError** - 当 `ratio` 的类型不为元组。
- **TypeError** - 当 `size` 的类型不为int或Sequence[int]。
- **TypeError** - 当 `scale` 的类型不为tuple或list。
- **TypeError** - 当 `ratio` 的类型不为tuple或list。
- **TypeError** - 当 `interpolation` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **TypeError** - 当 `max_attempts` 的类型不为整型。
- **TypeError** - 当 `max_attempts` 的类型不为int。
- **ValueError** - 当 `size` 不为正数。
- **ValueError** - 当 `scale` 为负数。
- **ValueError** - 当 `ratio` 为负数。

20
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomResizedCropWithBBox.rst
View File

@ -3,28 +3,28 @@ mindspore.dataset.vision.c_transforms.RandomResizedCropWithBBox
.. py:class:: mindspore.dataset.vision.c_transforms.RandomResizedCropWithBBox(size, scale=(0.08, 1.0), ratio=(3. / 4., 4. / 3.), interpolation=Inter.BILINEAR, max_attempts=10)
对输入图像进行随机裁剪且随机调整纵横比，并将处理后的图像调整为指定的大小，并相应地调整边界框。
对输入图像进行随机裁剪且随机调整纵横比，并将处理后的图像调整为指定的尺寸大小，并相应地调整边界框。
**参数：**
- **size** (Union[int, sequence]) - 图像的输出大小。 如果 `size` 是整数，则返回大小为 (size, size) 的正方形图像。 如果 `size` 是一个长度为2的序列，其输入格式应该为 (height, width)。
- **scale** (list, tuple, optional) - 裁剪子图的大小相对原图比例的随机选取范围，需要在[min, max)区间，默认值：(0.08, 1.0)。
- **ratio** (list, tuple, optional) - 裁剪子图的宽高比的随机选取范围，需要在[min, max)区间，默认值：(3./4., 4./3.)。
- **interpolation** (Inter, optional) - 调整大小采用的的图像插值模式。它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] 中的任何一个，默认值：Inter.BILINEAR。
- **size** (Union[int, sequence]) - 图像的输出尺寸大小。若输入整型，则放缩至(size, size)大小；若输入2元素序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **scale** (Union[list, tuple], 可选) - 裁剪子图的尺寸大小相对原图比例的随机选取范围，需要在[min, max)区间，默认值：(0.08, 1.0)。
- **ratio** (Union[list, tuple], 可选) - 裁剪子图的宽高比的随机选取范围，需要在[min, max)区间，默认值：(3./4., 4./3.)。
- **interpolation** (Inter, 可选) - 插值方式。它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] 中的任何一个，默认值：Inter.BILINEAR。
- Inter.BILINEAR，双线性插值。
- Inter.NEAREST，最近邻插值。
- Inter.BICUBIC，双三次插值。
- **max_attempts** (int, optional): 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪，默认值：10。
- **max_attempts** (int, 可选): 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪，默认值：10。
**异常：**
- **TypeError** - 当 `size` 的类型不为整型或整型序列。
- **TypeError** - 当 `scale` 的类型不为元组。
- **TypeError** - 当 `ratio` 的类型不为元组。
- **TypeError** - 当 `size` 的类型不为int或Sequence[int]。
- **TypeError** - 当 `scale` 的类型不为tuple或list。
- **TypeError** - 当 `ratio` 的类型不为tuple或list。
- **TypeError** - 当 `interpolation` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **TypeError** - 当 `max_attempts` 的类型不为整型。
- **TypeError** - 当 `max_attempts` 的类型不为int。
- **ValueError** - 当 `size` 不为正数。
- **ValueError** - 当 `scale` 为负数。
- **ValueError** - 当 `ratio` 为负数。

16
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomRotation.rst
View File

@ -8,22 +8,22 @@ mindspore.dataset.vision.c_transforms.RandomRotation
**参数：**
- **degrees** (Union[int, float, sequence]) - 旋转角度的随机选取范围。若输入单个数字，则从(-degrees, degrees)中随机生成旋转角度；若输入2元素序列，需按(min, max)顺序排列。
- **resample** (Inter mode, optional) - 插值方式。 它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] 中的任何一个，默认值：Inter.NEAREST。
- **resample** (Inter, 可选) - 插值方式。它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] 中的任何一个，默认值：Inter.NEAREST。
- Inter.BILINEAR，双线性插值。
- Inter.NEAREST，最近邻插值。
- Inter.BICUBIC，双三次插值。
- **expand** (bool, optional) - 图像大小拓宽标志，若为True，将扩展图像大小使其足以容纳整个旋转图像；若为False或未指定，则保持输出图像与输入图像大小一致。请注意，扩展时将假设图像为中心旋转且未进行平移，默认值：False。
- **center** (tuple, optional) - 可选的旋转中心，以图像左上角为原点，旋转中心的位置按照 (width, height) 格式指定。默认值：None，表示中心旋转。
- **fill_value** (Union[int, tuple], optional) - 旋转图像之外区域的像素填充值。若输入3元素元组，将分别用于填充R、G、B通道；若输入整型，将以该值填充RGB通道。 `fill_value` 值必须在 [0, 255] 范围内，默认值：0。
- **expand** (bool, 可选) - 图像形状大小扩展标志，若为True，将扩展图像形状大小使其足以容纳整个旋转图像；若为False或未指定，则保持输出图像与输入图像形状大小一致。请注意，扩展时将假设图像为中心旋转且未进行平移，默认值：False。
- **center** (tuple, 可选) - 可选的旋转中心，以图像左上角为原点，旋转中心的位置按照 (宽度, 高度) 格式指定。默认值：None，表示中心旋转。
- **fill_value** (Union[int, tuple], 可选) - 旋转图像之外区域的像素填充值。若输入3元素元组，将分别用于填充R、G、B通道；若输入整型，将以该值填充RGB通道。`fill_value` 值必须在 [0, 255] 范围内，默认值：0。
**异常：**
- **TypeError** - 当 `degrees` 的类型不为整型、浮点型或序列。
- **TypeError** - 当 `degrees` 的类型不为int、float或sequence。
- **TypeError** - 当 `resample` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **TypeError** - 当 `expand` 的类型不为布尔型。
- **TypeError** - 当 `center` 的类型不为元组。
- **TypeError** - 当 `fill_value` 的类型不为整型或整型序列。
- **TypeError** - 当 `expand` 的类型不为bool。
- **TypeError** - 当 `center` 的类型不为tuple。
- **TypeError** - 当 `fill_value` 的类型不为int或Tuple[int]。
- **ValueError** - 当 `fill_value` 取值不在[0, 255]范围内。
- **RuntimeError** - 当输入图像的shape不为<H, W>或<H, W, C>。

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomSelectSubpolicy.rst
View File

@ -3,7 +3,7 @@ mindspore.dataset.vision.c_transforms.RandomSelectSubpolicy
.. py:class:: mindspore.dataset.vision.c_transforms.RandomSelectSubpolicy(policy)
从策略列表中选择一个随机子策略以应用于输入图像。
从策略列表中随机选择一个子策略以应用于输入图像。
**参数：**

6
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomSharpness.rst
View File

@ -3,14 +3,14 @@ mindspore.dataset.vision.c_transforms.RandomSharpness
.. py:class:: mindspore.dataset.vision.c_transforms.RandomSharpness(degrees=(0.1, 1.9))
在给定的范围随机内地调整输入图像的锐度。调节系数为0.0时将返回模糊图像；调节系数为1.0时将返回原始图像；调节系数为2.0时将返回锐化图像。
在固定或随机的范围调整输入图像的锐度。度数为0.0时将返回模糊图像；度数为1.0时将返回原始图像；度数为2.0时将返回锐化图像。
**参数：**
- **degrees** (Union[list, tuple], optional) - 锐度调节系数的随机选取范围，按照(min, max)顺序排列。如果 min=max，那么它是一个单一的固定锐度调整操作，默认值：(0.1, 1.9)。
- **degrees** (Union[list, tuple], 可选) - 锐度调整度的随机选取范围，按照(min, max)顺序排列。如果min与max相等，那么它是一个单一的固定锐度调整操作，默认值：(0.1, 1.9)。
**异常：**
- **TypeError** - 如果 `degree` 不是列表或元组。
- **TypeError** - 如果 `degree` 的类型不为list或tuple。
- **ValueError** - 如果 `degree` 为负数。
- **ValueError** - 如果 `degree` 采用 (max, min) 格式而不是 (min, max)。

6
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomSolarize.rst
View File

@ -3,13 +3,13 @@ mindspore.dataset.vision.c_transforms.RandomSolarize
.. py:class:: mindspore.dataset.vision.c_transforms.RandomSolarize(threshold=(0, 255))
从给定阈值范围内随机选择一个子范围，并对像素值位于给定子范围内的像素，将其值设置为（255 - 原本像素值）。
从给定阈值范围内随机选择一个子范围，对位于给定子范围内的像素，将其像素值设置为(255 - 原本像素值)。
**参数：**
- **threshold** (tuple, optional) - 随机曝光的阈值范围，默认值：（0, 255）。`threshold` 输入格式应该为 (min, max)，其中 `min` 和 `max` 是 (0, 255) 范围内的整数，并且 min <= max。 如果 min=max，则反转所有高于 min(或max) 的像素值。
- **threshold** (tuple, 可选) - 随机曝光的阈值范围，默认值：(0, 255)。 `threshold` 输入格式应该为 (min, max)，其中min和max是 (0, 255) 范围内的整数，并且min小于等于max。如果min与max相等，则反转所有高于 min(或max) 的像素值。
**异常：**
- **TypeError** - 当 `threshold` 的类型不为元组。
- **TypeError** - 当 `threshold` 的类型不为tuple。
- **ValueError** - 当 `threshold` 取值不在[0, 255]范围内。

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomVerticalFlip.rst
View File

@ -7,7 +7,7 @@ mindspore.dataset.vision.c_transforms.RandomVerticalFlip
**参数：**
- **prob** (float, optional) - 图像被翻转的概率，默认值：0.5。
- **prob** (float, 可选) - 图像被翻转的概率，默认值：0.5。
**异常：**

2
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.RandomVerticalFlipWithBBox.rst
View File

@ -7,7 +7,7 @@ mindspore.dataset.vision.c_transforms.RandomVerticalFlipWithBBox
**参数：**
- **prob** (float, optional) - 图像被翻转的概率，默认值：0.5。
- **prob** (float, 可选) - 图像被翻转的概率，默认值：0.5。
**异常：**

6
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Rescale.rst
View File

@ -3,7 +3,7 @@ mindspore.dataset.vision.c_transforms.Rescale
.. py:class:: mindspore.dataset.vision.c_transforms.Rescale(rescale, shift)
基于给定的缩放和平移因子调整图像的大小。输出图像的大小为：output = image * rescale + shift。
基于给定的缩放和平移因子调整图像的尺寸大小。输出图像的尺寸大小为：output = image * rescale + shift。
**参数：**
@ -12,5 +12,5 @@ mindspore.dataset.vision.c_transforms.Rescale
**异常：**
- **TypeError** - 当 `rescale` 的类型不为浮点型。
- **TypeError** - 当 `shift` 的类型不为浮点型。
- **TypeError** - 当 `rescale` 的类型不为float。
- **TypeError** - 当 `shift` 的类型不为float。

12
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Resize.rst
View File

@ -3,22 +3,22 @@ mindspore.dataset.vision.c_transforms.Resize
.. py:class:: mindspore.dataset.vision.c_transforms.Resize(size, interpolation=Inter.LINEAR)
使用给定的插值模式将输入图像调整为给定的大小。
对输入图像使用给定的 :class:`mindspore.dataset.vision.Inter` 插值方式去调整为给定的尺寸大小。
**参数：**
- **size** (Union[int, sequence]) - 图像的输出大小。如果 `size` 是整数，将调整图像的较短边长度为 `size`，且保持图像的宽高比不变；若输入是2元素组成的序列，其输入格式需要是 (height, width) 。
- **interpolation** (Inter mode, optional) - 图像插值模式。它可以是 [Inter.LINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.PILCUBIC] 中的任何一个，默认值：Inter.LINEAR。
- **size** (Union[int, sequence]) - 图像的输出大小。若输入整型，则放缩至(size, size)大小；若输入2元素序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **interpolation** (Inter, 可选) - 图像插值方式。它可以是 [Inter.LINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.PILCUBIC] 中的任何一个，默认值：Inter.LINEAR。
- Inter.LINEAR，双线性插值。
- Inter.NEAREST，最近邻插值。
- Inter.BICUBIC，双三次插值。
- Inter.AREA，像素区域插值。
- Inter.PILCUBIC，与 `pillow` 中实现的双三次插值效果一致，输入应为3通道格式。
- Inter.PILCUBIC，Pillow库中实现的双三次插值，输入应为3通道格式。
**异常：**
- **TypeError** - 当 `size` 的类型不为整型或整型序列。
- **TypeError** - 当 `interpolation` 的类型不为 :class:`Inter` 。
- **TypeError** - 当 `size` 的类型不为int或Sequence[int]。
- **TypeError** - 当 `interpolation` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **ValueError** - 当 `size` 不为正数。
- **RuntimeError** - 如果输入的Tensor不是 <H, W> 或 <H, W, C> 格式。

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.ResizeWithBBox.rst
View File

@ -7,8 +7,8 @@ mindspore.dataset.vision.c_transforms.ResizeWithBBox
**参数：**
- **size** (Union[int, sequence]) - 图像的输出大小。如果 `size` 是整数，将调整图像的较短边长度为 `size`，且保持图像的宽高比不变；若输入是2元素组成的序列，其输入格式需要是 (height, width) 。
- **interpolation** (Inter mode, optional) - 图像插值模式。它可以是 [Inter.LINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.PILCUBIC] 中的任何一个，默认值：Inter.LINEAR。
- **size** (Union[int, sequence]) - 图像的输出大小。如果 `size` 是整数，将调整图像的较短边长度为 `size`，且保持图像的宽高比不变；若输入是2元素组成的序列，其输入格式需要是 (高度, 宽度) 。
- **interpolation** (Inter, 可选) - 图像插值方式。它可以是 [Inter.LINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.PILCUBIC] 中的任何一个，默认值：Inter.LINEAR。
- Inter.LINEAR，双线性插值。
- Inter.NEAREST，最近邻插值。
@ -16,7 +16,7 @@ mindspore.dataset.vision.c_transforms.ResizeWithBBox
**异常：**
- **TypeError** - 当 `size` 的类型不为整型或整型序列。
- **TypeError** - 当 `interpolation` 的类型不为 :class:`Inter` 。
- **TypeError** - 当 `size` 的类型不为int或Sequence[int]。
- **TypeError** - 当 `interpolation` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **ValueError** - 当 `size` 不为正数。
- **RuntimeError** - 如果输入的Tensor不是 <H, W> 或 <H, W, C> 格式。

16
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.Rotate.rst
View File

@ -8,22 +8,22 @@ mindspore.dataset.vision.c_transforms.Rotate
**参数：**
- **degrees** (Union[int, float]) - 旋转角度。
- **resample** (Inter mode, optional) - 插值方式。 它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] 中的任何一个，默认值：Inter.NEAREST。
- **resample** (Inter, 可选) - 插值方式。 它可以是 [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] 中的任何一个，默认值：Inter.NEAREST。
- Inter.BILINEAR，双线性插值。
- Inter.NEAREST，最近邻插值。
- Inter.BICUBIC，双三次插值。
- **expand** (bool, optional) - 图像大小拓宽标志，若为True，将扩展图像大小使其足以容纳整个旋转图像；若为False或未指定，则保持输出图像与输入图像大小一致。请注意，扩展时将假设图像为中心旋转且未进行平移，默认值：False。
- **center** (tuple, optional) - 可选的旋转中心，以图像左上角为原点，旋转中心的位置按照 (width, height) 格式指定。默认值：None，表示中心旋转。
- **fill_value** (Union[int, tuple], optional) - 旋转图像之外区域的像素填充值。若输入3元素元组，将分别用于填充R、G、B通道；若输入整型，将以该值填充RGB通道。 `fill_value` 值必须在 [0, 255] 范围内，默认值：0。
- **expand** (bool, 可选) - 图像大小拓宽标志，若为True，将扩展图像大小使其足以容纳整个旋转图像；若为False或未指定，则保持输出图像与输入图像大小一致。请注意，扩展时将假设图像为中心旋转且未进行平移，默认值：False。
- **center** (tuple, 可选) - 可选的旋转中心，以图像左上角为原点，旋转中心的位置按照 (宽度, 高度) 格式指定。默认值：None，表示中心旋转。
- **fill_value** (Union[int, tuple], 可选) - 旋转图像之外区域的像素填充值。若输入3元素元组，将分别用于填充R、G、B通道；若输入整型，将以该值填充RGB通道。 `fill_value` 值必须在 [0, 255] 范围内，默认值：0。
**异常：**
- **TypeError** - 当 `degrees` 的类型不为整型、浮点型或序列。
- **TypeError** - 当 `degrees` 的类型不为int或float。
- **TypeError** - 当 `resample` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **TypeError** - 当 `expand` 的类型不为布尔型。
- **TypeError** - 当 `center` 的类型不为元组。
- **TypeError** - 当 `fill_value` 的类型不为整型或整型序列。
- **TypeError** - 当 `expand` 的类型不为bool。
- **TypeError** - 当 `center` 的类型不为tuple。
- **TypeError** - 当 `fill_value` 的类型不为int或Tuple[int]。
- **ValueError** - 当 `fill_value` 取值不在[0, 255]范围内。
- **RuntimeError** - 当输入图像的shape不为<H, W>或<H, W, C>。

16
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.SlicePatches.rst
View File

@ -7,17 +7,17 @@ mindspore.dataset.vision.c_transforms.SlicePatches
**参数：**
- **num_height** (int, optional) - 垂直方向的切块数量，默认值：1。
- **num_width** (int, optional) - 水平方向的切块数量，默认值：1。
- **slice_mode** (Inter mode, optional) - 表示填充或丢弃，它可以是 [SliceMode.PAD, SliceMode.DROP] 中的任何一个，默认值：SliceMode.PAD。
- **fill_value** (int, optional) - 如果 `slice_mode` 取值为 SliceMode.PAD，该值表示在右侧和底部方向上的填充的边界宽度（以像素数计），默认值：0。
- **num_height** (int, 可选) - 垂直方向的切块数量，默认值：1。
- **num_width** (int, 可选) - 水平方向的切块数量，默认值：1。
- **slice_mode** (Inter, 可选) - 表示填充或丢弃，它可以是 [SliceMode.PAD, SliceMode.DROP] 中的任何一个，默认值：SliceMode.PAD。
- **fill_value** (int, 可选) - 如果 `slice_mode` 取值为 SliceMode.PAD，该值表示在右侧和底部方向上的填充的边界宽度（以像素数计），默认值：0。
**异常：**
- **TypeError** - 当 `num_height` 不是整型。
- **TypeError** - 当 `num_width` 不是整型。
- **TypeError** - 当 `slice_mode` 不是整型。
- **TypeError** - 当 `fill_value` 不是整型。
- **TypeError** - 当 `num_height` 不是int。
- **TypeError** - 当 `num_width` 不是int。
- **TypeError** - 当 `slice_mode` 的类型不为 :class:`mindspore.dataset.vision.Inter` 。
- **TypeError** - 当 `fill_value` 不是int。
- **ValueError** - 当 `num_height` 不为正数。
- **ValueError** - 当 `num_width` 不为正数。
- **ValueError** - 当 `fill_value` 不在 [0, 255]范围内。

20
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.SoftDvppDecodeRandomCropResizeJpeg.rst
View File

@ -3,22 +3,22 @@ mindspore.dataset.vision.c_transforms.SoftDvppDecodeRandomCropResizeJpeg
.. py:class:: mindspore.dataset.vision.c_transforms.SoftDvppDecodeRandomCropResizeJpeg(size, scale=(0.08, 1.0), ratio=(3. / 4., 4. / 3.), max_attempts=10)
使用Ascend系列芯片DVPP模块的模拟算法组合了 `Crop` 、 `Decode` 和 `Resize` 。
使用场景与数据增强算子 `SoftDvppDecodeResizeJpeg` 一致。 输入图像大小应在 [32*32, 8192*8192] 范围内。图像长度和宽度的缩小和放大倍数应在 [1/32, 16] 范围内。使用该算子只能输出具有均匀分辨率的图像，不支持奇数分辨率的输出。
使用Ascend系列芯片DVPP模块的模拟算法对JPEG图像进行裁剪、解码和缩放。
使用场景与数据增强算子 :class:`mindspore.dataset.vision.c_transforms.SoftDvppDecodeResizeJpeg` 一致。输入图像尺寸大小应在 [32*32, 8192*8192] 范围内。图像长度和宽度的缩小和放大倍数应在 [1/32, 16] 范围内。使用该算子只能输出具有均匀分辨率的图像，不支持奇数分辨率的输出。
**参数：**
- **size** (Union[int, sequence]) - 输出图像的大小。如果 `size` 是整数，则返回大小为 (size, size) 的正方形图像。 如果 `size` 是一个长度为2的序列，其输入格式应该为 (height, width)。
- **scale** (list, tuple, optional) - 裁剪子图的大小相对原图比例的随机选取范围，需要在[min, max)区间，默认值：(0.08, 1.0)。
- **ratio** (list, tuple, optional) - 裁剪子图的宽高比的随机选取范围，需要在[min, max)区间，默认值：(3./4., 4./3.)。
- **max_attempts** (int, optional) - 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪，默认值：10。
- **size** (Union[int, sequence]) - 输出图像的尺寸大小。如果 `size` 是整型，则返回尺寸大小为 (size, size) 的正方形图像。如果 `size` 是一个长度为2的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
- **scale** (Union[list, tuple], 可选) - 裁剪子图的尺寸大小相对原图比例的随机选取范围，需要在[min, max)区间，默认值：(0.08, 1.0)。
- **ratio** (Union[list, tuple], 可选) - 裁剪子图的宽高比的随机选取范围，需要在[min, max)区间，默认值：(3./4., 4./3.)。
- **max_attempts** (int, 可选) - 生成随机裁剪位置的最大尝试次数，超过该次数时将使用中心裁剪， `max_attempts` 值必须为正数，默认值：10。
**异常：**
- **TypeError** - 当 `size` 不是整型或不是整型序列。
- **TypeError** - 当 `scale` 不是元组类型。
- **TypeError** - 当 `ratio` 不是元组类型。
- **TypeError** - 当 `max_attempts` 不是整型。
- **TypeError** - 当 `size` 不是int或不是Sequence[int]类型。
- **TypeError** - 当 `scale` 不是tuple或list类型。
- **TypeError** - 当 `ratio` 不是tuple或list类型。
- **TypeError** - 当 `max_attempts` 不是int类型。
- **ValueError** - 当 `size` 不为正数。
- **ValueError** - 当 `scale` 是负数。
- **ValueError** - 当 `ratio` 是负数。

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.SoftDvppDecodeResizeJpeg.rst
View File

@ -3,16 +3,16 @@ mindspore.dataset.vision.c_transforms.SoftDvppDecodeResizeJpeg
.. py:class:: mindspore.dataset.vision.c_transforms.SoftDvppDecodeResizeJpeg(size)
使用Ascend系列芯片DVPP模块的仿真算法对JPEG图像进行解码和缩放。
使用Ascend系列芯片DVPP模块的模拟算法对JPEG图像进行解码和缩放。
建议在以下场景使用该算法：训练时不使用Ascend芯片的DVPP模块，推理时使用Ascend芯片的DVPP模块，推理的准确率低于训练的准确率； 并且输入图像大小应在 [32*32, 8192*8192] 范围内。 图像长度和宽度的缩小和放大倍数应在 [1/32, 16] 范围内。使用该算子只能输出具有均匀分辨率的图像，不支持奇数分辨率的输出。
建议在以下场景使用该算法：训练时不使用Ascend芯片的DVPP模块，推理时使用Ascend芯片的DVPP模块，推理的准确率低于训练的准确率； 并且输入图像尺寸大小应在 [32*32, 8192*8192] 范围内。 图像长度和宽度的缩小和放大倍数应在 [1/32, 16] 范围内。使用该算子只能输出具有均匀分辨率的图像，不支持奇数分辨率的输出。
**参数：**
- **size** (Union[int, sequence]) - 图像的输出大小。如果 `size` 是整数，将调整图像的较短边长度为 `size`，且保持图像的宽高比不变；若输入是2元素组成的序列，其输入格式需要是 (height, width) 。
- **size** (Union[int, sequence]) - 图像的输出尺寸大小。如果 `size` 是整数，将调整图像的较短边长度为 `size`，且保持图像的宽高比不变；若输入是2元素组成的序列，则以2个元素分别为高和宽放缩至(高度, 宽度)大小。
**异常：**
- **TypeError** - 当 `size` 不是整型或不是整型序列。
- **TypeError** - 当 `size` 不是int或不是Sequence[int]类型。
- **ValueError** - 当 `size` 不为正数。
- **RuntimeError** - 如果输入的Tensor不是一个一维序列。

8
docs/api/api_python/dataset_vision/mindspore.dataset.vision.c_transforms.UniformAugment.rst
View File

@ -7,11 +7,11 @@ mindspore.dataset.vision.c_transforms.UniformAugment
**参数：**
- **transforms** - C++ 操作列表（不接受Python操作）。
- **num_ops** (int, optional) - 要选择和执行的操作数量，默认值：2。
- **transforms** (TensorOperation) - 对给定图像随机选择的边界框区域应用 C++ 变换处理。(不接受Python操作）。
- **num_ops** (int, 可选) - 要选择和执行的操作的数量，默认值：2。
**异常：**
- **TypeError** - 当 `transforms` 包含不可调用的Python对象。
- **TypeError** - 当 `num_ops` 不是整数。
- **TypeError** - 如果 `transform` 不是 :class:`mindspore.dataset.vision.c_transforms` 模块中的图像变换处理。
- **TypeError** - 当 `num_ops` 不是int类型。
- **ValueError** - 当 `num_ops` 不为正数。

122
mindspore/python/mindspore/dataset/vision/c_transforms.py
View File

@ -288,10 +288,11 @@ class BoundingBoxAugment(ImageTensorOperation):
transform (TensorOperation): C++ transformation operation to be applied on random selection
of bounding box regions of a given image.
ratio (float, optional): Ratio of bounding boxes to apply augmentation on.
Range: [0, 1] (default=0.3).
Range: [0.0, 1.0] (default=0.3).
Raises:
TypeError: If `transform` is an image processing operation in :class:`mindspore.dataset.vision.c_transforms`.
TypeError: If `transform` is not an image processing operation
in :class:`mindspore.dataset.vision.c_transforms`.
TypeError: If `ratio` is not of type float.
ValueError: If `ratio` is not in range [0.0, 1.0].
RuntimeError: If given bounding box is invalid.
@ -330,7 +331,7 @@ class CenterCrop(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the cropped image.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
If size is a sequence of length 2, an image of size (height, width) will be cropped.
The size value(s) must be larger than 0.
Raises:
@ -445,7 +446,7 @@ class Crop(ImageTensorOperation):
values, in the form of (top, left).
size (Union[int, sequence]): The output size of the cropped image.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
If size is a sequence of length 2, an image of size (height, width) will be cropped.
The size value(s) must be larger than 0.
Raises:
@ -555,11 +556,11 @@ class CutOut(ImageTensorOperation):
class Decode(ImageTensorOperation):
"""
Decode the input image in RGB mode(default) or BGR mode(option is deprecated).
Decode the input image.
Args:
rgb (bool, optional): Mode of decoding input image (default=True).
If True means format of decoded image is RGB else BGR(option is deprecated).
If True means format of decoded image is RGB else BGR (deprecated).
Raises:
RuntimeError: If `rgb` is False, since this option is deprecated.
@ -624,11 +625,11 @@ class GaussianBlur(ImageTensorOperation):
Args:
kernel_size (Union[int, sequence]): Size of the Gaussian kernel to use. The value must be positive and odd. If
only an integer is provided, the kernel size will be (size, size). If a sequence of integer is provided, it
must be a sequence of 2 values which represents (width, height).
only an integer is provided, the kernel size will be (kernel_size, kernel_size). If a sequence of integer
is provided, it must be a sequence of 2 values which represents (width, height).
sigma (Union[float, sequence], optional): Standard deviation of the Gaussian kernel to use (default=None). The
value must be positive. If only a float is provided, the sigma will be (sigma, sigma). If a sequence of
float is provided, it must be a sequence of 2 values which represents the sigma of width and height. If None
float is provided, it must be a sequence of 2 values which represents (width, height). If None
is provided, the sigma will be calculated as ((kernel_size - 1) * 0.5 - 1) * 0.3 + 0.8.
Raises:
@ -684,7 +685,7 @@ class HorizontalFlip(ImageTensorOperation):
class HWC2CHW(ImageTensorOperation):
"""
Transpose the input image from shape (H, W, C) to shape (C, H, W). The input image should be 3 channels image.
Transpose the input image from shape <H, W, C> to shape <C, H, W>. The input image should be 3 channels image.
Raises:
RuntimeError: If given tensor shape is not <H, W, C>.
@ -812,14 +813,14 @@ class NormalizePad(ImageTensorOperation):
The mean values must be in range (0.0, 255.0].
std (sequence): List or tuple of standard deviations for each channel, with respect to channel order.
The standard deviation values must be in range (0.0, 255.0].
dtype (str, optional): Set the output data type of normalized image (default is "float32").
dtype (str, optional): Set the dtype of the output image (default is "float32").
Raises:
TypeError: If `mean` is not of type sequence.
TypeError: If `std` is not of type sequence.
TypeError: If `dtype` is not of type string.
ValueError: If `mean` is not in range [0.0, 255.0].
ValueError: If `mean` is not in range (0.0, 255.0].
ValueError: If `std` is not in range (0.0, 255.0].
RuntimeError: If given tensor shape is not <H, W, C>.
Supported Platforms:
@ -847,10 +848,10 @@ class NormalizePad(ImageTensorOperation):
class Pad(ImageTensorOperation):
"""
Pad the image according to padding parameters.
Pad the image.
Args:
padding (Union[int, sequence]): The number of pixels to pad the image.
padding (Union[int, sequence]): The number of pixels to pad each border of the image.
If a single number is provided, it pads all borders with this value.
If a tuple or lists of 2 values are provided, it pads the (left and top)
with the first value and (right and bottom) with the second value.
@ -1096,7 +1097,7 @@ class RandomAutoContrast(ImageTensorOperation):
class RandomColor(ImageTensorOperation):
"""
Adjust the color of the input image by a fixed or random degree.
This operation works only with 3-channel color images.
This operation works only with 3-channel RGB images.
Args:
degrees (sequence, optional): Range of random color adjustment degrees, which must be non-negative.
@ -1207,8 +1208,8 @@ class RandomCrop(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the cropped image. The size value(s) must be positive.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
padding (Union[int, sequence], optional): The number of pixels to pad the image
If size is a sequence of length 2, an image of size (height, width) will be cropped.
padding (Union[int, sequence], optional): The number of pixels to pad each border of the image.
The padding value(s) must be non-nagetive (default=None).
If padding is not None, pad image first with padding values.
If a single number is provided, pad all borders with this value.
@ -1288,10 +1289,10 @@ class RandomCropDecodeResize(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the resized image. The size value(s) must be positive.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
scale (list, tuple, optional): Range [min, max) of respective size of the
If size is a sequence of length 2, an image of size (height, width) will be cropped.
scale (Union[list, tuple], optional): Range [min, max) of respective size of the
original size to be cropped, which must be non-negative (default=(0.08, 1.0)).
ratio (list, tuple, optional): Range [min, max) of aspect ratio to be
ratio (Union[list, tuple], optional): Range [min, max) of aspect ratio to be
cropped, which must be non-negative (default=(3. / 4., 4. / 3.)).
interpolation (Inter, optional): Image interpolation mode for resize operator(default=Inter.BILINEAR).
It can be any of [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.AREA, Inter.PILCUBIC].
@ -1312,8 +1313,8 @@ class RandomCropDecodeResize(ImageTensorOperation):
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
TypeError: If `scale` is not of type tuple.
TypeError: If `ratio` is not of type tuple.
TypeError: If `scale` is not of type tuple or list.
TypeError: If `ratio` is not of type tuple or list.
TypeError: If `interpolation` is not of type :class:`mindspore.dataset.vision.Inter`.
TypeError: If `max_attempts` is not of type integer.
ValueError: If `size` is not positive.
@ -1369,7 +1370,7 @@ class RandomCropWithBBox(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the cropped image. The size value(s) must be positive.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
If size is a sequence of length 2, an image of size (height, width) will be cropped.
padding (Union[int, sequence], optional): The number of pixels to pad the image
The padding value(s) must be non-nagetive (default=None).
If padding is not None, first pad image with padding values.
@ -1591,10 +1592,10 @@ class RandomLighting(ImageTensorOperation):
class RandomPosterize(ImageTensorOperation):
"""
Reduce the number of bits for each color channel to posterize the input image randomly with a given probability.
Reduce the number of bits for each RGB channel to posterize the input image randomly with a given probability.
Args:
bits (sequence or int, optional): Range of random posterize to compress image.
bits (Union[int, Sequence[int]], optional): Range of random posterize to compress image.
Bits values must be in range of [1,8], and include at
least one integer value in the given range. It must be in
(min, max) or integer format. If min=max, then it is a single fixed
@ -1634,13 +1635,13 @@ class RandomResizedCrop(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the resized image. The size value(s) must be positive.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
scale (list, tuple, optional): Range [min, max) of respective size of the original
If size is an integer, a square of size (size, size) will be cropped with this value.
If size is a sequence of length 2, an image of size (height, width) will be cropped.
scale (Union[list, tuple], optional): Range [min, max) of respective size of the original
size to be cropped, which must be non-negative (default=(0.08, 1.0)).
ratio (list, tuple, optional): Range [min, max) of aspect ratio to be
ratio (Union[list, tuple], optional): Range [min, max) of aspect ratio to be
cropped, which must be non-negative (default=(3. / 4., 4. / 3.)).
interpolation (Inter, optional): Image interpolation mode for resize operator (default=Inter.BILINEAR).
interpolation (Inter, optional): Method of interpolation (default=Inter.BILINEAR).
It can be any of [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.AREA, Inter.PILCUBIC].
- Inter.BILINEAR, means interpolation method is bilinear interpolation.
@ -1659,8 +1660,8 @@ class RandomResizedCrop(ImageTensorOperation):
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
TypeError: If `scale` is not of type tuple.
TypeError: If `ratio` is not of type tuple.
TypeError: If `scale` is not of type tuple or list.
TypeError: If `ratio` is not of type tuple or list.
TypeError: If `interpolation` is not of type :class:`mindspore.dataset.vision.Inter`.
TypeError: If `max_attempts` is not of type integer.
ValueError: If `size` is not positive.
@ -1704,14 +1705,14 @@ class RandomResizedCropWithBBox(ImageTensorOperation):
Args:
size (Union[int, sequence]): The size of the output image. The size value(s) must be positive.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
scale (list, tuple, optional): Range (min, max) of respective size of the original
If size is an integer, a square of size (size, size) will be cropped with this value.
If size is a sequence of length 2, an image of size (height, width) will be cropped.
scale (Union[list, tuple], optional): Range (min, max) of respective size of the original
size to be cropped, which must be non-negative (default=(0.08, 1.0)).
ratio (list, tuple, optional): Range (min, max) of aspect ratio to be
ratio (Union[list, tuple], optional): Range (min, max) of aspect ratio to be
cropped, which must be non-negative (default=(3. / 4., 4. / 3.)).
interpolation (Inter mode, optional): Image interpolation mode (default=Inter.BILINEAR).
It can be any of [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC].
interpolation (Inter mode, optional): Method of interpolation (default=Inter.BILINEAR).
It can be any of [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC] .
- Inter.BILINEAR, means interpolation method is bilinear interpolation.
@ -1724,8 +1725,8 @@ class RandomResizedCropWithBBox(ImageTensorOperation):
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
TypeError: If `scale` is not of type tuple.
TypeError: If `ratio` is not of type tuple.
TypeError: If `scale` is not of type tuple or list.
TypeError: If `ratio` is not of type tuple or list.
TypeError: If `interpolation` is not of type Inter.
TypeError: If `max_attempts` is not of type integer.
ValueError: If `size` is not positive.
@ -1768,9 +1769,8 @@ class RandomResize(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the resized image. The size value(s) must be positive.
If size is an integer, smaller edge of the image will be resized to this value with
the same image aspect ratio.
If size is a sequence of length 2, it should be (height, width).
If size is an integer, a square of size (size, size) will be cropped with this value.
If size is a sequence of length 2, an image of size (height, width) will be cropped.
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
@ -1809,9 +1809,8 @@ class RandomResizeWithBBox(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the resized image. The size value(s) must be positive.
If size is an integer, smaller edge of the image will be resized to this value with
the same image aspect ratio.
If size is a sequence of length 2, it should be (height, width).
If size is an integer, a square of size (size, size) will be cropped with this value.
If size is a sequence of length 2, an image of size (height, width) will be cropped.
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
@ -1975,7 +1974,7 @@ class RandomSharpness(ImageTensorOperation):
it is a single fixed magnitude operation (default = (0.1, 1.9)).
Raises:
TypeError : If `degrees` is not a list or a tuple.
TypeError : If `degrees` is not of type list or tuple.
ValueError: If `degrees` is negative.
ValueError: If `degrees` is in (max, min) format instead of (min, max).
@ -2123,9 +2122,8 @@ class Resize(ImageTensorOperation):
Args:
size (Union[int, sequence]): The output size of the resized image. The size value(s) must be positive.
If size is an integer, the smaller edge of the image will be resized to this value with
the same image aspect ratio.
If size is a sequence of length 2, it should be (height, width).
If size is an integer, a square of size (size, size) will be cropped with this value.
If size is a sequence of length 2, an image of size (height, width) will be cropped.
interpolation (Inter, optional): Image interpolation mode (default=Inter.LINEAR).
It can be any of [Inter.LINEAR, Inter.NEAREST, Inter.BICUBIC, Inter.AREA, Inter.PILCUBIC].
@ -2178,7 +2176,7 @@ class ResizeWithBBox(ImageTensorOperation):
If size is an integer, smaller edge of the image will be resized to this value with
the same image aspect ratio.
If size is a sequence of length 2, it should be (height, width).
interpolation (Inter mode, optional): Image interpolation mode (default=Inter.LINEAR).
interpolation (Inter, optional): Image interpolation mode (default=Inter.LINEAR).
It can be any of [Inter.LINEAR, Inter.NEAREST, Inter.BICUBIC].
- Inter.LINEAR, means interpolation method is bilinear interpolation.
@ -2248,7 +2246,7 @@ class Rotate(ImageTensorOperation):
Args:
degrees (Union[int, float]): Rotation degrees.
resample (Inter mode, optional): An optional resampling filter (default=Inter.NEAREST).
resample (Inter, optional): An optional resampling filter (default=Inter.NEAREST).
It can be any of [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC].
- Inter.BILINEAR, means resample method is bilinear interpolation.
@ -2267,7 +2265,7 @@ class Rotate(ImageTensorOperation):
The fill_value values must be in range [0, 255] (default=0).
Raises:
TypeError: If `degrees` is not of type integer, float or sequence.
TypeError: If `degrees` is not of type integer or float.
TypeError: If `resample` is not of type Inter.
TypeError: If `expand` is not of type bool.
TypeError: If `center` is not of type tuple.
@ -2373,18 +2371,18 @@ class SoftDvppDecodeRandomCropResizeJpeg(ImageTensorOperation):
Args:
size (Union[int, sequence]): The size of the output image. The size value(s) must be positive.
If size is an integer, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
scale (list, tuple, optional): Range [min, max) of respective size of the
If size is a sequence of length 2, an image of size (height, width) will be cropped.
scale (Union[list, tuple], optional): Range [min, max) of respective size of the
original size to be cropped, which must be non-negative (default=(0.08, 1.0)).
ratio (list, tuple, optional): Range [min, max) of aspect ratio to be
ratio (Union[list, tuple], optional): Range [min, max) of aspect ratio to be
cropped, which must be non-negative (default=(3. / 4., 4. / 3.)).
max_attempts (int, optional): The maximum number of attempts to propose a valid crop_area (default=10).
If exceeded, fall back to use center_crop instead. The max_attempts value must be positive.
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
TypeError: If `scale` is not of type tuple.
TypeError: If `ratio` is not of type tuple.
TypeError: If `scale` is not of type tuple or list.
TypeError: If `ratio` is not of type tuple or list.
TypeError: If `max_attempts` is not of type integer.
ValueError: If `size` is not positive.
ValueError: If `scale` is negative.
@ -2435,7 +2433,7 @@ class SoftDvppDecodeResizeJpeg(ImageTensorOperation):
size (Union[int, sequence]): The output size of the resized image. The size value(s) must be positive.
If size is an integer, smaller edge of the image will be resized to this value with
the same image aspect ratio.
If size is a sequence of length 2, it should be (height, width).
If size is a sequence of length 2, an image of size (height, width) will be cropped.
Raises:
TypeError: If `size` is not of type integer or sequence of integer.
@ -2471,11 +2469,13 @@ class UniformAugment(ImageTensorOperation):
Perform randomly selected augmentation on input image.
Args:
transforms: List of C++ operations (Python operations are not accepted).
transforms (TensorOperation): C++ transformation operation to be applied on random selection
of bounding box regions of a given image (Python operations are not accepted).
num_ops (int, optional): Number of operations to be selected and applied, which must be positive (default=2).
Raises:
TypeError: If `transforms` contains uncallable Python object.
TypeError: If `transform` is not an image processing operation
in :class:`mindspore.dataset.vision.c_transforms`.
TypeError: If `num_ops` is not of type integer.
ValueError: If `num_ops` is not positive.