运算符对象 (旧版)#
在旧版本的 DALI 中，使用面向对象的 API 来定义操作，而不是函数式 API。现在不鼓励使用对象 API，此处显示其文档仅供参考。
旧版对象“运算符”包含在 dali.ops 模块中，它们的名称使用驼峰式大小写，而不是蛇形大小写。例如，dali.ops.CropMirrorNormalize 是 dali.fn.crop_mirror_normalize 的旧版对应物。
当使用运算符对象 API 时，运算符的定义与其在 DALI pipeline 中的使用分离，这允许在实例化期间设置静态参数。
这是一个使用（推荐的）函数式 API 的 pipeline 示例
import nvidia.dali as dali
pipe = dali.pipeline.Pipeline(batch_size = 3, num_threads = 2, device_id = 0)
with pipe:
files, labels = dali.fn.readers.file(file_root = "./my_file_root")
images = dali.fn.decoders.image(files, device = "mixed")
images = dali.fn.rotate(images, angle = dali.fn.random.uniform(range=(-45,45)))
images = dali.fn.resize(images, resize_x = 300, resize_y = 300)
pipe.set_outputs(images, labels)
outputs = pipe.run()
以及使用运算符对象 API 的旧版实现
import nvidia.dali as dali
class CustomPipe(Pipeline):
def __init__(self, batch_size, num_threads, device_id):
super(CustomPipe, self).__init__(batch_size, num_threads, device_id)
self.reader = dali.ops.readers.File(file_root='./my_file_root')
self.decoder = dali.ops.ImageDecoder(device='mixed')
self.rotate = dali.ops.Rotate()
self.resize = dali.ops.Resize(resize_x=300, resize_y=300)
self.rng = dali.ops.random.Uniform(range=(-45, 45))
def define_graph(self):
files, labels = self.reader()
images = self.decoder(files)
images = self.rotate(images, angle=self.rng())
images = self.resize(images)
return images, labels
pipe = CustomPipe(batch_size = 3, num_threads = 2, device_id = 0)
outputs = pipe.run()
值得注意的是，这两个 API 可以同时在单个 pipeline 中使用。这是一个示例
pipe = dali.pipeline.Pipeline(batch_size = 3, num_threads = 2, device_id = 0)
reader = dali.ops.readers.File(file_root = ".")
resize = dali.ops.Resize(device = "gpu", resize_x = 300, resize_y = 300)
with pipe:
files, labels = reader()
images = dali.fn.decoders.image(files, device = "mixed")
images = dali.fn.rotate(images, angle = dali.fn.random.uniform(range=(-45,45)))
images = resize(images)
pipe.set_outputs(images, labels)
outputs = pipe.run()
映射到函数式 API#
下表显示了当前函数式 API 中的操作与旧版运算符对象 API 之间的对应关系。
函数 (fn.*) |
运算符对象 (ops.*) |
|---|---|
模块#
nvidia.dali.ops#
- class nvidia.dali.ops.AudioDecoder(*, bytes_per_sample_hint=[0], downmix=False, dtype=DALIDataType.FLOAT, preserve=False, quality=50.0, sample_rate=0.0, device=None, name=None)#
警告
此运算符现已弃用。请改用
decoders.Audio()。在 DALI 1.0 中，所有解码器都移至专用的
decoders子模块并重命名以遵循通用模式。这是一个占位符运算符，功能相同，以实现向后兼容性。用于
decoders.audio()的旧版别名。
- class nvidia.dali.ops.AudioResample(*, bytes_per_sample_hint=[0], dtype=None, in_rate=None, out_length=None, out_rate=None, preserve=False, quality=50.0, scale=None, device=None, name=None)#
重采样音频信号。
重采样是通过应用带有 Hann 窗口的 sinc 滤波器来实现的，Hann 窗口的范围由
quality参数控制。重采样率可以直接指定，也可以指定为目标采样率与源采样率之比，或者根据请求的输出长度与输入长度之比计算得出。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出类型。
如果未指定，则输出类型与输入类型相同。当类型更改时，值将被归一化以填充目标数据类型的动态范围。当将浮点输入转换为整数类型时，输入值假定在 -1..1 范围内。在有符号和无符号类型之间转换时，0 转换为无符号类型的一半范围。示例
float -> uint8 -1.0 -> 0 0 -> 128 1.0 -> 255 uint8 -> int16 0 -> -32767 127 -> -128 128 -> 128 255 -> 32767 uint16 -> float 0 -> -1 32767 -> -0.000015 32768 -> 0.000015 65535 -> 1
in_rate¶ (float 或 TensorList of float, 可选) –
输入采样率。
输入样本的采样率。此参数必须与
out_rate一起指定。该值相对于out_rate，并且不需要使用任何特定单位，只要输入和输出速率的单位匹配即可。in_rate和out_rate参数不能与scale或out_length一起指定。out_length¶ (int 或 TensorList of int, 可选) –
请求的输出长度，以样本为单位。
out_rate¶ (float 或 TensorList of float, 可选) –
输出采样率。
请求的输出采样率。此参数必须与
in_rate一起指定。该值相对于in_rate，并且不需要使用任何特定单位，只要输入和输出速率的单位匹配即可。in_rate和out_rate参数不能与scale或out_length一起指定。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中删除，即使其输出未使用。
quality¶ (float, 可选, 默认值 = 50.0) –
重采样质量，其中 0 为最低，100 为最高。
0 提供 3 个 sinc 滤波器瓣，50 提供 16 个瓣，100 提供 64 个瓣。
scale¶ (float 或 TensorList of float, 可选) –
缩放因子。
缩放因子是目标采样率与源采样率的比率。例如，
scale=2将生成输出，其样本数是输入的两倍。此参数不能与
in_rate和out_rate或out_length一起指定。
- class nvidia.dali.ops.BBoxPaste(*, bytes_per_sample_hint=[0], ltrb=False, paste_x=0.5, paste_y=0.5, preserve=False, ratio=None, device=None, name=None)#
转换边界框，使得在图像粘贴到更大的画布上后，框在图像中保持在相同的位置。
角坐标根据以下公式进行转换
(x', y') = (x/ratio + paste_x', y/ratio + paste_y')
框的大小（如果使用
xywh）根据以下公式进行转换(w', h') = (w/ratio, h/ratio)
其中
paste_x' = paste_x * (ratio - 1)/ratio paste_y' = paste_y * (ratio - 1)/ratio
粘贴坐标已归一化，因此
(0,0)将图像与画布的左上角对齐，而(1,1)将其与右下角对齐。- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
ltrb¶ (bool, optional, default = False) – 如果为 True，则为
ltrb格式；如果为 False，则为xywh格式。paste_x¶ (float 或 TensorList of float, optional, default = 0.5) – 粘贴在图像坐标中的水平位置 (0.0 - 1.0)。
paste_y¶ (float 或 TensorList of float, optional, default = 0.5) – 粘贴在图像坐标中的垂直位置 (0.0 - 1.0)。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
ratio¶ (float 或 TensorList of float) – 画布大小与输入大小的比率；该值必须至少为 1。
- class nvidia.dali.ops.BatchPermutation(*, allow_repetitions=False, bytes_per_sample_hint=[0], no_fixed_points=False, preserve=False, seed=-1, device=None, name=None)#
生成一批随机整数，可用作批次中索引样本的索引。
- 支持的后端
‘cpu’
- 关键字参数:
allow_repetitions¶ (bool, optional, default = False) – 如果为 true，则输出可以包含重复项和遗漏项。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
no_fixed_points¶ (bool, optional, default = False) – 如果为 true，则输出置换不能包含不动点，即
out[i] != i。当批次大小为 1 时，此参数将被忽略。preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
- __call__(*, allow_repetitions=False, bytes_per_sample_hint=[0], no_fixed_points=False, preserve=False, seed=-1, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.BbFlip(*, bytes_per_sample_hint=[0], horizontal=1, ltrb=False, preserve=False, vertical=0, device=None, name=None)#
水平或垂直翻转（镜像）边界框。
输入的边界框坐标采用 [x, y, width, height] -
xywh或 [left, top, right, bottom] -ltrb格式。所有坐标都在图像坐标系中，即 0.0-1.0- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
horizontal¶ (int 或 TensorList of int, optional, default = 1) – 水平维度翻转。
ltrb¶ (bool, optional, default = False) – 如果为 True，则为
ltrb格式；如果为 False，则为xywh格式。preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
vertical¶ (int 或 TensorList of int, optional, default = 0) – 垂直维度翻转。
- class nvidia.dali.ops.BoxEncoder(*, anchors=None, bytes_per_sample_hint=[0], criteria=0.5, means=[0.0, 0.0, 0.0, 0.0], offset=False, preserve=False, scale=1.0, stds=[1.0, 1.0, 1.0, 1.0], device=None, name=None)#
使用作为参数传递的一组默认框（锚框）来编码输入边界框和标签。
此算子遵循 “SSD: Single Shot MultiBox Detector” 中描述的算法，并在 mlperf/training 中实现。输入必须作为以下 Tensor 提供
BBoxes，其中包含表示为[l,t,r,b]的边界框。Labels，其中包含每个边界框的相应标签。
结果是两个 tensor
EncodedBBoxes，其中包含 M 编码的边界框，格式为[l,t,r,b]，其中 M 是锚框的数量。EncodedLabels，其中包含每个编码框的相应标签。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
anchors¶ (float 或 list of float) – 用于编码的锚框，浮点列表采用
ltrb格式。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
criteria¶ (float, optional, default = 0.5) –
用于将边界框与锚框匹配的 IoU 阈值。
该值需要在 0 到 1 之间。
means¶ (float 或 list of float, optional, default = [0.0, 0.0, 0.0, 0.0]) – 用于归一化的 [x y w h] 均值。
offset¶ (bool, optional, default = False) – 在 EncodedBBoxes 中返回归一化的偏移量
((encoded_bboxes*scale - anchors*scale) - mean) / stds，该偏移量使用std和mean以及scale参数。preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
scale¶ (float, optional, default = 1.0) – 在计算偏移量之前，重新缩放框和锚框值（例如，返回到绝对值）。
stds¶ (float 或 list of float, optional, default = [1.0, 1.0, 1.0, 1.0]) – 用于偏移量归一化的 [x y w h] 标准差。
- __call__(__input_0, __input_1, /, *, anchors=None, bytes_per_sample_hint=[0], criteria=0.5, means=[0.0, 0.0, 0.0, 0.0], offset=False, preserve=False, scale=1.0, stds=[1.0, 1.0, 1.0, 1.0], device=None, name=None)#
请参阅
nvidia.dali.ops.BoxEncoder()类以获取完整信息。
- class nvidia.dali.ops.Brightness(*, brightness=1.0, brightness_shift=0.0, bytes_per_sample_hint=[0], dtype=None, preserve=False, device=None, name=None)#
调整图像的亮度。
亮度根据以下公式进行调整
out = brightness_shift * output_range + brightness * in
其中 output_range 对于浮点输出为 1，对于整数类型为最大正值。
此算子还可以更改数据类型。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
brightness¶ (float 或 TensorList of float, optional, default = 1.0) –
亮度乘数。
支持
per-frame输入。brightness_shift¶ (float 或 TensorList of float, optional, default = 0.0) –
亮度偏移量。
对于有符号类型，1.0 表示该类型可以表示的最大正值。
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
如果未设置，则使用输入类型。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
- class nvidia.dali.ops.BrightnessContrast(*, brightness=1.0, brightness_shift=0.0, bytes_per_sample_hint=[0], contrast=1.0, contrast_center=0.5, dtype=None, preserve=False, device=None, name=None)#
调整图像的亮度和对比度。
亮度和对比度根据以下公式进行调整
out = brightness_shift * output_range + brightness * (contrast_center + contrast * (in - contrast_center))
其中 output_range 对于浮点输出为 1，对于整数类型为最大正值。
此算子还可以更改数据类型。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
brightness¶ (float 或 TensorList of float, optional, default = 1.0) –
亮度乘数。
支持
per-frame输入。brightness_shift¶ (float 或 TensorList of float, optional, default = 0.0) –
亮度偏移量。
对于有符号类型，1.0 表示该类型可以表示的最大正值。
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
contrast¶ (float 或 TensorList of float, optional, default = 1.0) –
对比度乘数，其中 0.0 产生均匀的灰色。
支持
per-frame输入。contrast_center¶ (float 或 TensorList of float, optional, default = 0.5) –
不受对比度影响的强度级别。
这是当对比度为零时所有像素都假定的值。 如果未设置，则使用输入类型正范围的一半（或对于
float类型为 0.5）。支持
per-frame输入。dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
如果未设置，则使用输入类型。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
- 类 nvidia.dali.ops.COCOReader(*, annotations_file='', avoid_class_remapping=False, bytes_per_sample_hint=[0], dont_use_mmap=False, file_root=None, image_ids=False, images=None, include_iscrowd=True, initial_fill=1024, lazy_init=False, ltrb=False, num_shards=1, pad_last_batch=False, pixelwise_masks=False, polygon_masks=False, prefetch_queue_depth=1, preprocessed_annotations='', preserve=False, random_shuffle=False, ratio=False, read_ahead=False, save_preprocessed_annotations=False, save_preprocessed_annotations_dir='', seed=-1, shard_id=0, shuffle_after_epoch=False, size_threshold=0.1, skip_cached_images=False, skip_empty=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
警告
此运算符现已弃用。请改用
readers.COCO()。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。readers.coco()的旧别名。
- 类 nvidia.dali.ops.Caffe2Reader(*, additional_inputs=0, bbox=False, bytes_per_sample_hint=[0], dont_use_mmap=False, image_available=True, initial_fill=1024, label_type=0, lazy_init=False, num_labels=1, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
警告
此运算符现已弃用。请改用
readers.Caffe2()。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。readers.caffe2()的旧别名。
- 类 nvidia.dali.ops.CaffeReader(*, bytes_per_sample_hint=[0], dont_use_mmap=False, image_available=True, initial_fill=1024, label_available=True, lazy_init=False, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
警告
此运算符现已弃用。请改用
readers.Caffe()。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。readers.caffe()的旧别名。
- 类 nvidia.dali.ops.Cast(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, device=None, name=None)#
将张量转换为不同的类型。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType) – 输出数据类型。preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也防止其从图中移除。
- 类 nvidia.dali.ops.CastLike(*, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
将第一个张量转换为第二个张量的类型。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
- __call__(__input_0, __input_1, /, *, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.CastLike()类。
- 类 nvidia.dali.ops.Cat(*, axis=0, axis_name=None, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
沿现有轴连接输入张量。
除了连接轴之外，输入的形状在所有维度上必须匹配。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axis¶ (int，可选，默认值 = 0) –
输入张量沿其连接的轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
axis_name¶ (str, 可选) –
张量沿其连接的轴的名称。
此参数与
axis互斥。此参数要求至少一个输入具有非空布局，并且所有非空输入布局都匹配。bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也防止其从图中移除。
- __call__(__input_0, __input_1, /, *__input_, axis=0, axis_name=None, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.Cat()类。
- 类 nvidia.dali.ops.CoinFlip(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, probability=0.5, seed=-1, shape=None, device=None, name=None)#
警告
此运算符现已弃用。请改用
random.CoinFlip()。生成服从伯努利分布的随机布尔值。
生成值 1（真）的概率由
probability参数确定。生成数据的形状可以通过
shape参数显式指定，或者选择与输入形状匹配（如果提供）。 如果两者都不存在，则每个样本生成一个值。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也防止其从图中移除。
probability¶ (float 或 float 的 TensorList，可选，默认值 = 0.5) – 值 1 的概率。
seed¶ (int，可选，默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表 或 int 的 TensorList, 可选) – 输出数据的形状。
- class nvidia.dali.ops.ColorSpaceConversion(*, bytes_per_sample_hint=[0], image_type=None, output_type=None, preserve=False, device=None, name=None)#
在各种图像颜色模型之间进行转换。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
image_type¶ (
nvidia.dali.types.DALIImageType) – 输入图像的颜色空间。output_type¶ (
nvidia.dali.types.DALIImageType) – 输出图像的颜色空间。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
- class nvidia.dali.ops.ColorTwist(*, brightness=1.0, bytes_per_sample_hint=[0], contrast=1.0, dtype=None, hue=0.0, image_type=DALIImageType.RGB, preserve=False, saturation=1.0, device=None, name=None)#
调整图像的色调、饱和度、亮度和对比度。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
brightness¶ (float 或 TensorList of float, optional, default = 1.0) –
亮度变化因子。
值必须为非负数。
示例值
0 - 黑色图像。
1 - 无变化。
2 - 亮度增加两倍。
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
contrast¶ (float 或 TensorList of float, optional, default = 1.0) –
对比度变化因子。
值必须为非负数。
示例值
0 - 均匀灰色图像。
1 - 无变化。
2 - 亮度增加两倍。
支持
per-frame输入。dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
如果未设置，则使用输入类型。
hue¶ (float 或 TensorList of float, optional, default = 0.0) –
色调变化，以度为单位。
支持
per-frame输入。image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 输入和输出图像的颜色空间。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
saturation¶ (float 或 TensorList of float, optional, default = 1.0) –
饱和度变化因子。
值必须为非负数。
示例值
0 - 完全去饱和的图像。
1 - 图像的饱和度无变化。
支持
per-frame输入。
- nvidia.dali.ops.Compose(op_list)#
返回一个元运算符，该运算符链接 op_list 中的操作。
返回值是一个可调用对象，当调用时，执行以下操作
op_list[n-1](op_list([n-2](... op_list[0](args))))
只有当列表中前一个运算符的所有输出都可以被下一个运算符直接处理时，运算符才能被组合。
下面的示例链式连接了一个图像解码器和一个具有随机正方形大小的 Resize 操作。
decode_and_resize对象可以像运算符一样被调用decode_and_resize = ops.Compose([ ops.decoders.Image(device="cpu"), ops.Resize(size=fn.random.uniform(range=400,500)), device="gpu") ]) files, labels = fn.readers.caffe(path=caffe_db_folder, seed=1) pipe.set_outputs(decode_and_resize(files), labels)
如果在 op_list 的中间存在从 CPU 到 GPU 的转换，如本例所示，
Compose会自动安排将数据复制到 GPU 内存。注意
这是一个实验性功能，如有更改，恕不另行通知。
- class nvidia.dali.ops.Contrast(*, bytes_per_sample_hint=[0], contrast=1.0, contrast_center=0.5, dtype=None, preserve=False, device=None, name=None)#
调整图像的对比度。
对比度根据以下公式进行调整
out = contrast_center + contrast * (in - contrast_center)
此算子还可以更改数据类型。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
contrast¶ (float 或 TensorList of float, optional, default = 1.0) –
对比度乘数，其中 0.0 产生均匀的灰色。
支持
per-frame输入。contrast_center¶ (float 或 TensorList of float, optional, default = 0.5) –
不受对比度影响的强度级别。
这是当对比度为零时所有像素都假定的值。 如果未设置，则使用输入类型正范围的一半（或对于
float类型为 0.5）。支持
per-frame输入。dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
如果未设置，则使用输入类型。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
- class nvidia.dali.ops.CoordFlip(*, bytes_per_sample_hint=[0], center_x=0.5, center_y=0.5, center_z=0.5, flip_x=1, flip_y=0, flip_z=0, layout='', preserve=False, device=None, name=None)#
通过相对于给定中心翻转（反射）坐标来变换向量或点。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
center_x¶ (float 或 TensorList of float, optional, default = 0.5) – 水平轴上的翻转中心。
center_y¶ (float 或 TensorList of float, optional, default = 0.5) – 垂直轴上的翻转中心。
center_z¶ (float 或 TensorList of float, optional, default = 0.5) – 深度轴上的翻转中心。
flip_x¶ (int 或 TensorList of int, optional, default = 1) – 翻转水平 (x) 坐标。
flip_y¶ (int 或 TensorList of int, optional, default = 0) – 翻转垂直 (y) 坐标。
flip_z¶ (int 或 TensorList of int, optional, default = 0) – 翻转深度 (z) 坐标。
layout¶ (layout str, optional, default = ‘’) –
确定输入中坐标的顺序。
字符串应包含以下字符
“x”（水平坐标），
“y”（垂直坐标），
“z”（深度坐标），
注意
如果留空，则根据维度数量，假定值为“x”、“xy”或“xyz”。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
- class nvidia.dali.ops.CoordTransform(*, M=None, MT=None, T=None, bytes_per_sample_hint=[0], dtype=DALIDataType.FLOAT, preserve=False, device=None, name=None)#
对点或向量应用线性变换。
变换形式为
out = M * in + T
其中
M是一个m x n矩阵，T是一个具有 m 个分量的平移向量。输入必须由 n 元素向量或点组成，输出具有 m 个分量。此运算符可用于许多操作。这是一个（不完整的）列表
对点云应用仿射变换
将点投影到子空间
一些颜色空间转换，例如 RGB 到 YCbCr 或灰度
对颜色进行线性运算，如色调旋转、亮度和对比度调整
此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
M¶ (float 或 list of float 或 TensorList of float, optional) –
用于变换输入向量的矩阵。
如果未指定，则使用单位矩阵。
矩阵
M不需要是方阵 - 如果不是，则输出向量将具有等于M中行数的组件数量。如果提供标量值，则假定
M是对角线上具有该值的方阵。然后假定矩阵的大小与输入向量中分量的数量相匹配。支持
per-frame输入。MT¶ (float 或 list of float 或 TensorList of float, optional) –
为此参数提供标量值等效于为 M 提供相同的标量并保持 T 未指定。
列数必须比输入中分量的数量多一个。此参数与
M和T互斥。支持
per-frame输入。T¶ (float 或 list of float 或 TensorList of float, optional) –
平移向量。
如果未指定，则不应用平移，除非使用 MT 参数。
此向量的分量数必须与矩阵
M中的行数匹配。如果提供标量值，则该值将广播到T的所有分量，并且选择分量数以匹配M中的行数。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) –输出坐标的数据类型。
如果使用整数类型，则输出值将四舍五入到最接近的整数并 clamped 到此类型的动态范围。
preserve¶ (bool, optional, default = False) – 即使其输出未被使用，也防止运算符从图中移除。
- class nvidia.dali.ops.Copy(*, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
创建输入张量的副本。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
- class nvidia.dali.ops.Crop(*, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=None, fill_values=[0.0], out_of_bounds_policy='error', preserve=False, rounding='round', device=None, name=None)#
使用指定的窗口尺寸和窗口位置（左上角）裁剪图像。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop¶ (float 或 float 列表或 TensorList of float, optional) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 TensorList of float, optional, default = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w、crop_h和crop_d必须一起指定。为crop_w、crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 TensorList of float, optional, default = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 TensorList of float, optional, default = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，crop_W是裁剪窗口的宽度。有关
crop_x如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_y¶ (float 或 TensorList of float, optional, default = 0.5) –
裁剪窗口起始位置（通常为左上角）的归一化 (0.0 - 1.0) 垂直位置。
实际位置计算为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，crop_H是裁剪窗口的高度。有关
crop_y如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_z¶ (float 或 TensorList of float, optional, default = 0.5) –
仅适用于体积输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，crop_D是裁剪窗口的深度。有关
crop_z如何转换为整数值的更多详细信息，请参阅rounding参数。crop_w¶ (float 或 TensorList of float, optional, default = 0.0) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
支持的类型：
FLOAT、FLOAT16和UINT8。如果未设置，则使用输入类型。
fill_values¶ (float 或 list of float, optional, default = [0.0]) –
确定填充值，仅当
out_of_bounds_policy设置为 “pad” 时才相关。如果提供标量值，则将用于所有通道。如果提供多个值，则值的数量和通道数必须相同（输出切片中维度
C的范围）。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 不再使用，将在未来版本中删除。
out_of_bounds_policy¶ (str, optional, default = ‘error’) –
确定在对输入进行越界区域切片时的策略。
以下是支持值的列表
"error"(默认)：尝试在输入边界之外切片将产生错误。"pad"：输入将根据需要使用零或使用fill_values参数指定的任何其他值进行填充。"trim_to_shape"：切片窗口将被裁剪到输入的边界。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool, optional, default = False) – 即使其输出未被使用，也防止运算符从图中移除。
rounding¶ (str, optional, default = ‘round’) –
确定用于将窗口的起始坐标转换为整数值的舍入函数（请参阅
crop_pos_x、crop_pos_y、crop_pos_z）。可能的值为
"round"- 四舍五入到最接近的整数值，中间值四舍五入到远离零的值。"truncate"- 丢弃数字的小数部分（向零截断）。
- __call__(__input, /, *, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=None, fill_values=[0.0], out_of_bounds_policy='error', preserve=False, rounding='round', device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'CHW', 'DHWC', 'CDHW', 'FHWC', 'FCHW', 'CFHW', 'FDHWC', 'FCDHW', 'CFDHW')) – 运算符的输入。
- class nvidia.dali.ops.CropMirrorNormalize(*, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=DALIDataType.FLOAT, fill_values=[0.0], mean=[0.0], mirror=0, out_of_bounds_policy='error', output_layout='CHW', pad_output=False, preserve=False, rounding='round', scale=1.0, shift=0.0, std=[1.0], device=None, name=None)#
执行融合的裁剪、归一化、格式转换（NHWC 到 NCHW，如果需要）和类型转换。
归一化采用输入图像，并通过使用以下公式生成输出
output = scale * (input - mean) / std + shift
注意
如果未指定裁剪参数，则只会发生镜像和归一化。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop¶ (float 或 float 列表或 TensorList of float, optional) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 TensorList of float, optional, default = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w、crop_h和crop_d必须一起指定。为crop_w、crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 TensorList of float, optional, default = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 TensorList of float, optional, default = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，crop_W是裁剪窗口的宽度。有关
crop_x如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_y¶ (float 或 TensorList of float, optional, default = 0.5) –
裁剪窗口起始位置（通常为左上角）的归一化 (0.0 - 1.0) 垂直位置。
实际位置计算为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，crop_H是裁剪窗口的高度。有关
crop_y如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_z¶ (float 或 TensorList of float, optional, default = 0.5) –
仅适用于体积输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，crop_D是裁剪窗口的深度。有关
crop_z如何转换为整数值的更多详细信息，请参阅rounding参数。crop_w¶ (float 或 TensorList of float, optional, default = 0.0) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) –输出数据类型。
支持的类型：
FLOAT、FLOAT16、INT8、UINT8。fill_values¶ (float 或 list of float, optional, default = [0.0]) –
确定填充值，并且仅当
out_of_bounds_policy设置为 “pad” 时才相关。如果提供标量值，则将用于所有通道。如果提供多个值，则值的数量和通道数必须相同（输出切片中维度
C的范围）。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 不再使用，将在未来版本中删除。
mean¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = [0.0]) – 用于图像归一化的像素均值。
mirror¶ (int 或 int 的 TensorList, 可选, 默认值 = 0) – 如果非零，图像将水平翻转（镜像）。
out_of_bounds_policy¶ (str, 可选, 默认值 = ‘error’) –
确定在对输入进行越界区域切片时的策略。
以下是支持值的列表
"error"(默认)：尝试在输入边界之外切片将产生错误。"pad": 如有需要，将使用零或使用fill_values参数指定的任何其他值填充输入。"trim_to_shape"：切片窗口将被裁剪到输入的边界。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –output_layout¶ (layout str, 可选, 默认值 = ‘CHW’) – 输出的 Tensor 数据布局。
pad_output¶ (bool, 可选, 默认值 = False) –
确定是否填充输出，使通道数是 2 的幂。
用于填充的值由
fill_values参数确定。preserve¶ (bool, 可选, 默认值 = False) – 即使其输出未使用，也阻止从图中删除算子。
rounding¶ (str, 可选, 默认值 = ‘round’) –
确定用于将窗口的起始坐标转换为整数值的舍入函数（参见
crop_pos_x,crop_pos_y,crop_pos_z）。可能的值为
"round"- 四舍五入到最接近的整数值，中间值四舍五入到远离零的值。"truncate"- 丢弃数字的小数部分（向零截断）。
scale¶ (float, 可选, 默认值 = 1.0) –
结果乘以的值。
当使用整数输出以提高动态范围利用率时，此参数很有用。
shift¶ (float, 可选, 默认值 = 0.0) –
添加到（缩放）结果的值。
当使用无符号整数输出以提高动态范围利用率时，此参数很有用。
std¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = [1.0]) – 用于图像归一化的标准差值。
- __call__(__input, /, *, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=DALIDataType.FLOAT, fill_values=[0.0], mean=[0.0], mirror=0, out_of_bounds_policy='error', output_layout='CHW', pad_output=False, preserve=False, rounding='round', scale=1.0, shift=0.0, std=[1.0], device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'CHW', 'DHWC', 'CDHW', 'FHWC', 'FCHW', 'CFHW', 'FDHWC', 'FCDHW', 'CFDHW')) – 算子的输入。
- class nvidia.dali.ops.DLTensorPythonFunction(function, num_outputs=1, device='cpu', synchronize_stream=True, batch_processing=True, **kwargs)#
执行一个处理 DLPack 张量的 Python 函数。
该函数不应修改输入张量。
对于 GPU 算子，用户有责任将设备代码与 DALI 同步。为了将设备代码与 DALI 同步，请在算子调用之前使用 `synchronize_stream` 标志（默认启用）同步 DALI 的工作，并确保在算子调用中完成计划的设备任务。GPU 代码可以在 DALI 使用的 CUDA 流上执行，可以通过调用 `
current_dali_stream()` 函数获得该 CUDA 流。在这种情况下，可以将 `synchronize_stream` 标志设置为 False。警告
此算子与 TensorFlow 集成不兼容。
此算子允许序列输入并支持体积数据。
此算子将**不会**从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
batch_processing¶ (bool, 可选, 默认值 = False) –
确定函数是为每个批次调用一次，还是为批次中的每个样本单独调用。
如果设置为 True，函数将接收其参数作为 DLPack 张量列表。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
function¶ (object) –
定义算子功能的 Callable 对象。
警告
该函数不得持有对其使用的 Pipeline 的引用。如果持有，将形成对 Pipeline 的循环引用，并且 Pipeline 将永远不会被释放。
num_outputs¶ (int, 可选, 默认值 = 1) – 输出数量。
output_layouts¶ (layout str 或 layout str 列表, 可选) –
输出的 Tensor 数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则仅前几个输出设置了布局，其余输出未分配布局。
preserve¶ (bool, 可选, 默认值 = False) – 即使其输出未使用，也阻止从图中删除算子。
synchronize_stream¶ (bool, 可选, 默认值 = True) –
确保 DALI 在调用 Python 函数之前同步其 CUDA 流。
警告
仅当调用的函数将设备工作调度到 DALI 使用的流时，才应将此参数设置为 False。
- class nvidia.dali.ops.DumpImage(*, bytes_per_sample_hint=[0], input_layout='HWC', preserve=False, suffix='', device=None, name=None)#
以 PPM 格式将批处理图像保存到磁盘。
用于调试。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
input_layout¶ (layout str, 可选, 默认值 = ‘HWC’) – 输入图像的布局。
preserve¶ (bool, 可选, 默认值 = False) – 即使其输出未使用，也阻止从图中删除算子。
suffix¶ (str, 可选, 默认值 = ‘’) – 要添加到输出文件名的后缀。
- class nvidia.dali.ops.ElementExtract(*, bytes_per_sample_hint=[0], element_map=None, preserve=False, device=None, name=None)#
从输入序列中提取一个或多个元素。
输出是输入序列的第一个（最外层）维度的切片。输出的数量与
element_map中提供的元素数量相同。例如，对于 `
element_map = [2, 0, 3]`，将有三个输出，分别包含输入序列的第 2、第 0 和第 3 个元素。如果提供了输入布局，则必须以 `
F` 维度开头。输出的维度将比输入少一个，也就是说，对于 `FHWC` 输入，输出将是 `HWC` 元素。此算子期望序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
- class nvidia.dali.ops.Erase(*, anchor=[], axes=[1, 0], axis_names='HW', bytes_per_sample_hint=[0], centered_anchor=False, fill_value=[0.0], normalized=False, normalized_anchor=False, normalized_shape=False, preserve=False, shape=[], device=None, name=None)#
从输入张量中擦除一个或多个区域。
区域由
anchor（起始点）和shape（尺寸）指定。仅指定相关维度。未指定的维度被视为提供了轴的整个范围。要指定多个区域，anchor和shape连续表示多个点（例如，`anchor` = (y0, x0, y1, x1, …)，`shape` = (h0, w0, h1, w1, …)）。`anchor` 和 `shape` 参数根据 `axis_names` 参数的值或 `axes` 参数的值进行解释。如果未提供 `axis_names` 或 `axes` 参数，则必须指定除 `C`（通道）外的所有维度。示例 1
anchor= (10, 20),shape= (190, 200),axis_names= “HW”,fill_value= 0输入：`
layout` = “HWC”, `shape` = (300, 300, 3)擦除区域覆盖垂直维度（高度）上 10 到 200 之间的范围，以及水平维度（宽度）上 20 到 220 之间的范围。通道维度的范围未指定，因此在 0 到 3 之间。结果是
output[y, x, c] = 0 if 20 <= x < 220 and 10 <= y < 200 output[y, x, c] = input[y, x, c] otherwise
示例 2
anchor= (10, 250),shape= (20, 30),axis_names= “W”,fill_value= (118, 185, 0)输入：`
layout` = “HWC”, `shape` = (300, 300, 3)提供了两个擦除区域，它们覆盖了两个垂直条带，范围分别为 x=(10, 30) 和 x=(250, 280)。擦除区域中的每个像素都填充了多通道值 (118, 185, 0)。结果是
output[y, x, :] = (118, 185, 0) if 10 <= x < 30 or 250 <= x < 280 output[y, x, :] = input[y, x, :] otherwise
示例 3
anchor= (0.15, 0.15),shape= (0.3, 0.3),axis_names= “HW”,fill_value= 100,normalized= True输入：`
layout` = “HWC”, `shape` = (300, 300, 3)提供了一个擦除区域，该区域的高度和宽度维度使用了归一化坐标。为所有通道提供了填充值。坐标可以通过乘以输入形状转换为绝对坐标。结果是
if (0.15 * 300 <= x < (0.3 + 0.15) * 300 and 0.15 * 300 <= y < (0.3 + 0.15) * 300(): output[y, x, c] = 100 else: output[y, x, c] = input[y, x, c]
示例 4：
anchor= (0.15, 0.15),shape= (20, 30),normalized_anchor= True,normalized_shape= False输入：`
layout` = “HWC”, `shape` = (300, 300, 3)指定了一个擦除区域，其锚点以归一化坐标指定，形状以绝对坐标指定。由于没有提供 axis_names，因此锚点和形状必须包含除 “C”（通道）外的所有维度。结果是
if (0.15 * 300 <= x < (0.15 * 300) + 20 and (0.15 * 300) <= y < (0.15 * 300) + 30): output[y, x, c] = 0 else: output[y, x, c] = input[y, x, c]
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
anchor¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = []) –
擦除区域的锚点或起点的坐标。
仅应提供由 axis_names 或 axes 指定的相关维度的坐标。
axes¶ (int 或 int 列表, 可选, 默认值 = [1, 0]) –
用于 anchor 和 shape 参数的维度顺序，以维度索引表示。
例如，axes=(1, 0) 表示 *anchor* 和 *shape* 中的坐标按特定顺序引用轴 1 和轴 0。
axis_names¶ (str, 可选, 默认值 = ‘HW’) –
用于 anchor 和 shape 参数的维度顺序，如布局中所述。
例如，axis_names=”HW” 表示 *anchor* 和 *shape* 中的坐标按特定顺序引用维度 H（高度）和 W（宽度）。
注意
axis_name*s 的优先级高于 *axes。.
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
centered_anchor¶ (bool, optional, default = False) –
如果设置为 True，则锚点将指向区域的中心而不是左上角。
这将在指定的 *anchor* 位置产生居中擦除区域。
fill_value¶ (float 或 list of float 或 TensorList of float, optional, default = [0.0]) –
用于填充擦除区域的值。
可以指定为单个值（例如，0）或多通道值（例如，(200, 210, 220)）。如果提供多通道填充值，则输入布局应包含通道维度
C。normalized¶ (bool, optional, default = False) –
确定锚点和形状参数应解释为归一化坐标（范围 [0.0, 1.0]）还是绝对坐标。
分别为 normalized_shape 和 normalized_anchor 参数提供值是互斥的。
normalized_anchor¶ (bool, optional, default = False) –
确定锚点参数应解释为归一化坐标（范围 [0.0, 1.0]）还是绝对坐标。
为 normalized 提供值是互斥的。
normalized_shape¶ (bool, optional, default = False) –
确定形状参数应解释为归一化坐标（范围 [0.0, 1.0]）还是绝对坐标。
为 normalized 提供值是互斥的。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止将其从图中移除。
shape¶ (float 或 list of float 或 TensorList of float, optional, default = []) –
擦除区域的形状或尺寸的值。
仅应提供由 axis_names 或 axes 指定的相关维度的坐标。
- class nvidia.dali.ops.ExpandDims(*, axes=None, bytes_per_sample_hint=[0], new_axis_names='', preserve=False, device=None, name=None)#
向数据形状插入维度为 1 的新维度。
新维度插入的位置由
axes指定。如果提供了
new_axis_names，新维度名称将插入到数据布局中，位置由axes指定。如果未提供new_axis_names，则输出数据布局将为空。”此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list of int 或 TensorList of int) – 插入新维度的索引。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
new_axis_names¶ (layout str, optional, default = ‘’) –
数据布局中新维度的名称。
*new_axis_names* 的长度必须与 *axes* 的长度匹配。如果未提供参数，布局将被清除。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止将其从图中移除。
- class nvidia.dali.ops.ExternalSource(source=None, num_outputs=None, *, cycle=None, layout=None, dtype=None, ndim=None, name=None, device='cpu', cuda_stream=None, use_copy_kernel=None, batch=None, parallel=None, no_copy=None, prefetch_queue_depth=None, bytes_per_sample_hint=None, batch_info=None, repeat_last=False, **kwargs)#
ExternalSource 是一个特殊的运算符，可以通过多种方法从 Python 向 DALI 管道提供数据。
最简单和首选的方法是指定一个
source，它可以是可调用对象或可迭代对象。注意
nvidia.dali.fn.external_source()运算符通过nvidia.dali.plugin.tf.experimental.DALIDatasetWithInputs()与 TensorFlow 集成部分兼容。有关详细信息，请参阅其文档。注意
要返回同一张量的批量副本，请使用
nvidia.dali.types.Constant()，这更高效。- 参数:
source¶ (callable 或 iterable) –
数据的来源。
当管道需要下一迭代的输入时，会轮询数据源（通过调用
source()或next(source)）。根据 num_outputs 的值，数据源可以提供一个或多个数据项。数据项可以是整个批次（默认）或单个批次条目（当batch==False时）。如果未设置 num_outputs，则source应返回一个项目（批次或样本）。如果指定了此值（即使其值为 1），则数据应为元组或列表，其中每个元素对应于 external_source 的相应返回值。数据样本必须是以下兼容的数组类型之一
NumPy ndarray (CPU)
MXNet ndarray (CPU)
PyTorch 张量 (CPU 或 GPU)
CuPy 数组 (GPU)
实现
__cuda_array_interface__的对象DALI 张量对象
批次数据源必须生成完整的数据批次。这可以通过向数组添加新的最外层维度或返回数组列表来实现（在这种情况下，它们的大小可以不同，但必须具有相同的秩和元素类型）。批次数据源还可以生成 DALI TensorList 对象，这可以是另一个 DALI 管道的输出。
每个批次的数据源可以接受一个位置参数。如果接受，则它是当前迭代在 epoch 中的索引，连续调用将是
source(0)、source(1)等。如果 batch_info 设置为 True，则nvidia.dali.types.BatchInfo的实例将传递给数据源，而不是普通索引。每个样本的数据源可以接受一个
nvidia.dali.types.SampleInfo类型的位置参数，其中包含当前 epoch 和批次中样本的索引，以及当前迭代次数。如果数据源是生成器函数，则会调用该函数并将其视为可迭代对象。但是，与生成器不同，该函数可以与
cycle一起使用。在这种情况下，当生成器到达迭代结束时，将再次调用该函数。对于 GPU 输入，用户有责任仅在提供的流中修改提供的 GPU 内存内容。DALI 在此流上安排复制，并且所有工作都已正确排队。如果未提供流，DALI 将使用默认流，并尽力确保正确性。有关更多信息，请参阅
cuda_stream参数文档。注意
从检查点恢复后，对单参数可调用对象（接受
nvidia.dali.types.SampleInfo、nvidia.dali.types.BatchInfo或批次索引）的数据源的查询将从检查点中保存的 epoch 和迭代恢复。num_outputs¶ (int, optional) –
如果指定，表示源函数生成的 TensorList 的数量。
如果设置，运算符将返回 DataNode 对象列表，否则返回单个 DataNode 对象。
- 关键字参数:
cycle¶ (string 或 bool, optional) –
指定是否以及如何循环遍历数据源。它可以是以下值之一
"no",False或None- 不循环；当
数据结束时，会引发
StopIteration异常；这是默认行为 *"quiet"或True- 数据无限重复， *"raise"- 当数据结束时，会引发StopIteration异常，但在后续调用时会重新开始迭代。此标志要求
source是一个集合，例如，一个可迭代对象，其中iter(source)在每次调用时返回一个新的迭代器，或者是一个生成器函数。在后一种情况下，当请求的数据多于函数生成的数据时，将再次调用生成器函数。指定
"raise"可以与 DALI 迭代器一起使用来创建 epoch 的概念。name¶ (str, optional) –
数据节点的名称。
在调用
feed_input馈送数据时使用，如果数据由source提供，则可以省略。layout¶ (layout str 或 list/tuple thereof, optional) –
如果提供，则设置数据的布局。
当
num_outputs > 1时，layout 可以是一个列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则只有前几个输出设置了布局，其余输出没有设置布局。dtype¶ (nvidia.dali.types.DALIDataType 或 list/tuple thereof, optional) –
输入数据类型。
当
num_outputs > 1时，dtype可以是一个列表，其中包含每个输出的不同值。运算符将验证获取的数据是否为提供的类型。如果省略该参数或传递
DALIDataType.NO_TYPE，则运算符将从提供的数据中推断类型。从 DALI 2.0 开始，此参数将是必需的。
ndim¶ (int 或 list/tuple thereof, optional) –
输入数据中的维度数。
当
num_outputs > 1时，ndim可以是一个列表，其中包含每个输出的不同值。将根据此值验证提供给运算符的数据的维度。如果提供了
layout参数，也可以从layout参数推断维度数。如果提供了
layout参数，则ndim必须与布局中的维度数匹配。从 DALI 2.0 开始，指定输入维度将是必需的
cuda_stream¶ (optional,
cudaStream_t或可转换为cudaStream_t的对象,) –例如
cupy.cuda.Stream或torch.cuda.Stream。CUDA 流用于将数据复制到 GPU 或从 GPU 源复制数据。如果未设置此参数，将尽力保持正确性。也就是说，如果数据是从 CuPy 或 PyTorch 等公认的库以张量/数组形式提供的，则使用该库的当前流。虽然这种方法在典型情况下有效，但在高级用例以及使用不受支持的库的代码中，您可能需要显式提供流句柄。
此参数有两个特殊值
0 - 使用默认 CUDA 流
1 - 使用 DALI 的内部流
如果使用内部流，则对
feed_input的调用将阻塞，直到复制到内部缓冲区完成，因为无法与此流同步以防止在另一个流中使用新数据覆盖数组。use_copy_kernel¶ (bool, optional) –
如果设置为 True，DALI 将使用 CUDA 内核来馈送数据，而不是
cudaMemcpyAsync（默认）。注意
这仅在将数据复制到 GPU 内存和从 GPU 内存复制数据时适用。
blocking¶ (bool, optional) – 高级 如果为 True，则此运算符将阻塞，直到数据可用（例如，通过调用
feed_input）。如果为 False，则如果数据不可用，运算符将引发错误。no_copy¶ (bool, optional) –
确定在调用
feed_input时 DALI 是否应复制缓冲区。如果设置为 True，DALI 会将用户内存直接传递到管道，而不是复制它。用户有责任保持缓冲区活动且未修改，直到它被管道使用。
在相关迭代的输出被使用后，可以再次修改或释放缓冲区。实际上，这发生在管道的 prefetch_queue_depth 或
cpu_queue_depth * gpu_queue_depth（当它们不相等时）在feed_input调用之后的迭代之后。内存位置必须与运算符的指定 device 参数匹配。对于 CPU，提供的内存可以是一个连续缓冲区或一个连续张量列表。对于 GPU，为了避免额外的复制，提供的缓冲区必须是连续的。如果提供单独张量的列表，则会在内部进行额外的复制，从而消耗内存和带宽。
当
parallel=True时自动设置为 Truebatch¶ (bool, optional) –
如果设置为 True 或 None，则
source预计一次性生成整个批次。如果设置为 False，则source将按样本调用。batch_info¶ (bool, optional, default = False) – 控制可调用的
source（接受一个参数并返回批次）应接收 ~nvidia.dali.types.BatchInfo 实例还是仅接收表示迭代次数的整数。如果设置为 False（默认值），则仅传递整数。如果source不可调用、不接受参数或batch设置为 False，则设置此标志无效。parallel¶ (bool, optional, default = False) –
如果设置为 True，则相应的 pipeline 将启动一个 Python 工作进程池以并行运行回调函数。您可以通过将
py_num_workers传递到 pipeline 的构造函数中来指定工作进程的数量。当
parallel设置为 True 时，source返回的样本必须是 NumPy/MXNet/PyTorch CPU 数组或 TensorCPU 实例。可接受的 source 取决于为
batch参数指定的值。如果
batch设置为False，则source必须是- 可调用的对象（函数或具有
__call__方法的对象），它接受 恰好一个参数（
SampleInfo实例，表示所请求样本的索引）。
- 可调用的对象（函数或具有
如果
batch设置为True，则source可以是以下之一：- 可调用的对象，它接受恰好一个参数（
BatchInfo 实例或整数 - 有关详细信息，请参阅
batch_info）
- 可调用的对象，它接受恰好一个参数（
可迭代对象，
生成器函数。
警告
无论
batch值如何，可调用对象都应该是无状态的 - 它们应该仅基于SampleInfo/BatchInfo实例或批次中的索引来生成请求的样本或批次，以便它们可以在多个工作进程中并行运行。当数据结束时，
source回调函数必须引发StopIteration异常。请注意，由于预取，回调函数可能会在数据集结束后被调用几次迭代 - 请确保在这种情况下它始终如一地引发StopIteration异常。警告
当 pipeline 启用条件执行时，必须采取额外的步骤来防止
source被 AutoGraph 重写。 有两种方法可以实现这一点：1. 在全局作用域中定义函数（即在
pipeline_def作用域之外）。
2. 如果函数是另一个“工厂”函数的结果，则工厂函数必须在 pipeline 定义函数之外定义，并使用
@do_not_convert装饰器进行装饰。更多详细信息可以在
@do_not_convert文档中找到。注意
可调用的
source可以由多个工作进程并行运行。对于batch=True，可以并行准备多个批次；对于batch=False，可以并行化批次内的计算。当
batch=True时，可调用对象的性能可能会特别受益于增加prefetch_queue_depth，以便可以并行计算接下来的几个批次。注意
迭代器或生成器函数将被分配给单个工作进程，该工作进程将迭代它们。 主要优点是与主 Python 进程并行执行，但由于它们的状态，一次无法计算多个批次。
repeat_last¶ (bool, optional, default = False) –
注意
这是一个高级设置，主要用于带有解耦模型的 Triton Inference Server。
通常，
external_source消耗其输入数据，并期望在即将到来的迭代中馈入新的数据。 设置repeat_last=True会更改此行为，以便external_source将检测到在前一个 pipeline 运行和当前运行之间没有馈入新数据，并将使用最近的数据进行自我重新馈送。仅在“push”模式下设置
repeat_last为 True 才有意义，即当用户通过调用feed_input主动提供数据时。 启用此选项与指定source不兼容，这会使external_source在“pull”模式下运行。prefetch_queue_depth¶ (int, optional, default = 1) – 当在
parallel=True模式下运行时，指定要预先计算并存储在内部缓冲区中的批次数量，否则将忽略此参数。bytes_per_sample_hint¶ (int, optional, default = None) –
如果在
parallel=True模式下指定，则该值在计算工作进程用于将并行外部 source 输出传递到 pipeline 的共享内存槽的初始容量时充当提示。 在非并行模式下，此参数将被忽略。设置足够大的值以容纳传入数据可以防止 DALI 在 pipeline 运行期间重新分配共享内存。 此外，手动提供提示可以防止 DALI 高估必要的共享内存容量。
该值必须是正整数。 请注意，共享内存中的样本附带一些内部元数据，因此，对共享内存的实际需求略高于外部 source 生成的二进制数据的大小。 实际元数据大小取决于多种因素，例如，可能会在 Python 或 DALI 版本之间更改，恕不另行通知。
请参阅 pipeline 的
external_source_shm_statistics以检查为 pipeline 的并行外部 source 生成的数据分配了多少共享内存。
- __call__(*, source=None, cycle=None, name=None, layout=None, dtype=None, ndim=None, cuda_stream=None, use_copy_kernel=None, batch=None, parallel=None, no_copy=None, prefetch_queue_depth=None, bytes_per_sample_hint=None, batch_info=None, repeat_last=False, **kwargs)#
- 参数:
source¶ (callable or iterable) –
数据的来源。
当管道需要下一迭代的输入时，会轮询数据源（通过调用
source()或next(source)）。根据 num_outputs 的值，数据源可以提供一个或多个数据项。数据项可以是整个批次（默认）或单个批次条目（当batch==False时）。如果未设置 num_outputs，则source应返回一个项目（批次或样本）。如果指定了此值（即使其值为 1），则数据应为元组或列表，其中每个元素对应于 external_source 的相应返回值。数据样本必须是以下兼容的数组类型之一
NumPy ndarray (CPU)
MXNet ndarray (CPU)
PyTorch 张量 (CPU 或 GPU)
CuPy 数组 (GPU)
实现
__cuda_array_interface__的对象DALI 张量对象
批次数据源必须生成完整的数据批次。这可以通过向数组添加新的最外层维度或返回数组列表来实现（在这种情况下，它们的大小可以不同，但必须具有相同的秩和元素类型）。批次数据源还可以生成 DALI TensorList 对象，这可以是另一个 DALI 管道的输出。
每个批次的数据源可以接受一个位置参数。如果接受，则它是当前迭代在 epoch 中的索引，连续调用将是
source(0)、source(1)等。如果 batch_info 设置为 True，则nvidia.dali.types.BatchInfo的实例将传递给数据源，而不是普通索引。每个样本的数据源可以接受一个
nvidia.dali.types.SampleInfo类型的位置参数，其中包含当前 epoch 和批次中样本的索引，以及当前迭代次数。如果数据源是生成器函数，则会调用该函数并将其视为可迭代对象。但是，与生成器不同，该函数可以与
cycle一起使用。在这种情况下，当生成器到达迭代结束时，将再次调用该函数。对于 GPU 输入，用户有责任仅在提供的流中修改提供的 GPU 内存内容。DALI 在此流上安排复制，并且所有工作都已正确排队。如果未提供流，DALI 将使用默认流，并尽力确保正确性。有关更多信息，请参阅
cuda_stream参数文档。注意
从检查点恢复后，对单参数可调用对象（接受
nvidia.dali.types.SampleInfo、nvidia.dali.types.BatchInfo或批次索引）的数据源的查询将从检查点中保存的 epoch 和迭代恢复。num_outputs¶ (int, optional) –
如果指定，表示源函数生成的 TensorList 的数量。
如果设置，运算符将返回 DataNode 对象列表，否则返回单个 DataNode 对象。
- 关键字参数:
cycle¶ (string or bool, optional) –
指定是否以及如何循环遍历数据源。它可以是以下值之一
"no",False或None- 不循环；当
数据结束时，会引发
StopIteration异常；这是默认行为 *"quiet"或True- 数据无限重复， *"raise"- 当数据结束时，会引发StopIteration异常，但在后续调用时会重新开始迭代。此标志要求
source是一个集合，例如，一个可迭代对象，其中iter(source)在每次调用时返回一个新的迭代器，或者是一个生成器函数。在后一种情况下，当请求的数据多于函数生成的数据时，将再次调用生成器函数。指定
"raise"可以与 DALI 迭代器一起使用来创建 epoch 的概念。name¶ (str, optional) –
数据节点的名称。
在调用
feed_input馈送数据时使用，如果数据由source提供，则可以省略。layout¶ (layout str or list/tuple thereof, optional) –
如果提供，则设置数据的布局。
当
num_outputs > 1时，layout 可以是一个列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则只有前几个输出设置了布局，其余输出没有设置布局。dtype¶ (nvidia.dali.types.DALIDataType or list/tuple thereof, optional) –
输入数据类型。
当
num_outputs > 1时，dtype可以是一个列表，其中包含每个输出的不同值。运算符将验证获取的数据是否为提供的类型。如果省略该参数或传递
DALIDataType.NO_TYPE，则运算符将从提供的数据中推断类型。从 DALI 2.0 开始，此参数将是必需的。
ndim¶ (int or list/tuple thereof, optional) –
输入数据中的维度数。
当
num_outputs > 1时，ndim可以是一个列表，其中包含每个输出的不同值。将根据此值验证提供给运算符的数据的维度。如果提供了
layout参数，也可以从layout参数推断维度数。如果提供了
layout参数，则ndim必须与布局中的维度数匹配。从 DALI 2.0 开始，指定输入维度将是必需的
cuda_stream¶ (optional,
cudaStream_tor an object convertible tocudaStream_t,)例如
cupy.cuda.Stream或torch.cuda.Stream。CUDA 流用于将数据复制到 GPU 或从 GPU 源复制数据。如果未设置此参数，将尽力保持正确性。也就是说，如果数据是从 CuPy 或 PyTorch 等公认的库以张量/数组形式提供的，则使用该库的当前流。虽然这种方法在典型情况下有效，但在高级用例以及使用不受支持的库的代码中，您可能需要显式提供流句柄。
此参数有两个特殊值
0 - 使用默认 CUDA 流
1 - 使用 DALI 的内部流
如果使用内部流，则对
feed_input的调用将阻塞，直到复制到内部缓冲区完成，因为无法与此流同步以防止在另一个流中使用新数据覆盖数组。use_copy_kernel¶ (bool, optional) –
如果设置为 True，DALI 将使用 CUDA 内核来馈送数据，而不是
cudaMemcpyAsync（默认）。注意
这仅在将数据复制到 GPU 内存和从 GPU 内存复制数据时适用。
blocking¶ (bool, optional) – Advanced 如果为 True，则此运算符将阻塞，直到数据可用（例如，通过调用
feed_input）。如果为 False，则如果数据不可用，运算符将引发错误。no_copy¶ (bool, optional) –
确定在调用
feed_input时 DALI 是否应复制缓冲区。如果设置为 True，DALI 会将用户内存直接传递到管道，而不是复制它。用户有责任保持缓冲区活动且未修改，直到它被管道使用。
在相关迭代的输出被使用后，可以再次修改或释放缓冲区。实际上，这发生在管道的 prefetch_queue_depth 或
cpu_queue_depth * gpu_queue_depth（当它们不相等时）在feed_input调用之后的迭代之后。内存位置必须与运算符的指定 device 参数匹配。对于 CPU，提供的内存可以是一个连续缓冲区或一个连续张量列表。对于 GPU，为了避免额外的复制，提供的缓冲区必须是连续的。如果提供单独张量的列表，则会在内部进行额外的复制，从而消耗内存和带宽。
当
parallel=True时自动设置为 Truebatch¶ (bool, optional) –
如果设置为 True 或 None，则
source预计一次性生成整个批次。如果设置为 False，则source将按样本调用。batch_info¶ (bool, optional, default = False) – 控制可调用的
source（接受一个参数并返回批次）应接收 ~nvidia.dali.types.BatchInfo 实例还是仅接收表示迭代次数的整数。如果设置为 False（默认值），则仅传递整数。如果source不可调用、不接受参数或batch设置为 False，则设置此标志无效。parallel¶ (bool, optional, default = False) –
如果设置为 True，则相应的 pipeline 将启动一个 Python 工作进程池以并行运行回调函数。您可以通过将
py_num_workers传递到 pipeline 的构造函数中来指定工作进程的数量。当
parallel设置为 True 时，source返回的样本必须是 NumPy/MXNet/PyTorch CPU 数组或 TensorCPU 实例。可接受的 source 取决于为
batch参数指定的值。如果
batch设置为False，则source必须是- 可调用的对象（函数或具有
__call__方法的对象），它接受 恰好一个参数（
SampleInfo实例，表示所请求样本的索引）。
- 可调用的对象（函数或具有
如果
batch设置为True，则source可以是以下之一：- 可调用的对象，它接受恰好一个参数（
BatchInfo 实例或整数 - 有关详细信息，请参阅
batch_info）
- 可调用的对象，它接受恰好一个参数（
可迭代对象，
生成器函数。
警告
无论
batch值如何，可调用对象都应该是无状态的 - 它们应该仅基于SampleInfo/BatchInfo实例或批次中的索引来生成请求的样本或批次，以便它们可以在多个工作进程中并行运行。当数据结束时，
source回调函数必须引发StopIteration异常。请注意，由于预取，回调函数可能会在数据集结束后被调用几次迭代 - 请确保在这种情况下它始终如一地引发StopIteration异常。警告
当 pipeline 启用条件执行时，必须采取额外的步骤来防止
source被 AutoGraph 重写。 有两种方法可以实现这一点：1. 在全局作用域中定义函数（即在
pipeline_def作用域之外）。
2. 如果函数是另一个“工厂”函数的结果，则工厂函数必须在 pipeline 定义函数之外定义，并使用
@do_not_convert装饰器进行装饰。更多详细信息可以在
@do_not_convert文档中找到。注意
可调用的
source可以由多个工作进程并行运行。对于batch=True，可以并行准备多个批次；对于batch=False，可以并行化批次内的计算。当
batch=True时，可调用对象的性能可能会特别受益于增加prefetch_queue_depth，以便可以并行计算接下来的几个批次。注意
迭代器或生成器函数将被分配给单个工作进程，该工作进程将迭代它们。 主要优点是与主 Python 进程并行执行，但由于它们的状态，一次无法计算多个批次。
repeat_last¶ (bool, optional, default = False) –
注意
这是一个高级设置，主要用于带有解耦模型的 Triton Inference Server。
通常，
external_source消耗其输入数据，并期望在即将到来的迭代中馈入新的数据。 设置repeat_last=True会更改此行为，以便external_source将检测到在前一个 pipeline 运行和当前运行之间没有馈入新数据，并将使用最近的数据进行自我重新馈送。仅在“push”模式下设置
repeat_last为 True 才有意义，即当用户通过调用feed_input主动提供数据时。 启用此选项与指定source不兼容，这会使external_source在“pull”模式下运行。prefetch_queue_depth¶ (int, optional, default = 1) – 当在
parallel=True模式下运行时，指定要预先计算并存储在内部缓冲区中的批次数量，否则将忽略此参数。bytes_per_sample_hint¶ (int, optional, default = None) –
如果在
parallel=True模式下指定，则该值在计算工作进程用于将并行外部 source 输出传递到 pipeline 的共享内存槽的初始容量时充当提示。 在非并行模式下，此参数将被忽略。设置足够大的值以容纳传入数据可以防止 DALI 在 pipeline 运行期间重新分配共享内存。 此外，手动提供提示可以防止 DALI 高估必要的共享内存容量。
该值必须是正整数。 请注意，共享内存中的样本附带一些内部元数据，因此，对共享内存的实际需求略高于外部 source 生成的二进制数据的大小。 实际元数据大小取决于多种因素，例如，可能会在 Python 或 DALI 版本之间更改，恕不另行通知。
请参阅 pipeline 的
external_source_shm_statistics以检查为 pipeline 的并行外部 source 生成的数据分配了多少共享内存。
- class nvidia.dali.ops.FastResizeCropMirror(*, antialias=False, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mirror=0, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, rounding='round', size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
警告
此运算符现已弃用。请改用
ResizeCropMirror()。ResizedCropMirror 的旧别名，默认情况下禁用抗锯齿。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
antialias¶ (bool, optional, default = False) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop¶ (float or list of float or TensorList of float, optional) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float or TensorList of float, optional, default = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w、crop_h和crop_d必须一起指定。 为crop_w、crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float or TensorList of float, optional, default = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float or TensorList of float, optional, default = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，crop_W是裁剪窗口的宽度。有关
crop_x如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_y¶ (float or TensorList of float, optional, default = 0.5) –
裁剪窗口起始位置（通常为左上角）的归一化 (0.0 - 1.0) 垂直位置。
实际位置计算为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，crop_H是裁剪窗口的高度。有关
crop_y如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_z¶ (float or TensorList of float, optional, default = 0.5) –
仅适用于体积输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，crop_D是裁剪窗口的深度。有关
crop_z如何转换为整数值的更多详细信息，请参阅rounding参数。crop_w¶ (float or TensorList of float, optional, default = 0.0) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
必须与输入类型或
float相同。 如果未设置，则使用输入类型。interp_type¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList，可选，默认值 = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来为缩小比例和放大比例指定不同的滤波。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList，可选，默认值 = DALIInterpType.INTERP_LINEAR) – 放大比例时使用的滤波器。max_size¶ (float or list of float, optional) –
输出尺寸的限制。
当算子配置为保持宽高比且仅指定较小尺寸时，其他尺寸可能会变得非常大。当使用
resize_shorter参数或 “not_smaller” 模式，或者当某些尺寸范围未指定时，可能会发生这种情况。此参数限制了输出可以变得多大。此值可以按轴指定，也可以对所有轴统一指定。
注意
当与 “not_smaller” 模式或
resize_shorter参数一起使用时，max_size优先，并且保持宽高比 - 例如，使用mode="not_smaller", size=800, max_size=1400调整大小，尺寸为 1200x600 的图像将被调整为 1400x700。min_filter¶ (
nvidia.dali.types.DALIInterpType或 nvidia.dali.types.DALIInterpType 的 TensorList, 可选, 默认 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, 可选, 默认 = 32) – 在内核调用中处理的最大图像数量。
mirror¶ (int 或 int 的 TensorList, 可选, 默认 = 0) –
翻转的掩码
支持的值
0 - 不翻转
1 - 水平翻转
2 - 垂直翻转
4 - 深度方向翻转
上述任意按位组合
mode¶ (str, 可选, 默认 = ‘default’) –
调整大小模式。
以下是支持模式的列表
"default"- 图像被调整为指定大小。缺失的尺寸范围将使用提供的尺寸范围的平均比例进行缩放。"stretch"- 图像被调整为指定大小。缺失的尺寸范围根本不进行缩放。"not_larger"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不超过指定大小。例如，对于 1280x720 的图像，期望的输出大小为 640x480，实际会生成 640x360 的输出。"not_smaller"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不小于指定大小。例如，对于 640x480 的图像，期望的输出大小为 1920x1080，实际会生成 1920x1440 的输出。此参数与
resize_longer和resize_shorter互斥。
preserve¶ (bool, 可选, 默认 = False) – 阻止算子从图中移除，即使其输出未被使用。
resize_longer¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
调整大小后图像较长尺寸的长度。
此选项与
resize_shorter和显式的大小参数互斥，并且算子保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_larger"。resize_shorter¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
调整大小后图像较短尺寸的长度。
此选项与
resize_longer和显式的大小参数互斥，并且算子保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_smaller"。可以通过设置max_size参数来限制较长尺寸。有关更多信息，请参阅max_size参数文档。resize_x¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
调整大小后图像 X 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_y未指定或为 0，则算子保持原始图像的宽高比。负值会翻转图像。resize_y¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
调整大小后图像 Y 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_x未指定或为 0，则算子保持原始图像的宽高比。负值会翻转图像。resize_z¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
调整大小后体积 Z 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_x和resize_y未指定或为 0，则算子将保持原始体积的宽高比。负值会翻转体积。roi_end¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标 (0..1)，具体取决于relative_roi参数的值。如果 ROI 原点在任何维度上都大于 ROI 终点，则该区域在该维度上被翻转。roi_relative¶ (bool, 可选, 默认 = False) – 如果为 true，则 ROI 坐标相对于输入大小，其中 0 表示顶部/左侧，1 表示底部/右侧
roi_start¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
输入感兴趣区域 (ROI) 的原点。
必须与
roi_end一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标 (0..1)，具体取决于relative_roi参数的值。如果 ROI 原点在任何维度上都大于 ROI 终点，则该区域在该维度上被翻转。rounding¶ (str, 可选, 默认 = ‘round’) –
确定用于将窗口的起始坐标转换为整数值的舍入函数 (参见
crop_pos_x,crop_pos_y,crop_pos_z)。可能的值为
"round"- 四舍五入到最接近的整数值，中间值四舍五入到远离零的值。"truncate"- 丢弃数字的小数部分（向零截断）。
size¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
期望的输出大小。
必须是列表/元组，每个空间维度一个条目，不包括视频帧和通道。尺寸范围为 0 的维度被视为不存在，输出大小将根据其他尺寸范围和
mode参数计算。subpixel_scale¶ (bool, 可选, 默认 = True) –
如果为 True，则直接指定或计算的分数大小将导致调整输入 ROI 以保持缩放因子。
否则，将调整缩放因子，以便源图像映射到舍入后的输出大小。
temp_buffer_hint¶ (int, 可选, 默认 = 0) –
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
- __call__(__input, /, *, antialias=False, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mirror=0, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, rounding='round', size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'FHWC', 'CHW', 'FCHW', 'CFHW', 'DHWC', 'FDHWC', 'CDHW', 'FCDHW', 'CFDHW')) – 算子的输入。
- class nvidia.dali.ops.FileReader(*, bytes_per_sample_hint=[0], case_sensitive_filter=False, dir_filters=None, dont_use_mmap=False, file_filters=['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tif', '*.tiff', '*.pnm', '*.ppm', '*.pgm', '*.pbm', '*.jp2', '*.webp', '*.flac', '*.ogg', '*.wav'], file_list=None, file_root=None, files=None, initial_fill=1024, labels=None, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
警告
此算子现已弃用。请使用
readers.File()代替。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。readers.file()的旧别名。
- class nvidia.dali.ops.Flip(*, bytes_per_sample_hint=[0], depthwise=0, horizontal=1, preserve=False, vertical=0, device=None, name=None)#
在选定的维度（水平、垂直和深度方向）上翻转图像。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
depthwise¶ (int 或 int 的 TensorList, 可选, 默认 = 0) – 翻转深度方向维度。
horizontal¶ (int 或 int 的 TensorList, 可选, 默认 = 1) – 翻转水平维度。
preserve¶ (bool, 可选, 默认 = False) – 阻止算子从图中移除，即使其输出未被使用。
vertical¶ (int 或 int 的 TensorList, 可选, 默认 = 0) – 翻转垂直维度。
- class nvidia.dali.ops.Full(*, bytes_per_sample_hint=[0], preserve=False, shape=None, device=None, name=None)#
返回具有给定形状和类型的新数据，并用填充值填充。
- 支持的后端
‘cpu’
- 关键字参数:
- class nvidia.dali.ops.FullLike(*, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
返回与输入数据具有相同形状和类型的新数据，并用 fill_value 填充。
- 支持的后端
‘cpu’
- 关键字参数:
- class nvidia.dali.ops.GaussianBlur(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, sigma=[0.0], window_size=[0], device=None, name=None)#
对输入应用高斯模糊。
高斯模糊通过应用高斯核的卷积来计算，可以使用 windows_size 和
sigma进行参数化。如果仅指定 sigma，则高斯核的半径默认为ceil(3 * sigma)，因此内核窗口大小为2 * ceil(3 * sigma) + 1。如果仅提供窗口大小，则 sigma 通过以下公式计算
radius = (window_size - 1) / 2 sigma = (radius - 1) * 0.3 + 0.8
sigma 和内核窗口大小可以指定为所有数据轴的单个值，也可以为每个数据轴指定一个值。
当为每个轴指定 sigma 或窗口大小时，轴的提供方式与布局相同，从最外层到最内层。
注意
通道
C和帧F维度不被视为数据轴。如果存在通道，则仅支持通道优先或通道最后的输入。例如，对于
HWC输入，您可以提供sigma=1.0或sigma=(1.0, 2.0)，因为有两个数据轴，H 和 W。相同的输入可以作为每个样本的张量提供。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
支持的类型：FLOAT。如果未设置，则使用输入类型。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
sigma¶ (float 或 list of float 或 TensorList of float, optional, default = [0.0]) –
高斯核的 Sigma 值。
支持
per-frame输入。window_size¶ (int 或 list of int 或 TensorList of int, optional, default = [0]) –
内核的直径。
支持
per-frame输入。
- class nvidia.dali.ops.GetProperty(*, bytes_per_sample_hint=[0], key=None, preserve=False, device=None, name=None)#
返回作为输入传递的张量的属性。
输出的类型将取决于请求属性的
key。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
key¶ (str) –
指定请求哪个属性。
支持以下属性
"source_info": 返回类型：字节数组。类似字符串的字节数组，其中包含有关样本来源的信息。例如，在通过
fn.readers.file()加载的张量上调用的fn.get_property()返回张量来源的文件的完整路径。
"layout": 返回类型：字节数组数据布局 在给定的张量中。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- class nvidia.dali.ops.GridMask(*, angle=0.0, bytes_per_sample_hint=[0], preserve=False, ratio=0.5, shift_x=0.0, shift_y=0.0, tile=100, device=None, name=None)#
执行 GridMask 数据增强 (https://arxiv.org/abs/2001.04086)。
以网格状方式将图像的像素置零。网格由在 x 和 y 方向上重复的正方形组成，在两个方向上具有相同的间距。可以绕原点旋转。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
angle¶ (float 或 TensorList of float, optional, default = 0.0) – 网格旋转的角度，以弧度为单位。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
ratio¶ (float 或 TensorList of float, optional, default = 0.5) – 黑色正方形宽度与瓦片宽度的比率。
shift_x¶ (float 或 TensorList of float, optional, default = 0.0) – 平移向量的 x 分量，在旋转后应用。
shift_y¶ (float 或 TensorList of float, optional, default = 0.0) – 平移向量的 y 分量，在旋转后应用。
tile¶ (int 或 TensorList of int, optional, default = 100) – 单个瓦片的长度，等于黑色正方形的宽度加上它们之间的间距。
- class nvidia.dali.ops.Hsv(*, bytes_per_sample_hint=[0], dtype=DALIDataType.UINT8, hue=0.0, preserve=False, saturation=1.0, value=1.0, device=None, name=None)#
调整图像的色相、饱和度和明度（亮度）。
要更改图像的色相、饱和度和/或明度，请传递相应的系数。请记住，
hue是一个加性增量参数，而对于saturation和value，参数是乘法的。此运算符接受 RGB 颜色空间中的图像。
出于性能原因，该操作通过 RGB 空间中的线性变换来近似。颜色向量沿中性（灰色）轴投影，基于色相增量旋转，基于明度和饱和度乘数缩放，然后恢复到原始颜色空间。
此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.UINT8) –输出数据类型。
如果未设置值，则使用输入类型。
hue¶ (float 或 TensorList of float, optional, default = 0.0) –
色相增量，以度为单位。
色相分量可以解释为角度，并且 0-360 范围之外的值会像旋转一样环绕。
支持
per-frame输入。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
saturation¶ (float 或 TensorList of float, optional, default = 1.0) –
饱和度乘数。
支持
per-frame输入。value¶ (float 或 TensorList of float, optional, default = 1.0) –
明度乘数。
支持
per-frame输入。
- class nvidia.dali.ops.Hue(*, bytes_per_sample_hint=[0], dtype=None, hue=0.0, image_type=DALIImageType.RGB, preserve=False, device=None, name=None)#
更改图像的色调级别。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
如果未设置，则使用输入类型。
hue¶ (float 或 TensorList of float, optional, default = 0.0) –
色调变化，以度为单位。
支持
per-frame输入。image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 输入和输出图像的颜色空间。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- class nvidia.dali.ops.ImageDecoder(*, affine=True, bytes_per_sample_hint=[0], cache_batch_copy=True, cache_debug=False, cache_size=0, cache_threshold=0, cache_type='', device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, use_fast_idct=False, device=None, name=None)#
警告
此运算符现已弃用。请改用
decoders.Image()。在 DALI 1.0 中，所有解码器都移至专用的
decoders子模块并重命名以遵循通用模式。这是一个占位符运算符，功能相同，以实现向后兼容性。decoders.image()的旧别名。
- class nvidia.dali.ops.ImageDecoderCrop(*, affine=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rounding='round', use_fast_idct=False, device=None, name=None)#
警告
此运算符现已弃用。请改用
decoders.ImageCrop()。在 DALI 1.0 中，所有解码器都移至专用的
decoders子模块并重命名以遵循通用模式。这是一个占位符运算符，功能相同，以实现向后兼容性。decoders.image_crop()的旧别名。
- class nvidia.dali.ops.ImageDecoderRandomCrop(*, affine=True, bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, num_attempts=10, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, use_fast_idct=False, device=None, name=None)#
警告
此运算符现已弃用。请使用
decoders.ImageRandomCrop()代替。在 DALI 1.0 中，所有解码器都移至专用的
decoders子模块并重命名以遵循通用模式。这是一个占位符运算符，功能相同，以实现向后兼容性。旧版别名，用于
decoders.image_random_crop()。
- class nvidia.dali.ops.ImageDecoderSlice(*, affine=True, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, end=None, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, normalized_anchor=True, normalized_shape=True, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, use_fast_idct=False, device=None, name=None)#
警告
此运算符现已弃用。请使用
decoders.ImageSlice()代替。在 DALI 1.0 中，所有解码器都移至专用的
decoders子模块并重命名以遵循通用模式。这是一个占位符运算符，功能相同，以实现向后兼容性。旧版别名，用于
decoders.image_slice()。
- class nvidia.dali.ops.Jitter(*, bytes_per_sample_hint=[0], fill_value=0.0, interp_type=DALIInterpType.INTERP_NN, mask=1, nDegree=2, preserve=False, seed=-1, device=None, name=None)#
执行随机抖动增强。
输出图像的生成方式为：在 x 和 y 维度上将每个像素移动一个随机量，并以
nDegree参数的一半为界。- 支持的后端
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
fill_value¶ (float, 可选, 默认值 = 0.0) – 用于填充的颜色值。
interp_type¶ (
nvidia.dali.types.DALIInterpType, 可选, 默认值 = DALIInterpType.INTERP_NN) – 使用的插值类型。mask¶ (int 或 TensorList of int, 可选, 默认值 = 1) –
确定是否将此增强应用于输入图像。
以下是值：
0：不应用此变换。
1：应用此变换。
nDegree¶ (int, 可选, 默认值 = 2) – 每个像素在
[-nDegree/2, nDegree/2]范围内移动一个随机量。preserve¶ (bool, 可选, 默认值 = False) – 即使其输出未使用，也防止从图中删除运算符。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
- class nvidia.dali.ops.JpegCompressionDistortion(*, bytes_per_sample_hint=[0], preserve=False, quality=50, device=None, name=None)#
将 JPEG 压缩伪影引入 RGB 图像。
JPEG 是一种有损压缩格式，它利用自然图像和人类视觉系统的特性来实现高压缩比。信息损失源于以低于亮度的空间分辨率对颜色信息进行采样，以及以较低的有效位深度表示图像的高频分量。转换为频域和量化独立应用于 8x8 像素块，这会在块边界处引入额外的伪影。
此操作通过对输入进行转换来生成图像，该转换模拟具有给定
quality因子的 JPEG 压缩，然后进行解压缩。此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
- class nvidia.dali.ops.Laplacian(*, bytes_per_sample_hint=[0], dtype=None, normalized_kernel=False, preserve=False, scale=[1.0], smoothing_size=None, window_size=[3], device=None, name=None)#
计算输入的拉普拉斯算子。
拉普拉斯算子计算为关于每个空间维度的二阶偏导数的总和。每个偏导数都使用可分离卷积来近似，该卷积在偏导数方向上使用导数窗口，并在其余轴上使用平滑窗口。
默认情况下，每个偏导数都通过沿所有空间轴卷积来近似：偏导数方向上的轴使用
window_size的导数窗口，其余轴与相同大小的平滑窗口卷积。如果指定了smoothing_size，则应用于给定轴的平滑窗口的大小可以与导数窗口的大小不同。指定smoothing_size = 1意味着在垂直于导数方向的轴上不进行平滑处理。window_size和smoothing_size都可以指定为单个值或每个轴的值。例如，对于体积输入，如果指定了window_size=[dz, dy, dx]和smoothing_size=[sz, sy, sx]，则将使用以下窗口：对于
z方向的偏导数：沿z轴的大小为dz的导数窗口，以及分别沿 y 和 x 的大小为sy和sx的平滑窗口。对于
y方向的偏导数：沿y轴的大小为dy的导数窗口，以及分别沿 z 和 x 的大小为sz和sx的平滑窗口。对于
x方向的偏导数：沿x轴的大小为dx的导数窗口，以及分别沿 z 和 y 的大小为sz和sy的平滑窗口。
窗口大小和平滑大小必须为奇数。导数窗口的大小必须至少为 3。平滑窗口的大小可以为 1，这意味着沿相应轴不进行平滑处理。
要归一化偏导数，可以使用
normalized_kernel=True。每个偏导数都按2^(-s + n + 2)缩放，其中s是用于计算给定偏导数的窗口大小之和（包括平滑窗口），n是数据维度/轴的数量。或者，您可以指定scale参数以自定义缩放因子。比例可以是单个值，也可以是n个值，每个偏导数一个。运算符使用 32 位浮点数作为中间类型。
注意
通道
C和帧F维度不被视为数据轴。如果存在通道，则仅支持通道优先或通道最后的输入。此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
支持的类型：FLOAT。如果未设置，则使用输入类型。
normalized_kernel¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则自动缩放偏导数内核。如果指定了
scale，则必须为 False。preserve¶ (bool, 可选, 默认值 = False) – 即使其输出未使用，也防止从图中删除运算符。
scale¶ (float 或 list of float 或 TensorList of float, 可选, 默认值 = [1.0]) –
手动缩放偏导数的因子。
支持
per-frame输入。smoothing_size¶ (int 或 list of int 或 TensorList of int, 可选) –
卷积中使用的平滑窗口的大小。
平滑大小必须为奇数，且介于 1 到 23 之间。
支持
per-frame输入。window_size¶ (int 或 list of int 或 TensorList of int, 可选, 默认值 = [3]) –
卷积中使用的导数窗口的大小。
窗口大小必须为奇数，且介于 3 到 23 之间。
支持
per-frame输入。
- class nvidia.dali.ops.LookupTable(*, bytes_per_sample_hint=[0], default_value=0.0, dtype=DALIDataType.FLOAT, keys=[], preserve=False, values=[], device=None, name=None)#
通过使用由
keys和values指定的查找表，以及未指定键的default_value，将输入映射到输出。例如，当
keys和values被用来以下列方式定义查找表时keys[] = {0, 2, 3, 4, 5, 3} values[] = {0.2, 0.4, 0.5, 0.6, 0.7, 0.10} default_value = 0.99 0 <= i < max(keys) lut[i] = values[keys.index[i]] if i in keys lut[i] = default_value otherwise
该算子创建以下表格
lut[] = {0.2, 0.99, 0.4, 0.10, 0.6, 0.7} // only last occurrence of a key is considered
并根据以下公式生成输出
Output[i] = lut[Input[i]] if 0 <= Input[i] <= len(lut) Output[i] = default_value otherwise
这是一个实际示例，考虑上述定义的表格
Input[] = {1, 4, 1, 0, 100, 2, 3, 4} Output[] = {0.99, 0.6, 0.99, 0.2, 0.99, 0.4, 0.10, 0.6}
注意
只有整数类型可以用作此算子的输入。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
default_value¶ (float，可选，默认值 = 0.0) – 表中不存在的键的默认输出值。
dtype¶ (
nvidia.dali.types.DALIDataType，可选，默认值 = DALIDataType.FLOAT) – 输出数据类型。keys¶ (int 或 int 列表，可选，默认值 = []) –
查找表中的输入值（键）列表。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool，可选，默认值 = False) – 即使算子的输出未使用，也防止从图中移除该算子。
values¶ (float 或 float 列表，可选，默认值 = []) –
- class nvidia.dali.ops.MFCC(*, axis=0, bytes_per_sample_hint=[0], dct_type=2, lifter=0.0, n_mfcc=20, normalize=False, preserve=False, device=None, name=None)#
从梅尔频谱图计算梅尔频率倒谱系数 (MFCC)。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axis¶ (int，可选，默认值 = 0) –
将应用变换的轴。
如果未提供值，将使用最外层维度。
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dct_type¶ (int，可选，默认值 = 2) –
离散余弦变换类型。
支持的类型为 1、2、3、4。用于计算 DCT 的公式等同于 https://en.wikipedia.org/wiki/Discrete_cosine_transform 中描述的公式（数字对应于 https://en.wikipedia.org/wiki/Discrete_cosine_transform#Formal_definition 中列出的类型）。
lifter¶ (float，可选，默认值 = 0.0) –
倒谱滤波系数，也称为提升系数。
如果提升系数大于 0，则 MFCC 将根据以下公式进行缩放
MFFC[i] = MFCC[i] * (1 + sin(pi * (i + 1) / lifter)) * (lifter / 2)
n_mfcc¶ (int，可选，默认值 = 20) – MFCC 系数数量。
normalize¶ (bool，可选，默认值 = False) –
如果设置为 True，则 DCT 使用正交归一化基。
注意
当 dct_type=1 时，不支持归一化。
preserve¶ (bool，可选，默认值 = False) – 即使算子的输出未使用，也防止从图中移除该算子。
- class nvidia.dali.ops.MXNetReader(*, bytes_per_sample_hint=[0], dont_use_mmap=False, index_path=None, initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
警告
此算子现已弃用。请改用
readers.MXNet()。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.mxnet()的旧别名。
- class nvidia.dali.ops.MelFilterBank(*, bytes_per_sample_hint=[0], freq_high=0.0, freq_low=0.0, mel_formula='slaney', nfilter=128, normalize=True, preserve=False, sample_rate=44100.0, device=None, name=None)#
通过应用三角滤波器组将频谱图转换为梅尔频谱图。
频率 ('f') 维度从输入布局中选择。如果未指定布局，则假定为 “f”、“ft” 或 “*ft”，具体取决于维度的数量。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
freq_high¶ (float，可选，默认值 = 0.0) –
最大频率。
如果未提供此值，则使用
sample_rate/2。freq_low¶ (float，可选，默认值 = 0.0) – 最小频率。
mel_formula¶ (str，可选，默认值 = ‘slaney’) –
确定用于将频率从赫兹转换为梅尔以及从梅尔转换为赫兹的公式。
梅尔刻度是音调的感知刻度，因此没有单一公式。
支持的值包括
slaney，它遵循 Slaney 的 MATLAB 听觉建模工作行为。此公式在 1 KHz 以下是线性的，在此值以上是对数线性的。该实现与 Librosa 的默认实现一致。htk，它遵循 O’Shaughnessy 书籍公式，m = 2595 * log10(1 + (f/700))。此值与 Hidden Markov Toolkit (HTK) 的实现一致。
nfilter¶ (int，可选，默认值 = 128) – 梅尔滤波器数量。
normalize¶ (bool，可选，默认值 = True) –
确定是否按其频带宽度归一化三角滤波器权重。
如果设置为 True，则滤波器函数的积分值为 1。
如果设置为 False，则滤波器函数的峰值为 1。
preserve¶ (bool，可选，默认值 = False) – 即使算子的输出未使用，也防止从图中移除该算子。
sample_rate¶ (float，可选，默认值 = 44100.0) – 音频信号的采样率。
- class nvidia.dali.ops.MultiPaste(*, bytes_per_sample_hint=[0], dtype=None, in_anchors=None, in_anchors_rel=None, in_ids=None, out_anchors=None, out_anchors_rel=None, output_size=None, preserve=False, shapes=None, shapes_rel=None, device=None, name=None)#
对每个输出执行从图像批次多次粘贴操作。
如果指定了
in_ids，则该算子正好需要一个输入批次。在这种情况下，对于每个输出样本，in_ids描述了应将输入批次中的哪些样本粘贴到输出批次中的相应样本。如果省略
in_ids参数，则该算子接受多个输入。在这种情况下，每个输入批次中的第 i 个样本将粘贴到输出批次的第 i 个样本。所有输入批次必须具有相同的类型和设备放置。如果输入形状是统一的，并且未提供显式的
output_size，则该算子假定相同的输出形状（输出画布大小）。否则，必须指定output_size。此算子还可以更改数据类型。
此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType，可选) – 输出数据类型。如果未设置，则使用输入类型。in_anchors¶ (int 或 int 的 TensorList，可选) –
源区域左上角的绝对坐标。
锚点表示为 2D 张量，其中第一个维度等于粘贴区域的数量，第二个维度为 2（对于 H 和 W 范围）。
如果未提供
in_anchors和in_anchors_rel，则所有锚点均为零。支持
per-frame输入。in_anchors_rel¶ (float 或 float 的 TensorList，可选) –
源区域左上角的相对坐标。
此参数的工作方式类似于
in_anchors，但值应为 [0, 1] 范围内的浮点数，描述相对于输入样本形状的锚点位置。支持
per-frame输入。in_ids¶ (int 或 int 列表或 int 的 TensorList，可选) –
要从中粘贴数据的输入的索引。
如果指定，则该算子接受一个批次作为输入。
out_anchors¶ (int 或 int 的 TensorList，可选) –
输出画布中粘贴区域左上角的绝对坐标。
锚点表示为 2D 张量，其中第一个维度等于粘贴区域的数量，第二个维度为 2（对于 H 和 W 范围）。
如果未提供
out_anchors和out_anchors_rel，则所有锚点均为零，从而使所有粘贴区域都从输出画布的左上角开始。支持
per-frame输入。out_anchors_rel¶ (float 或 float 的 TensorList，可选) –
输出画布中粘贴区域左上角的相对坐标。
此参数的工作方式类似于
out_anchors参数，但值应为 [0, 1] 范围内的浮点数，描述相对于输出画布大小的粘贴区域左上角。支持
per-frame输入。output_size¶ (int 或 int 列表或 int 的 TensorList，可选) –
描述输出形状（即输出粘贴的画布大小）的元组 (H, W)。
如果算子以统一形状的输入运行，则可以省略。在这种情况下，相同的形状将用作画布大小。
preserve¶ (bool，可选，默认值 = False) – 即使算子的输出未使用，也防止从图中移除该算子。
shapes¶ (int 或 int 的 TensorList，可选) –
粘贴区域的形状。
形状表示为 2D 张量，其中第一个维度等于粘贴区域的数量，第二个维度为 2（对于 H 和 W 范围）。
如果未提供
shapes和shapes_rel，则会计算形状，以使区域从输入锚点跨越到输入图像的末尾。支持
per-frame输入。shapes_rel¶ (float 或 float 的 TensorList，可选) –
粘贴区域的相对形状。
此参数的工作方式类似于 shape 参数，但值应为 [0, 1] 范围内的浮点数，描述相对于输入形状的粘贴区域形状。
支持
per-frame输入。
- __call__(__input_0, /, *__input_, bytes_per_sample_hint=[0], dtype=None, in_anchors=None, in_anchors_rel=None, in_ids=None, out_anchors=None, out_anchors_rel=None, output_size=None, preserve=False, shapes=None, shapes_rel=None, device=None, name=None)#
请参阅
nvidia.dali.ops.MultiPaste()类以获取完整信息。
- class nvidia.dali.ops.NemoAsrReader(*, bytes_per_sample_hint=[0], dont_use_mmap=False, downmix=True, dtype=DALIDataType.FLOAT, initial_fill=1024, lazy_init=False, manifest_filepaths=None, max_duration=0.0, min_duration=0.0, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, quality=50.0, random_shuffle=False, read_ahead=False, read_idxs=False, read_sample_rate=True, read_text=True, sample_rate=-1.0, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
警告
此运算符现已弃用。请使用
readers.NemoAsr()代替。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.nemo_asr()的旧版别名。
- class nvidia.dali.ops.NonsilentRegion(*, bytes_per_sample_hint=[0], cutoff_db=-60.0, preserve=False, reference_power=0.0, reset_interval=8192, window_length=2048, device=None, name=None)#
在音频缓冲区中执行前导和尾随静音检测。
该运算符通过比较为信号的
window_length计算的短期功率与静音截止阈值，返回非静音区域的起始位置和长度。当short_term_power_db小于cutoff_db时，信号被认为是静音的。其中short_term_power_db = 10 * log10( short_term_power / reference_power )
除非另有说明，否则
reference_power是信号的最大功率。输入和输出
输入 0 - 1D 音频缓冲区。
输出 0 - 非静音区域中第一个样本的索引。
输出 1 - 非静音区域的长度。
注意
如果
Outputs[1] == 0，则Outputs[0]中的值未定义。警告
目前，此运算符的“gpu”后端是根据“cpu”实现来实现的。这会导致输入从设备到主机的复制以及输出从主机到设备的复制。虽然使用此运算符的“gpu”实现本身没有任何性能优势，但为了能够在 pipeline 中将前面的操作移动到 GPU，使用它可能是有意义的。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
cutoff_db¶ (float, optional, default = -60.0) – 信号被认为是静音的阈值，以 dB 为单位。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
reference_power¶ (float, optional, default = 0.0) –
用于将信号转换为 dB 的参考功率。
如果未提供值，则信号的最大功率将用作参考。
reset_interval¶ (int, optional, default = 8192) –
重新计算移动平均值的样本数，以避免精度损失。
如果
reset_interval == -1，或者输入类型允许精确计算，则平均值将不会重置。默认值可用于大多数用例。window_length¶ (int, optional, default = 2048) – 用于计算信号短期功率的滑动窗口大小。
- class nvidia.dali.ops.NormalDistribution(*, bytes_per_sample_hint=[0], dtype=None, mean=0.0, preserve=False, seed=-1, shape=None, stddev=1.0, device=None, name=None)#
警告
此运算符现已弃用。请使用
random.Normal()代替。生成服从正态分布的随机数。
生成数据的形状可以通过
shape参数显式指定，也可以选择与提供的__shape_like输入的形状匹配。如果两者都不存在，则每个样本生成一个值。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
mean¶ (float 或 TensorList of float, optional, default = 0.0) – 分布的均值。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 list of int 或 TensorList of int, optional) – 输出数据的形状。
stddev¶ (float 或 TensorList of float, optional, default = 1.0) – 分布的标准差。
- class nvidia.dali.ops.Normalize(*, axes=[], axis_names='', batch=False, bytes_per_sample_hint=[0], ddof=0, dtype=DALIDataType.FLOAT, epsilon=0.0, mean=None, preserve=False, scale=1.0, shift=0.0, stddev=None, device=None, name=None)#
通过移除均值并除以标准差来归一化输入。
均值和标准差可以在内部为指定的轴子集计算，也可以作为
mean和stddev参数从外部提供。归一化按照以下公式进行
out = scale * (in - mean) / stddev + shift
该公式假设 out 和 in 是形状相同的张量，但 mean 和 stddev 可能是形状相同的张量、标量或它们的混合。
注意
该表达式遵循 numpy 广播规则。
如果给定轴被缩减，则非标量
mean和stddev的大小必须为 1，或者与输入的相应大小匹配。如果维度在axes或axis_names中列出，则认为该维度已缩减。如果axes和axis_names参数都不存在，则通过比较输入形状与均值/标准差参数的形状来推断缩减轴的集合，但对于批处理中的所有张量，缩减轴的集合必须相同。以下是一些有效参数组合的示例
维度 0 和 2 的每个样本归一化
axes = 0,2 # optional input.shape = [ [480, 640, 3], [1080, 1920, 4] ] batch = False mean.shape = [ [1, 640, 1], [1, 1920, 1] ] stddev = (not supplied)
使用这些形状，批处理归一化是不可能的，因为非缩减维度在样本之间具有不同的大小。
维度 0 和 1 的批处理归一化
axes = 0,1 # optional input.shape = [ [480, 640, 3], [1080, 1920, 3] ] batch = True mean = (scalar) stddev.shape = [ [1, 1, 3] ] ]
对于彩色图像，此示例分别归一化 3 个颜色通道，但在批处理中的所有样本中进行归一化。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list of int, optional, default = []) –
输入沿其归一化的维度索引。
默认情况下，使用所有轴，并且轴也可以按名称指定。有关更多信息，请参阅
axis_names。axis_names¶ (layout str, optional, default = ‘’) –
输入中轴的名称。
轴索引取自输入布局，并且此参数不能与
axes一起使用。batch¶ (bool, optional, default = False) –
如果设置为 True，则均值和标准差将在批处理中的张量之间计算。
此参数还要求非缩减轴中的输入样本形状匹配。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
ddof¶ (int, optional, default = 0) –
Bessel 校正的 Delta 自由度。
方差估计使用以下公式
sum(Xi - mean)**2 / (N - ddof).
当使用外部提供的标准差时，此参数将被忽略。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) –输出数据类型。
当使用整数类型时，使用
shift和scale以提高输出类型动态范围的利用率。如果dtype是整数类型，则超出范围的值将被钳制，非整数值将四舍五入到最接近的整数。epsilon¶ (float, optional, default = 0.0) – 添加到方差以避免除以小数字的值。
mean¶ (float 或 TensorList of float, optional) –
要从数据中减去的均值。
该值可以是标量或与输入具有相同维度的张量批处理。每个维度的大小必须与输入的值匹配或等于 1。如果大小为 1，则该值将在此维度中广播。如果未指定该值，则从输入计算均值。当 batch 参数设置为 True 时，不能使用非标量均值。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
scale¶ (float, optional, default = 1.0) –
应用于输出的比例因子。
此参数对于整数输出类型很有用。
shift¶ (float, optional, default = 0.0) –
均值将在输出中映射到的值。
此参数对于无符号输出类型很有用。
stddev¶ (float 或 TensorList of float, optional) –
用于缩放数据的标准差值。
有关形状约束的更多信息，请参阅
mean参数。如果未指定值，则从输入计算标准差。当batch参数设置为 True 时，不能使用非标量stddev。
- class nvidia.dali.ops.NumbaFunction(*, batch_processing=False, blocks=None, bytes_per_sample_hint=[0], in_types=None, ins_ndim=None, out_types=None, outs_ndim=None, preserve=False, run_fn=None, setup_fn=None, threads_per_block=None, device=None, name=None)#
调用 njit 编译的 Numba 函数。
run 函数应该是一个 Python 函数，可以在 Numba
nopython模式下编译。 接受单个输入并产生单个输出的函数应遵循以下定义def run_fn(out0, in0)
其中
out0和in0是输入和输出张量的 numpy 数组视图。 如果运算符配置为在批处理模式下运行，则数组的第一个维度是样本索引。请注意，该函数最多可以接受 6 个输入和 6 个输出。
此外，还有一个可选的 setup 函数，用于计算输出的形状，以便 DALI 可以为输出分配内存，其定义如下
def setup_fn(outs, ins)
setup 函数会针对整个批次调用一次。
outs、ins的第一个维度分别是输出/输入的数量。 第二个维度是样本索引。 例如，可以通过outs[1][0]访问第二个输出上的第一个样本。如果未提供 setup 函数，则输出形状和数据类型将与输入相同。
注意
此运算符是实验性的，其 API 可能会在不另行通知的情况下更改。
警告
当 pipeline 启用了条件执行时，必须采取额外的步骤来防止
run_fn和setup_fn函数被 AutoGraph 重写。 有两种方法可以实现这一点在全局作用域（即
pipeline_def作用域之外）定义函数。如果函数是另一个“工厂”函数的结果，则工厂函数必须在 pipeline 定义函数之外定义，并使用
@do_not_convert进行装饰。
更多详细信息可以在
@do_not_convert文档中找到。示例 1
以下示例显示了一个简单的 setup 函数，该函数置换形状中维度的顺序。
def setup_change_out_shape(outs, ins): out0 = outs[0] in0 = ins[0] perm = [1, 0, 2] for sample_idx in range(len(out0)): for d in range(len(perm)): out0[sample_idx][d] = in0[sample_idx][perm[d]]
由于 setup 函数是针对整个批次运行的，因此我们需要迭代并单独置换每个样本的形状。 对于
shapes = [(10, 20, 30), (20, 10, 30)]，它将生成形状为shapes = [(20, 10, 30), (10, 20, 30)]的输出。此外，让我们提供 run 函数
def run_fn(out0, in0): for i in range(in0.shape[0]): for j in range(in0.shape[1]): out0[j, i] = in0[i, j]
run 函数可以按样本或按批次工作，具体取决于
batch_processing参数。按批次工作的 run 函数可能如下所示
def run_fn(out0_samples, in0_samples): for out0, in0 in zip(out0_samples, in0_samples): for i in range(in0.shape[0]): for j in range(in0.shape[1]): out0[j, i] = in0[i, j]
按样本工作的 run 函数可能如下所示
def run_fn(out0, in0): for i in range(in0.shape[0]): for j in range(in0.shape[1]): out0[j, i] = in0[i, j]
此算子允许序列输入并支持体积数据。
此算子将**不会**从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
batch_processing¶ (bool, optional, default = False) –
确定函数是每个批次调用一次，还是为批次中的每个样本单独调用。
当
batch_processing设置为True时，该函数处理整个批次。 如果函数必须执行跨样本操作，并且如果可以重用大部分工作，则这是必要的，并且可能是有益的。 对于其他用例，指定 False 并使用每样本处理函数允许运算符并行处理样本。blocks¶ (int or list of int, optional) –
- 3 项列表，指定用于每个网格的块数，用于
执行 CUDA 内核
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
in_types¶ (DALIDataType or list of DALIDataType) – 输入的类型。
ins_ndim¶ (int or list of int) – 输入形状应具有的维度数。
out_types¶ (DALIDataType or list of DALIDataType) – 输出的类型。
outs_ndim¶ (int or list of int) – 输出形状应具有的维度数。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
run_fn¶ (object) – 要调用的函数。 此函数必须在 Numba
nopython模式下工作。setup_fn¶ (object, optional) – 为输出设置形状的 Setup 函数。 此函数每个批次调用一次。 此外，此函数必须在 Numba
nopython模式下工作。threads_per_block¶ (int or list of int, optional) –
- 3 项列表，指定每个线程数
用于执行 CUDA 内核的块
- __call__(__input_0, __input_1=None, __input_2=None, __input_3=None, __input_4=None, __input_5=None, /, *, batch_processing=False, blocks=None, bytes_per_sample_hint=[0], in_types=None, ins_ndim=None, out_types=None, outs_ndim=None, preserve=False, run_fn=None, setup_fn=None, threads_per_block=None, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.NumbaFunction()类。
- class nvidia.dali.ops.NumpyReader(*, bytes_per_sample_hint=[0], cache_header_information=False, dont_use_mmap=False, file_filter='*.npy', file_list=None, file_root=None, files=None, fill_value=0.0, initial_fill=1024, lazy_init=False, num_shards=1, out_of_bounds_policy='error', pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, register_buffers=True, rel_roi_end=None, rel_roi_shape=None, rel_roi_start=None, roi_axes=[], roi_end=None, roi_shape=None, roi_start=None, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, use_o_direct=False, device=None, name=None)#
警告
此运算符现在已弃用。 请改用
readers.Numpy()。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.numpy()的旧版别名。
- class nvidia.dali.ops.OneHot(*, axis=-1, axis_name=None, bytes_per_sample_hint=[0], dtype=DALIDataType.FLOAT, num_classes=0, off_value=0.0, on_value=1.0, preserve=False, device=None, name=None)#
生成输入的 one-hot 编码。
添加新轴，或将标量输入转换为
num_classes元素的轴。对于给定的输入坐标
(x0, x1, ..., xn)和axis = k，输出样本指定为cls = input[x0, x1, ..., xn] output[x0, x1, ..., xk-1, i, xk, ..., xn] = on_value if i == cls else off_value
对于范围
[0, num_classes)中的所有i。对于标量，输出在从
input获取的索引处设置为on_value，在其他位置设置为off_valueoutput[i] = on_value if i == input else off_value
为了向后兼容，所有张量都只有一个元素的任何输入（无论维度数量如何）都被视为标量。 如果指定了
axis参数，则不支持将张量解释为标量的旧版方式。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axis¶ (int, optional, default = -1) – 用于放置大小为
num_classes的 one-hot 编码轴的维度。 默认情况下，对于非标量输入，它将作为最后一个维度附加。 对于标量输入，它将成为唯一的维度。axis_name¶ (str, optional) – 将用作输出布局中新添加维度的名称的单个字符。 如果未提供字符，则输出布局将为空。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) – 输出数据类型。num_classes¶ (int, optional, default = 0) – 数据中所有类别的数量。
off_value¶ (float, optional, default = 0.0) –
将用于填充输出的值，以指示相应输入坐标中缺少给定类别。
此值将转换为
dtype类型。on_value¶ (float, optional, default = 1.0) –
将用于填充输出的值，以指示相应输入坐标中给定的类别。
此值将转换为
dtype类型。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- class nvidia.dali.ops.Ones(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT32, preserve=False, shape=None, device=None, name=None)#
返回给定形状和类型的新数据，并用 1 填充。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.INT32) – 输出数据类型。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
shape¶ (int or list of int or TensorList of int, optional) – 输出数据的形状。
- __call__(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT32, preserve=False, shape=None, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.OnesLike(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT32, preserve=False, device=None, name=None)#
返回与输入数组具有相同形状和类型的新数据，并用 1 填充。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.INT32) – 覆盖输出数据类型。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- class nvidia.dali.ops.OpticalFlow(*, bytes_per_sample_hint=[0], enable_external_hints=False, enable_temporal_hints=False, hint_grid=4, image_type=DALIImageType.RGB, output_grid=4, preserve=False, preset=0.0, device=None, name=None)#
计算输入中图像之间的光流。
此运算符的主要输入是帧序列。 可选地，可以为运算符提供用于光流计算的外部提示。 此运算符的输出格式与光流驱动程序 API 的输出格式匹配。 有关 DALI 使用的 Turing、Ampere 和 Hopper 光流硬件的更多信息，请参阅 https://developer.nvidia.com/opticalflow-sdk。
注意
计算出的光流始终相对于输入图像的分辨率，但是输出光流图像可以是较低的分辨率，这由
output_grid决定。 相反，如果您希望光流向量与此运算符的输出分辨率保持一致，则必须将输出向量场除以output_grid。此运算符允许序列输入。
- 支持的后端
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
enable_external_hints¶ (bool, optional, default = False) –
启用或禁用光流计算的外部提示。
外部提示类似于时间提示，但唯一的区别是外部提示来自外部源。 启用此选项后，运算符需要两个输入。
enable_temporal_hints¶ (bool, optional, default = False) –
为长度超过两个图像的序列启用或禁用时间提示。
这些提示用于提高输出运动场的质量并加快计算速度。 这些提示在存在可能使光流算法混淆的大位移或周期性模式时尤其有用。）
hint_grid¶ (int, optional, default = 4) –
设置提示向量场的网格大小。
这些提示用于提高输出运动场的质量并加快计算速度。 网格分辨率可以设置为与输出不同的值。
注意
目前，Ampere 仅支持 1、2、4 和 8，Turing 仅支持 4。
image_type¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIImageType.RGB) – 输入颜色空间（RGB、BGR 或 GRAY）。output_format¶ (int) –
警告
参数 output_format 是已弃用的别名，请使用
output_grid代替output_grid。output_grid¶ (int, 可选, 默认值 = 4) –
设置输出向量场的网格大小。
此运算符生成的运动向量场的分辨率低于输入像素。此参数指定与一个运动向量对应的像素网格单元的大小。例如，值为 4 将为每个 4x4 像素块生成一个运动向量。因此，要使用
output_grid为 4 的光流来重新采样全分辨率图像，则会在不缩放向量大小的情况下对流场进行上采样。注意
目前，Ampere 架构仅支持 1、2 和 4，Turing 架构仅支持 4。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
preset¶ (float, 可选, 默认值 = 0.0) –
光流计算的速度和质量级别。
允许的值为：
0.0是最低速度和最佳质量。0.5是中等速度和质量。1.0是最快速度和最低质量。
速度越低，用于增强光流结果质量的额外预处理和后处理就越多。
- __call__(__input_0, __input_1=None, /, *, bytes_per_sample_hint=[0], enable_external_hints=False, enable_temporal_hints=False, hint_grid=4, image_type=DALIImageType.RGB, output_grid=4, preserve=False, preset=0.0, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.OpticalFlow()类。
- class nvidia.dali.ops.Pad(*, align=[], axes=[], axis_names='', bytes_per_sample_hint=[0], fill_value=0.0, preserve=False, shape=[], device=None, name=None)#
使用
fill_value在指定的轴上填充所有样本，以匹配批次中这些轴上的最大范围或匹配指定的最小形状。以下是一些示例：
1-D 样本，
fill_value= -1，axes= (0,)
样本在第一个轴上进行填充，以匹配最大样本的范围。
input = [[3, 4, 2, 5, 4], [2, 2], [3, 199, 5]]; output = [[3, 4, 2, 5, 4], [2, 2, -1, -1, -1], [3, 199, 5, -1, -1]]
1-D 样本，
fill_value= -1，axes= (0,)，shape= (7,)
样本在第一个轴上填充到最小范围 7。
input = [[3, 4, 2, 5, 4], [2, 2], [3, 199, 5], [1, 2, 3, 4, 5, 6, 7, 8]]; output = [[3, 4, 2, 5, 4, -1, -1], [2, 2, -1, -1, -1, -1, -1], [3, 199, 5, -1, -1, -1, -1], [1, 2, 3, 4, 5, 6, 7, 8]]
1-D 样本，
fill_value= -1，axes= (0,)，align= (4,)
样本在第一个轴上填充，以匹配最大样本的范围和对齐要求。输出范围为 8，这是将最大范围 (5) 向上舍入到对齐值 (4) 的倍数的结果。
input = [[3, 4, 2, 5, 4], [2, 2], [3, 199, 5]]; output = [[3, 4, 2, 5, 4, -1, -1, -1], [2, 2, -1, -1, -1, -1, -1, -1], [3, 199, 5, -1, -1, -1, -1, -1]]
1-D 样本，
fill_value= -1，axes= (0,)，shape= (1,)，align= (2,)
样本仅在第一个轴上填充以满足对齐要求。最小范围 (shape) 设置为 1，以避免除对齐所需的填充之外的任何填充。
input = [[3, 4, 2, 5, 4], [2, 2], [3, 199, 5]]; output = [[3, 4, 2, 5, 4, -1], [2, 2], [3, 199, 5, -1]]
2-D 样本，
fill_value= 42，axes= (1,)
样本在第二个轴上填充，以匹配最大样本的范围，并使用自定义填充值 42 而不是默认值 0。
input = [[[1, 2, 3, 4], [5, 6, 7, 8]], [[1, 2], [4, 5]]] output = [[[1, 2, 3, 4], [5, 6, 7, 8]], [[1, 2, 42, 42], [4, 5, 42, 42]]]
2-D 样本，
fill_value= 0，axes= (0, 1)，align= (4, 5)
样本在第一和第二轴上填充，以匹配每个轴的对齐要求。
input = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], [[1, 2], [4, 5]]] output = [[[1, 2, 3, 4, 0], [5, 6, 7, 8, 0], [9, 10, 11, 12, 0], [0, 0, 0, 0, 0]], [[1, 2, 0, 0, 0], [4, 5, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]
2-D 样本，
fill_value= 0，axes= (0, 1)，align= (1, 2)，shape= (4, -1)
样本在第一个轴上填充到最小范围 4，在第二个轴上填充以匹配批次中最大的样本和对齐值 2。
input = [[[1, 2, 3], [4, 5, 6]], [[1, 2], [4, 5], [6, 7]]] output = [[[1, 2, 3, 0], [4, 5, 6, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[1, 2, 0, 0], [4, 5, 0, 0], [6, 7, 0, 0], [0, 0, 0, 0]]]
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
align¶ (int 或 int 列表或 int 的 TensorList，可选, 默认值 = []) –
如果指定，此参数确定由
axes或axis_names指定的维度上的对齐方式。在
axis = axes[i]上的范围将被调整为align[i]的倍数。如果提供整数值，则对齐限制将应用于所有填充轴。
要仅使用对齐，即没有任何默认或显式填充行为，请将指定轴的最小
shape设置为 1。axes¶ (int 或 int 列表或 int 的 TensorList，可选, 默认值 = []) –
批次样本将在其上填充的轴的索引。
负值被解释为从后往前计数维度。有效范围：
[-ndim, ndim-1]，其中 ndim 是输入数据中的维度数。axis_names和axes参数是互斥的。如果axes和axis_names为空或未提供，则输出将在所有轴上填充。axis_names¶ (布局字符串, 可选, 默认值 = ‘’) –
批次样本将在其上填充的轴的名称。
axis_names和axes参数是互斥的。如果axes和axis_names为空或未提供，则输出将在所有轴上填充。bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
fill_value¶ (float 或 float 的 TensorList，可选, 默认值 = 0.0) – 用于填充批次的值。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
shape¶ (int 或 int 列表或 int 的 TensorList，可选, 默认值 = []) –
由
axes或axis_names指定的轴上输出形状的范围。为轴指定 -1 会恢复默认行为，即将轴扩展以适应批次中最大样本的对齐大小。
如果提供的范围小于样本的范围，则仅应用填充以匹配所需的对齐方式。例如，要禁用轴上的填充（除了对齐所需的填充之外），您可以指定值 1。
- class nvidia.dali.ops.Paste(*, bytes_per_sample_hint=[0], fill_value=None, min_canvas_size=0.0, n_channels=3, paste_x=0.5, paste_y=0.5, preserve=False, ratio=None, device=None, name=None)#
将输入图像粘贴到更大的画布上，其中画布大小等于
输入大小 * 比例。- 支持的后端
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
fill_value¶ (int 或 int 列表) –
用于填充画布的颜色的值元组。
元组的长度必须等于
n_channels。min_canvas_size¶ (float 或 float 的 TensorList，可选, 默认值 = 0.0) – 在按比例缩放输入大小后，强制执行最小粘贴画布尺寸。
n_channels¶ (int, 可选, 默认值 = 3) – 图像中的通道数。
paste_x¶ (float 或 float 的 TensorList，可选, 默认值 = 0.5) – 粘贴的水平位置，以 (0.0 - 1.0) 图像坐标表示。
paste_y¶ (float 或 float 的 TensorList，可选, 默认值 = 0.5) – 粘贴的垂直位置，以 (0.0 - 1.0) 图像坐标表示。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
ratio¶ (float 或 float 的 TensorList) – 画布大小与输入大小的比率。必须 >= 1。
- class nvidia.dali.ops.PeekImageShape(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT64, preserve=False, device=None, name=None)#
获取已编码图像的形状。
此运算符返回图像在解码后将具有的形状。
注意
不建议将此运算符与动态执行器（管道构造函数中的 exec_dynamic=True）一起使用。请改为在解码后的图像上使用
nvidia.dali.pipeline.DataNode.shape()。- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.INT64) – 大小转换到的数据类型。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
type¶ (
nvidia.dali.types.DALIDataType) –
- class nvidia.dali.ops.PerFrame(*, bytes_per_sample_hint=[0], preserve=False, replace=False, device=None, name=None)#
将输入张量标记为序列。
该运算符修改输入数据的布局字符串，以指示批次包含序列。只有布局会受到影响，而数据保持不变。
当处理序列时，运算符可用于提供逐帧张量参数。例如，以下代码片段显示了如何将
gaussian_blur应用于序列批次，以便为每个序列中的每个帧使用不同的sigma@pipeline_def def random_per_frame_blur(): video, _ = fn.readers.video_resize(sequence_length=50, ...) sigma = fn.random.uniform(range=[0.5, 5], shape=(50,)) blurred = fn.gaussian_blur(video, sigma=fn.per_frame(sigma)) return blurred
请注意，指定为逐帧参数的批次中每个张量的最外层维度必须与给定运算符处理的相应序列中的帧数匹配。例如，在呈现的示例中，
video批次中的每个序列都有 50 帧，因此sigma的形状为(50,)。请查阅序列处理运算符的给定参数的文档，以了解它是否支持逐帧输入。
如果传递给
per-frame运算符的输入没有布局，则会设置一个新布局，该布局以F开头，并用*填充以匹配输入的维度。否则，根据replace标志，运算符要么检查布局的第一个字符是否等于F，要么将该字符替换为F。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
- class nvidia.dali.ops.PermuteBatch(*, bytes_per_sample_hint=[0], indices=None, preserve=False, device=None, name=None)#
返回一个张量批次，该批次通过基于
indices参数中给出的索引从输入中选择张量而构建。out_tensor[i] = in_tensor[indices[i]]
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
indices¶ (int 或 list of int 或 TensorList of int) –
索引列表，与当前批次大小匹配，或表示输入批次中张量索引的标量批次。
索引必须在
[0..batch_size)范围内。允许重复和省略。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中删除，即使其输出未使用。
- class nvidia.dali.ops.PowerSpectrum(*, axis=-1, bytes_per_sample_hint=[0], nfft=None, power=2, preserve=False, device=None, name=None)#
计算信号的功率谱。
- 支持的后端
‘cpu’
- 关键字参数:
axis¶ (int, 可选, 默认值 = -1) –
要变换到频域的维度的索引。
默认情况下，选择最后一个维度。
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
nfft¶ (int, 可选) –
FFT 的大小。
默认情况下，选择
nfft以匹配变换轴中数据的长度。输出中创建的 bin 的数量使用以下公式计算
nfft // 2 + 1
注意
输出仅表示频谱的正半部分。
power¶ (int, 可选, 默认值 = 2) –
FFT 幅度的指数。
支持的值包括
2表示功率谱(real*real + imag*imag)1表示复数幅度(sqrt(real*real + imag*imag))。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中删除，即使其输出未使用。
- class nvidia.dali.ops.PreemphasisFilter(*, border='clamp', bytes_per_sample_hint=[0], dtype=DALIDataType.FLOAT, preemph_coeff=0.97, preserve=False, device=None, name=None)#
将预加重滤波器应用于输入数据。
此滤波器以简单形式表示，可以用公式表示
Y[t] = X[t] - coeff * X[t-1] if t > 1 Y[t] = X[t] - coeff * X_border if t == 0
其中
X和Y分别是输入和输出信号。X_border的值取决于border参数X_border = 0 if border_type == 'zero' X_border = X[0] if border_type == 'clamp' X_border = X[1] if border_type == 'reflect'
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
border¶ (str, 可选, 默认值 = ‘clamp’) – 边界值策略。可能的值为 "zero"、"clamp"、"reflect"。
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.FLOAT) – 输出的数据类型。preemph_coeff¶ (float 或 TensorList of float, 可选, 默认值 = 0.97) – 预加重系数
coeff。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中删除，即使其输出未使用。
- class nvidia.dali.ops.PythonFunction(function, num_outputs=1, device='cpu', batch_processing=False, **kwargs)#
执行 Python 函数。
此运算符可用于在 DALI pipeline 中执行自定义 Python 代码。该函数从 DALI 接收数据，对于 CPU 运算符，数据为 NumPy 数组，对于 GPU 运算符，数据为 CuPy 数组。它应以相同的格式返回结果。有关更通用的数据格式，请参阅
nvidia.dali.fn.dl_tensor_python_function()。该函数不应修改输入张量。警告
此算子与 TensorFlow 集成不兼容。
警告
当 pipeline 启用条件执行时，必须采取额外的步骤来防止 function 被 AutoGraph 重写。有两种方法可以实现这一点
1. 在全局作用域中定义函数（即在
pipeline_def作用域之外）。如果 function 是另一个“工厂”函数的结果，则工厂函数必须在 pipeline 定义函数之外定义，并使用
@do_not_convert修饰。
更多详细信息可以在
@do_not_convert文档中找到。此算子允许序列输入并支持体积数据。
此算子将**不会**从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
batch_processing¶ (bool, 可选, 默认值 = False) –
确定函数是为每个批次调用一次，还是为批次中的每个样本单独调用。
如果设置为 True，该函数将接收其参数作为 NumPy 或 CuPy 数组的列表，分别用于 CPU 和 GPU 后端。
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
function¶ (object) –
定义算子功能的 Callable 对象。
警告
该函数不得持有对其使用的 Pipeline 的引用。如果持有，将形成对 Pipeline 的循环引用，并且 Pipeline 将永远不会被释放。
num_outputs¶ (int, 可选, 默认值 = 1) – 输出的数量。
output_layouts¶ (layout str 或 list of layout str, 可选) –
输出的 Tensor 数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则仅前几个输出设置了布局，其余输出未分配布局。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中删除，即使其输出未使用。
- static current_stream()#
获取 DALI 的当前 CUDA 流。
- class nvidia.dali.ops.ROIRandomCrop(*, bytes_per_sample_hint=[0], crop_shape=None, in_shape=None, preserve=False, roi_end=None, roi_shape=None, roi_start=None, seed=-1, device=None, name=None)#
生成一个固定形状的裁剪窗口，随机放置，以便尽可能多地包含提供的感兴趣区域 (ROI)。
如果 ROI 大于裁剪窗口，则裁剪窗口将是 ROI 的子窗口。如果 ROI 小于裁剪窗口，则整个 ROI 应包含在裁剪窗口中。
如果给定了输入形状 (
in_shape)，则选择生成的裁剪窗口以使其在输入形状的边界内。或者，可以将要裁剪的输入数据传递给运算符，在运算符中。当提供输入形状时，感兴趣区域应在输入的边界内，并且裁剪窗口形状不应大于输入形状。如果未提供输入形状，则生成的裁剪窗口是无界的，可能会导致越界裁剪。
裁剪窗口尺寸应明确提供 (
crop_shape)，并且 ROI 应使用roi_start/roi_end或roi_start/roi_shape指定。该运算符生成表示裁剪窗口起始坐标的输出。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop_shape¶ (int 或 list of int 或 TensorList of int) – 裁剪窗口尺寸。
in_shape¶ (int 或 list of int 或 TensorList of int, 可选) –
输入数据的形状。
如果提供，将选择裁剪窗口的起始位置，以使裁剪窗口在输入的边界内。
注意
提供
in_shape与直接将输入数据作为位置输入馈送不兼容。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中删除，即使其输出未使用。
roi_end¶ (int 或 list of int 或 TensorList of int, 可选) –
ROI 结束坐标。
roi_shape¶ (int 或 list of int 或 TensorList of int, 可选) –
ROI 形状。
roi_start¶ (int 或 list of int 或 TensorList of int) – ROI 起始坐标。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
- class nvidia.dali.ops.RandomBBoxCrop(*, all_boxes_above_threshold=True, allow_no_crop=True, aspect_ratio=[1.0, 1.0], bbox_layout='', bbox_prune_threshold=None, bytes_per_sample_hint=[0], crop_shape=[], input_shape=[], ltrb=True, num_attempts=1, output_bbox_indices=False, preserve=False, scaling=[1.0, 1.0], seed=-1, shape_layout='', threshold_type='iou', thresholds=[0.0], total_num_attempts=-1, device=None, name=None)#
对图像坐标空间应用前瞻性随机裁剪，同时保持边界框，并可选择性地保持标签一致。
这意味着在将随机裁剪运算符应用于图像坐标空间后，将调整或过滤掉边界框以匹配裁剪后的 ROI。应用的随机裁剪操作受到提供给运算符的参数的约束。
随机选择裁剪窗口候选，直到一个候选满足由
thresholds参数指定的重叠限制。thresholds值表示由threshold_type指定的最小重叠度量，例如裁剪窗口和边界框的 intersection-over-union 或作为交集区域和边界框区域的比率的相对重叠。此外，如果
allow_no_crop为 True，则裁剪可能会完全跳过，作为运算符的有效结果之一。以下是随机裁剪的可用模式
- 随机形状的窗口，随机放置在原始输入空间中。随机裁剪窗口尺寸被选择为满足纵横比和相对面积限制。如果提供了
input_shape，它将被考虑用于纵横比范围检查。否则，纵横比将以相对术语计算。换句话说，如果没有input_shape，纵横比 1.0 等效于输入图像的纵横比。 - 固定大小的窗口，随机放置在原始输入空间中。随机裁剪窗口尺寸取自
crop_shape参数，锚点是随机选择的。当提供crop_shape时，也需要input_shape（这些维度是缩放输出边界框所必需的）。缩放输出边界框）。
num_attempts 参数可用于控制产生有效裁剪以匹配
thresholds中的最小重叠度量值的最大尝试次数。警告
当
allow_no_crop为 False 且thresholds不包含0.0时，如果您不增加num_attempts值，它可能会持续循环很长时间。输入：0: bboxes, (1: labels)
第一个输入
bboxes指的是作为二维张量提供的边界框，其中第一维指的是边界框的索引，第二维指的是坐标的索引。坐标是相对于原始图像尺寸的（这意味着范围为
[0.0, 1.0]），表示区域的起始位置，并根据 bbox_layout 的值，表示区域的结束位置或起始位置和形状。例如，bbox_layout=”xyXY” 表示边界框坐标遵循start_x、start_y、end_x和end_y的顺序，而bbox_layout=”xyWH” 表示顺序为start_x、start_y、width和height。有关更多信息，请参阅bbox_layout参数描述。可以提供可选的输入
labels，表示与每个边界框关联的标签。输出：0: anchor, 1: shape, 2: bboxes (, 3: labels, 4: bboxes_indices)
生成的裁剪参数以两个单独的输出 anchor 和 shape 提供，可以直接馈送到
nvidia.dali.fn.slice()算子，以完成原始图像的裁剪。anchor 和 shape 包含裁剪区域的起始坐标和尺寸，格式分别为[x, y, (z)]和[w, h, (d)]。坐标可以用绝对或相对术语表示，表示形式取决于是否使用了固定的crop_shape。注意
即使 anchor 和 shape 由于提供了
crop_shape参数而表示绝对坐标，它们也作为float返回。为了使nvidia.dali.fn.slice()正确解释它们，应将 normalized_anchor 和 normalized_shape 设置为 False。第三个输出包含边界框，在通过质心或面积阈值进行过滤后（请参阅
bbox_prune_threshold参数），并且坐标已映射到新的坐标空间。下一个输出是可选的，它表示与过滤后的边界框关联的标签。如果提供了 labels 输入，则将存在此输出。
最后一个输出也是可选的，对应于通过上述过滤过程并在输出中存在的边界框的原始索引。如果选项
output_bbox_indices设置为 True，则将存在此输出。- 支持的后端
‘cpu’
- 关键字参数:
all_boxes_above_threshold¶ (bool, optional, default = True) –
如果设置为 True，则样本中的所有边界框都应与
thresholds指定的裁剪窗口重叠。如果边界框不重叠，则裁剪窗口被认为是无效的。如果设置为 False，并且至少一个边界框与窗口重叠，则该窗口被认为是有效的。
allow_no_crop¶ (bool, optional, default = True) – 如果设置为 True，则随机过程的可能结果之一将是不裁剪，就像结果是从中选择的另一个
thresholds值一样。aspect_ratio¶ (float 或 list of float, optional, default = [1.0, 1.0]) –
裁剪窗口的有效纵横比范围。
此参数可以指定为两个值（最小值，最大值）或六个值（三个对），具体取决于输入的维度。
- 对于 2D 边界框，应提供一个有效纵横比 (x/y) 范围（例如
[min_xy, max_xy]）。 - 对于 3D 边界框，可以为 x/y、x/z 和 y/z 维度对指定三个单独的纵横比范围。它们按以下顺序提供：
[min_xy, max_xy, min_xz, max_xz, min_yz, max_yz]。或者，如果仅提供一个纵横比范围，它将用于所有三个维度对。
min的值应大于0.0，并且最小值应小于或等于max值。默认情况下，生成正方形窗口。注意
提供
aspect_ratio和scaling与显式指定crop_shape不兼容。注意
如果提供了
input_shape，则在计算裁剪窗口纵横比时会考虑它。否则，纵横比范围是相对于图像尺寸的。换句话说，当未指定input_shape时，纵横比 1.0 等效于图像的原始纵横比。bbox_layout¶ (layout str, optional, default = ‘’) –
确定边界框坐标的含义。
此参数的值是一个字符串，其中包含以下字符
x (horizontal start anchor), y (vertical start anchor), z (depthwise start anchor), X (horizontal end anchor), Y (vertical end anchor), Z (depthwise end anchor), W (width), H (height), D (depth).
注意
如果此值留空，则根据维度数，假定为 “xyXY” 或 “xyzXYZ”。
bbox_prune_threshold¶ (float, optional) –
控制何时将边界框视为在 ROI 之外并被修剪。如果设置此参数，则当边界框在其区域内 ROI 中的面积比例大于或等于指定的阈值 [0.0,1.0] 时，将保留这些框。如果未设置此参数，则当边界框的质心在 ROI 之外时，将修剪这些框。
例如，当 bbox_prune_threshold=0.2 时，至少有 20% 的原始面积在 ROI 内的边界框将被保留，小于或等于此值的边界框将被修剪。如果 bbox_prune_threshold=0.0，则所有在 ROI 中有存在的框都将被保留。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop_shape¶ (int 或 list of int 或 TensorList of int, optional, default = []) –
如果提供，则随机裁剪窗口尺寸将固定为此形状。
维度的顺序由
shape_layout中提供的布局确定。注意
当提供
crop_shape时，也应提供input_shape。显式提供crop_shape与使用scaling和aspect_ratio参数不兼容。input_shape¶ (int 或 list of int 或 TensorList of int, optional, default = []) –
指定原始输入图像的形状。
维度的顺序由
shape_layout中提供的布局确定。ltrb¶ (bool, optional, default = True) –
如果设置为 True，则边界框作为
[left, top, right, bottom]返回；否则，它们作为[left, top, width, height]提供。警告
此参数已弃用。要指定边界框编码，请改用
bbox_layout。例如，ltrb=True等于bbox_layout=”xyXY”，而ltrb=False对应于bbox_layout=”xyWH”。num_attempts¶ (int, optional, default = 1) –
获取与
aspect_ratio和从thresholds中选择的值匹配的裁剪窗口的尝试次数。在每次
num_attempts之后，将选择不同的阈值，直到阈值达到最大值total_num_attempts（如果提供），否则无限期地继续。output_bbox_indices¶ (bool, optional, default = False) – 如果设置为 True，则将返回一个额外的输出，其中包含通过质心过滤器并在输出边界框中存在的边界框的原始索引。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
scaling¶ (float 或 list of float, optional, default = [1.0, 1.0]) –
相对于原始图像尺寸的裁剪尺寸范围
[min, max]。min和max的值必须满足条件0.0 <= min <= max。注意
当显式指定
crop_shape值时，提供aspect_ratio和scaling不兼容。seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shape_layout¶ (layout str, optional, default = ‘’) –
确定
crop_shape和input_shape中提供的维度的含义。这些值是
W(宽度)H(高度)D(深度)
注意
如果留空，则根据维度数，将假定为
"WH"或"WHD"。threshold_type¶ (str, optional, default = ‘iou’) –
确定
thresholds的含义。默认情况下，阈值是指边界框相对于裁剪窗口的交并比 (IoU)。或者，可以将阈值设置为 “overlap” 以指定将落在裁剪窗口内的边界框的面积分数（按面积）。例如，阈值
1.0表示整个边界框必须包含在结果裁剪窗口中。thresholds¶ (float 或 list of float, optional, default = [0.0]) –
边界框相对于裁剪窗口的最小 IoU 或不同的度量，如果由
threshold_type指定。每个样本随机选择一个
thresholds，并且运算符将完成最多指定次数的尝试，以生成随机裁剪窗口，使其选定的度量高于该阈值。有关配置尝试次数的更多信息，请参阅num_attempts。total_num_attempts¶ (int, optional, default = -1) –
如果提供，则表示获取与
aspect_ratio和从thresholds中选择的任何值匹配的裁剪窗口的最大总尝试次数。在
total_num_attempts次尝试后，将选择最佳候选者。如果未指定此值，则裁剪搜索将无限期地继续，直到找到有效的裁剪为止。
警告
如果您不提供
total_num_attempts值，如果参数施加的条件无法满足，则可能导致无限循环。
- __call__(__boxes, __labels=None, /, *, all_boxes_above_threshold=True, allow_no_crop=True, aspect_ratio=[1.0, 1.0], bbox_layout='', bbox_prune_threshold=None, bytes_per_sample_hint=[0], crop_shape=[], input_shape=[], ltrb=True, num_attempts=1, output_bbox_indices=False, preserve=False, scaling=[1.0, 1.0], seed=-1, shape_layout='', threshold_type='iou', thresholds=[0.0], total_num_attempts=-1, device=None, name=None)#
算子调用，用于图定义中。
- class nvidia.dali.ops.RandomCropGenerator(*, bytes_per_sample_hint=[0], num_attempts=10, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, device=None, name=None)#
生成具有随机选择的面积和纵横比的裁剪窗口。
期望一维输入，表示我们要裁剪的输入的形状（HW 或 HWC 表示）。
生成两个输出，分别表示裁剪窗口的 anchor 和 shape。
此运算符的输出（anchor 和 shape）可以馈送到 fn.slice、fn.decoders.image_slice 或任何其他接受感兴趣区域的运算符。例如
crop_anchor, crop_shape = fn.random_crop_generator(image_shapes) images_crop = fn.slice(images, start=crop_anchor, shape=crop_shape, axes=[0, 1])
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
num_attempts¶ (int, optional, default = 10) – 用于选择随机面积和纵横比的最大尝试次数。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
random_area¶ (float 或 list of float, optional, default = [0.08, 1.0]) –
从中选择随机面积分数
A的范围。裁剪图像的面积将等于
A* 原始图像的面积。random_aspect_ratio¶ (float 或 list of float, optional, default = [0.75, 1.333333]) – 从中选择随机纵横比（宽度/高度）的范围。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
- class nvidia.dali.ops.RandomResizedCrop(*, antialias=True, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, num_attempts=10, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, size=None, temp_buffer_hint=0, device=None, name=None)#
执行具有随机选择的面积和纵横比的裁剪，并将其调整为指定的大小。
期望三维输入，样本布局为高度、宽度、通道 (HWC)。
此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
antialias¶ (bool, optional, default = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
必须与输入类型或
float相同。 如果未设置，则使用输入类型。interp_type¶ (
nvidia.dali.types.DALIInterpType或 TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来为缩小和放大指定不同的过滤。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。min_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, 可选, 默认值 = 32) – 在内核调用中处理的最大图像数量。
num_attempts¶ (int, 可选, 默认值 = 10) – 用于选择随机区域和宽高比的最大尝试次数。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也阻止其从图中移除。
random_area¶ (float 或 float 列表, 可选, 默认值 = [0.08, 1.0]) –
从中选择随机面积分数
A的范围。裁剪图像的面积将等于
A* 原始图像的面积。random_aspect_ratio¶ (float 或 float 列表, 可选, 默认值 = [0.75, 1.333333]) – 选择随机宽高比（宽度/高度）的范围。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
size¶ (int 或 int 列表) – 调整大小后的图像尺寸。
temp_buffer_hint¶ (int, 可选, 默认值 = 0) –
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
- __call__(__input, /, *, antialias=True, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, num_attempts=10, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, size=None, temp_buffer_hint=0, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'CHW', 'FHWC', 'FCHW', 'CFHW')) – 算子的输入。
- class nvidia.dali.ops.Reinterpret(*, bytes_per_sample_hint=[0], dtype=None, layout='', preserve=False, rel_shape=[], shape=[], src_dims=[], device=None, name=None)#
将输入的内容视为具有不同的类型、形状和/或布局。
缓冲区内容不会被复制。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
输出的总大小（以字节为单位）必须与输入匹配。如果未提供形状，则最内层维度将相应调整。如果最内层维度的字节大小不能被目标类型的大小整除，则会发生错误。
layout¶ (布局字符串, 可选, 默认值 = ‘’) –
数据的新布局。
如果未指定值，如果维度数与现有布局匹配，则保留输出布局。如果维度数不匹配，则参数将重置为空。如果设置了值且不为空，则布局必须与输出的维度匹配。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也阻止其从图中移除。
rel_shape¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = []) –
输出的相对形状。
输出形状通过将输入形状乘以
rel_shape计算得出。out_shape[i] = in_shape[i] * rel_shape[i]
可以使用额外的参数
src_dims来更改用于计算输出形状的源维度out_shape[i] = in_shape[src_dims[i]] * rel_shape[i]
可以有一个负的范围，用于接收匹配输入体积所需的大小。例如，形状为
[480, 640, 3]的输入和rel_shape = [0.5, -1]会产生形状为[240, 3840]的输出。维度数受以下限制：
shape¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = []) –
输出的期望形状。
可以有一个负的范围，用于接收匹配输入体积所需的大小。例如，形状为
[480, 640, 3]的输入和shape = [240, -1]会产生形状为[240, 3840]的输出。src_dims¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = []) –
要保留的维度索引。
此参数可用于操作现有维度的顺序，或删除或添加维度。特殊索引值 -1 可用于插入新维度。
例如，重塑形状为
[300, 200, 1]的样本和src_dims参数[-1, 1, 0]会产生输出形状[1, 200, 300]。在开头插入一个范围为 1 的前导维度，后跟第一个原始维度，但顺序相反。最后一个维度被删除。src_dims参数可以与rel_shape一起使用，在这种情况下，rel_shape中的相对范围描述目标维度。在上面的示例中，指定rel_shape = [-1, 0.5, 2]将导致输出形状[1, 100, 600]。所有索引都必须在输入有效维度的范围内，或为 -1。
- class nvidia.dali.ops.Reshape(*, bytes_per_sample_hint=[0], layout='', preserve=False, rel_shape=[], shape=[], src_dims=[], device=None, name=None)#
将输入的内容视为具有不同的形状和/或布局。
缓冲区内容不会被复制。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
layout¶ (布局字符串, 可选, 默认值 = ‘’) –
数据的新布局。
如果未指定值，如果维度数与现有布局匹配，则保留输出布局。如果维度数不匹配，则参数将重置为空。如果设置了值且不为空，则布局必须与输出的维度匹配。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也阻止其从图中移除。
rel_shape¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = []) –
输出的相对形状。
输出形状通过将输入形状乘以
rel_shape计算得出。out_shape[i] = in_shape[i] * rel_shape[i]
可以使用额外的参数
src_dims来更改用于计算输出形状的源维度out_shape[i] = in_shape[src_dims[i]] * rel_shape[i]
可以有一个负的范围，用于接收匹配输入体积所需的大小。例如，形状为
[480, 640, 3]的输入和rel_shape = [0.5, -1]会产生形状为[240, 3840]的输出。维度数受以下限制：
shape¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = []) –
输出的期望形状。
可以有一个负的范围，用于接收匹配输入体积所需的大小。例如，形状为
[480, 640, 3]的输入和shape = [240, -1]会产生形状为[240, 3840]的输出。src_dims¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = []) –
要保留的维度索引。
此参数可用于操作现有维度的顺序，或删除或添加维度。特殊索引值 -1 可用于插入新维度。
例如，重塑形状为
[300, 200, 1]的样本和src_dims参数[-1, 1, 0]会产生输出形状[1, 200, 300]。在开头插入一个范围为 1 的前导维度，后跟第一个原始维度，但顺序相反。最后一个维度被删除。src_dims参数可以与rel_shape一起使用，在这种情况下，rel_shape中的相对范围描述目标维度。在上面的示例中，指定rel_shape = [-1, 0.5, 2]将导致输出形状[1, 100, 600]。所有索引都必须在输入有效维度的范围内，或为 -1。
- class nvidia.dali.ops.Resize(*, antialias=True, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, save_attrs=False, size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
调整图像大小。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
antialias¶ (bool, 可选, 默认值 = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
必须与输入类型或
float相同。 如果未设置，则使用输入类型。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 不再使用，将在未来版本中删除。
interp_type¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来指定用于缩小和放大时不同的滤波方式。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。max_size¶ (float 或 list of float, 可选) –
输出尺寸的限制。
当操作符配置为保持宽高比且仅指定较小尺寸时，另一维度（或多个维度）可能会变得非常大。当使用
resize_shorter参数或 “not_smaller” 模式，或者当某些范围未指定时，可能会发生这种情况。此参数限制了输出可以变得多大。此值可以按轴指定，也可以对所有轴统一指定。
注意
当与 “not_smaller” 模式或
resize_shorter参数一起使用时，max_size优先，并且保持宽高比 - 例如，使用mode="not_smaller", size=800, max_size=1400调整大小，尺寸为 1200x600 的图像将被调整为 1400x700。min_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, 可选, 默认值 = 32) – 内核调用中处理的最大图像数量。
mode¶ (str, 可选, 默认值 = ‘default’) –
调整大小模式。
以下是支持模式的列表
"default"- 图像被调整为指定大小。缺失的尺寸范围将使用提供的尺寸范围的平均比例进行缩放。"stretch"- 图像被调整为指定大小。缺失的尺寸范围根本不进行缩放。"not_larger"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不超过指定大小。例如，对于 1280x720 的图像，期望的输出大小为 640x480，实际会生成 640x360 的输出。"not_smaller"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不小于指定大小。例如，对于 640x480 的图像，期望的输出大小为 1920x1080，实际会生成 1920x1440 的输出。此参数与
resize_longer和resize_shorter互斥。
preserve¶ (bool, 可选, 默认值 = False) – 即使操作符的输出未使用，也阻止将其从图中移除。
resize_longer¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
调整大小后图像较长尺寸的长度。
此选项与
resize_shorter和显式尺寸参数互斥，并且操作符保持原始图像的宽高比。此选项等效于为所有维度指定相同尺寸和mode="not_larger"。resize_shorter¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
调整大小后图像较短尺寸的长度。
此选项与
resize_longer和显式尺寸参数互斥，并且操作符保持原始图像的宽高比。此选项等效于为所有维度指定相同尺寸和mode="not_smaller"。可以通过设置max_size参数来限制较长维度。有关更多信息，请参见max_size参数文档。resize_x¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
调整大小后图像 X 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_y未指定或为 0，则操作符保持原始图像的宽高比。负值会翻转图像。resize_y¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
调整大小后图像 Y 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_x未指定或为 0，则操作符保持原始图像的宽高比。负值会翻转图像。resize_z¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
调整大小后体积 Z 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_x和resize_y未指定或为 0，则操作将保持原始体积的宽高比。负值会翻转体积。roi_end¶ (float 或 list of float 或 TensorList of float, 可选) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果在任何维度中 ROI 原点大于 ROI 终点，则该区域在该维度中被翻转。roi_relative¶ (bool, 可选, 默认值 = False) – 如果为 true，则 ROI 坐标相对于输入大小，其中 0 表示顶部/左侧，1 表示底部/右侧
roi_start¶ (float 或 list of float 或 TensorList of float, 可选) –
输入感兴趣区域 (ROI) 的原点。
必须与
roi_end一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果在任何维度中 ROI 原点大于 ROI 终点，则该区域在该维度中被翻转。save_attrs¶ (bool, 可选, 默认值 = False) – 保存重塑属性以进行测试。
size¶ (float 或 list of float 或 TensorList of float, 可选) –
期望的输出大小。
必须是每个空间维度一个条目的列表/元组，不包括视频帧和通道。范围为 0 的维度被视为不存在，输出大小将根据其他范围和
mode参数计算。subpixel_scale¶ (bool, 可选, 默认值 = True) –
如果为 True，则直接指定或计算的分数大小将导致调整输入 ROI 以保持缩放因子。
否则，将调整缩放因子，以便源图像映射到舍入后的输出大小。
temp_buffer_hint¶ (int, 可选, 默认值 = 0) –
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
- __call__(__input, /, *, antialias=True, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, save_attrs=False, size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'FHWC', 'CHW', 'FCHW', 'CFHW', 'DHWC', 'FDHWC', 'CDHW', 'FCDHW', 'CFDHW')) – 操作符的输入。
- class nvidia.dali.ops.ResizeCropMirror(*, antialias=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mirror=0, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, rounding='round', size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
执行融合的调整大小、裁剪、镜像操作。
该操作的结果等效于先应用
resize，然后应用crop和flip。在内部，操作符计算相关的感兴趣区域，并对该区域执行单个调整大小操作。此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
antialias¶ (bool, 可选, 默认值 = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop¶ (float 或 list of float 或 TensorList of float, 可选) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w,crop_h和crop_d必须一起指定。为crop_w,crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，crop_W是裁剪窗口的宽度。有关
crop_x如何转换为整数值的更多详细信息，请参见rounding参数。crop_pos_y¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
裁剪窗口起始位置（通常为左上角）的归一化 (0.0 - 1.0) 垂直位置。
实际位置计算为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，crop_H是裁剪窗口的高度。有关
crop_y如何转换为整数值的更多详细信息，请参见rounding参数。crop_pos_z¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
仅适用于体积输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，crop_D是裁剪窗口的深度。有关
crop_z如何转换为整数值的更多详细信息，请参见rounding参数。crop_w¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
必须与输入类型或
float相同。 如果未设置，则使用输入类型。interp_type¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来为缩小和放大指定不同的滤波方式。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。max_size¶ (float 或 float 的 list, 可选) –
输出尺寸的限制。
当操作符配置为保持宽高比且仅指定较小尺寸时，另一个（或多个）尺寸可能会变得非常大。当使用
resize_shorter参数或 “not_smaller” 模式或当某些范围未指定时，可能会发生这种情况。此参数限制了输出可以变得多大。此值可以按轴指定，也可以对所有轴统一指定。
注意
当与 “not_smaller” 模式或
resize_shorter参数一起使用时，max_size优先，并且保持宽高比 - 例如，使用mode="not_smaller", size=800, max_size=1400调整大小，尺寸为 1200x600 的图像将被调整为 1400x700。min_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, 可选, 默认值 = 32) – 在内核调用中处理的最大图像数量。
mirror¶ (int 或 int 的 TensorList, 可选, 默认值 = 0) –
翻转的掩码
支持的值
0 - 不翻转
1 - 水平翻转
2 - 垂直翻转
4 - 深度方向翻转
上述任意按位组合
mode¶ (str, 可选, 默认值 = ‘default’) –
调整大小模式。
以下是支持模式的列表
"default"- 图像被调整为指定大小。缺失的尺寸范围将使用提供的尺寸范围的平均比例进行缩放。"stretch"- 图像被调整为指定大小。缺失的尺寸范围根本不进行缩放。"not_larger"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不超过指定大小。例如，对于 1280x720 的图像，期望的输出大小为 640x480，实际会生成 640x360 的输出。"not_smaller"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不小于指定大小。例如，对于 640x480 的图像，期望的输出大小为 1920x1080，实际会生成 1920x1440 的输出。此参数与
resize_longer和resize_shorter互斥。
preserve¶ (bool, 可选, 默认值 = False) – 阻止操作符从图中移除，即使其输出未被使用。
resize_longer¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像较长尺寸的长度。
此选项与
resize_shorter和显式尺寸参数互斥，并且操作符保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_larger"。resize_shorter¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像较短尺寸的长度。
此选项与
resize_longer和显式尺寸参数互斥，并且操作符保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_smaller"。可以通过设置max_size参数来限制较长维度。有关更多信息，请参阅max_size参数文档。resize_x¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像 X 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果未指定resize_y或为 0，则操作符保持原始图像的宽高比。负值会翻转图像。resize_y¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像 Y 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果未指定resize_x或为 0，则操作符保持原始图像的宽高比。负值会翻转图像。resize_z¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后体积 Z 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果未指定resize_x和resize_y或为 0，则操作符将保持原始体积的宽高比。负值会翻转体积。roi_end¶ (float 或 float 的 list 或 float 的 TensorList, 可选) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果在任何维度中 ROI 原点大于 ROI 终点，则该区域在该维度中被翻转。roi_relative¶ (bool, 可选, 默认值 = False) – 如果为 true，则 ROI 坐标相对于输入尺寸，其中 0 表示顶部/左侧，1 表示底部/右侧。
roi_start¶ (float 或 float 的 list 或 float 的 TensorList, 可选) –
输入感兴趣区域 (ROI) 的原点。
必须与
roi_end一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果在任何维度中 ROI 原点大于 ROI 终点，则该区域在该维度中被翻转。rounding¶ (str, 可选, 默认值 = ‘round’) –
确定用于将窗口的起始坐标转换为整数值的舍入函数（请参阅
crop_pos_x,crop_pos_y,crop_pos_z）。可能的值为
"round"- 四舍五入到最接近的整数值，中间值四舍五入到远离零的值。"truncate"- 丢弃数字的小数部分（向零截断）。
size¶ (float 或 float 的 list 或 float 的 TensorList, 可选) –
期望的输出大小。
必须是每个空间维度一个条目的列表/元组，不包括视频帧和通道。维度为 0 的范围被视为空缺，输出大小将根据其他范围和
mode参数计算。subpixel_scale¶ (bool, 可选, 默认值 = True) –
如果为 True，则直接指定或计算的分数大小将导致调整输入 ROI 以保持缩放因子。
否则，将调整缩放因子，以便源图像映射到舍入后的输出大小。
temp_buffer_hint¶ (int, 可选, 默认值 = 0) –
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
- __call__(__input, /, *, antialias=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mirror=0, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, rounding='round', size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'FHWC', 'CHW', 'FCHW', 'CFHW', 'DHWC', 'FDHWC', 'CDHW', 'FCDHW', 'CFDHW')) – 操作符的输入。
- class nvidia.dali.ops.Rotate(*, angle=None, axis=[], bytes_per_sample_hint=[0], dtype=None, fill_value=None, interp_type=DALIInterpType.INTERP_LINEAR, keep_size=False, preserve=False, size=[], device=None, name=None)#
按指定的角度旋转图像。
此操作符支持体数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
angle¶ (float 或 float 的 TensorList) –
图像旋转的角度，以度为单位。
对于二维数据，旋转是逆时针的，假设左上角位于
(0,0)。对于三维数据，angle是绕提供的轴的正向旋转。支持
per-frame输入。axis¶ (float 或 float 的 list 或 float 的 TensorList, 可选, 默认值 = []) –
仅适用于三维数据，并且是图像绕其旋转的轴。
该向量不需要归一化，但必须具有非零长度。反转向量等效于更改
angle的符号。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 的 list, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
如果未设置，则使用输入类型。
fill_value¶ (float, 可选) –
用于填充源图像外部区域的值。
如果未指定值，则源坐标将被钳制，并且边界像素将被重复。
interp_type¶ (
nvidia.dali.types.DALIInterpType, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 使用的插值类型。keep_size¶ (bool, 可选, 默认值 = False) –
如果为 True，则保持原始画布大小。
如果设置为 False（默认值），并且未设置大小，则会调整画布大小以容纳旋转后的图像，并尽可能减少填充。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool, 可选, 默认值 = False) – 阻止操作符从图中移除，即使其输出未被使用。
size¶ (float 或 float 的 list 或 float 的 TensorList, 可选, 默认值 = []) –
输出大小，以像素/点为单位。
非整数大小将四舍五入到最接近的整数。通道维度应排除在外（例如，对于 RGB 图像，请指定
(480,640)，而不是(480,640,3)）。
- class nvidia.dali.ops.SSDRandomCrop(*, bytes_per_sample_hint=[0], num_attempts=1, preserve=False, seed=-1, device=None, name=None)#
警告
此操作符现在已被弃用。请使用
RandomBBoxCrop()代替。执行一个随机裁剪，其中边界框的交并比 (IoU) 符合 0-1 之间随机选择的阈值。
当 IoU 低于阈值时，将生成一个新的随机裁剪，最多尝试 num_attempts 次。作为输入，此算子接受图像、边界框和标签。输出为裁剪后的图像、裁剪后的有效边界框和有效标签。
- 支持的后端
‘cpu’
- 关键字参数:
- __call__(__input_0, __input_1, __input_2, /, *, bytes_per_sample_hint=[0], num_attempts=1, preserve=False, seed=-1, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.SSDRandomCrop()类。
- class nvidia.dali.ops.Saturation(*, bytes_per_sample_hint=[0], dtype=None, image_type=DALIImageType.RGB, preserve=False, saturation=1.0, device=None, name=None)#
更改图像的饱和度级别。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
如果未设置，则使用输入类型。
image_type¶ (
nvidia.dali.types.DALIImageType, 可选, 默认值 = DALIImageType.RGB) – 输入和输出图像的色彩空间。preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也阻止将其从图中移除。
saturation¶ (float 或 float 的 TensorList, 可选, 默认值 = 1.0) –
饱和度更改因子。
值必须为非负数。
示例值
0 - 完全去饱和的图像。
1 - 图像的饱和度无变化。
支持
per-frame输入。
- class nvidia.dali.ops.SequenceReader(*, bytes_per_sample_hint=[0], dont_use_mmap=False, file_root=None, image_type=DALIImageType.RGB, initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, step=1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
警告
此算子现已弃用。请改用
readers.Sequence()。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。readers.sequence()的旧别名。
- class nvidia.dali.ops.SequenceRearrange(*, bytes_per_sample_hint=[0], new_order=None, preserve=False, device=None, name=None)#
重新排列序列中的帧。
假设最外层维度表示序列中的帧索引。如果输入具有非空布局描述，则它必须以
F（帧）开头。此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
new_order¶ (int 或 int 列表 或 int 的 TensorList) –
描述每个样本中元素新顺序的列表。
位置
i处的输出序列将包含输入序列中的元素new_order[i]out[i, ...] = in[new_order[i], ...]
元素可以重复或删除，但不允许为空输出序列。仅允许在
new_order中使用[0, input_outermost_extent)中的索引。可以按每个样本指定为 1D 张量。preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也阻止将其从图中移除。
- class nvidia.dali.ops.Shapes(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT64, preserve=False, device=None, name=None)#
-
返回输入批次中张量的形状。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.INT64) – 尺寸转换到的数据类型。preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也阻止将其从图中移除。
type¶ (
nvidia.dali.types.DALIDataType) –
- class nvidia.dali.ops.Slice(*, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], dtype=None, end=None, fill_values=[0.0], normalized_anchor=True, normalized_shape=True, out_of_bounds_policy='error', preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, device=None, name=None)#
提取子张量或切片。
注意
对于通用索引和切片，您可以使用 Python 索引语法。有关详细信息，请参阅 索引和切片 。
可以通过提供切片的起始和结束坐标，或起始坐标和形状来指定切片。坐标和形状都可以以绝对或相对方式提供。
切片参数可以通过以下命名参数指定
start: 切片起始坐标（绝对）rel_start: 切片起始坐标（相对）end: 切片结束坐标（绝对）rel_end: 切片结束坐标（相对）shape: 切片形状（绝对）rel_shape: 切片形状（相对）
可以通过提供起始和结束坐标或起始和形状来配置切片。相对和绝对参数可以混合使用（例如，可以将
rel_start与shape一起使用），只要起始和形状或结束被唯一地定义。或者，可以提供两个额外的位置输入，指定
__anchor和__shape。当使用位置输入时，可以使用两个额外的布尔参数normalized_anchor/normalized_shape来指定所提供参数的性质。将位置输入用于锚点和形状与上面指定的命名参数不兼容。注意
对于 GPU 后端和位置输入
__anchor和__shape，CPU 和 GPU 数据节点均被接受，但首选 CPU 输入。将这些参数作为 GPU 输入提供将导致额外的设备到主机复制及其相关的同步点。如果可能，请将__anchor和__shape作为 CPU 输入提供。切片参数应提供与
axis_names或axes参数指定的维度一样多的维度。默认情况下，
nvidia.dali.fn.slice()算子对切片参数使用归一化坐标和WH顺序。此操作符支持体数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = [1, 0]) –
用作维度索引的锚点和形状切片输入的维度顺序。
负值被解释为从后往前计数维度。有效范围：
[-ndim, ndim-1]，其中 ndim 是输入数据中的维度数。axis_names¶ (布局字符串, 可选, 默认值 = ‘WH’) –
用作锚点和形状切片输入的维度的顺序，如布局中所述。
如果提供值，则
axis_names的优先级高于axes。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
支持的类型：
FLOAT、FLOAT16和UINT8。如果未设置，则使用输入类型。
end¶ (int 或 int 列表 或 int 的 TensorList, 可选) –
切片的结束坐标。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。fill_values¶ (float 或 float 列表, 可选, 默认值 = [0.0]) –
确定填充值，仅当
out_of_bounds_policy设置为 “pad” 时才相关。如果提供标量值，则将用于所有通道。如果提供多个值，则值的数量和通道数必须相同（输出切片中维度
C的范围）。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 不再使用，将在未来版本中删除。
normalized_anchor¶ (bool, optional, default = True) –
确定是否应将锚点位置输入解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
注意
此参数仅在锚点数据类型为
float时相关。对于整数类型，坐标始终是绝对坐标。normalized_shape¶ (bool, optional, default = True) –
确定是否应将形状位置输入解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
注意
此参数仅在锚点数据类型为
float时相关。对于整数类型，坐标始终是绝对坐标。out_of_bounds_policy¶ (str, optional, default = ‘error’) –
确定在对输入进行越界区域切片时的策略。
以下是支持值的列表
"error"(默认)：尝试在输入边界之外切片将产生错误。"pad": 将根据需要使用零或使用fill_values参数指定的任何其他值来填充输入。"trim_to_shape"：切片窗口将被裁剪到输入的边界。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
rel_end¶ (float 或 float 列表或 float 的 TensorList，可选) –
切片的结束相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。rel_shape¶ (float 或 float 列表或 float 的 TensorList，可选) –
切片的相对形状（范围 [0.0 - 1.0]）。
提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入 anchor 和 shape 不兼容。rel_start¶ (float 或 float 列表或 float 的 TensorList，可选) –
切片的起始相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。shape¶ (int 或 int 列表或 int 的 TensorList，可选) –
切片的形状。
提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入 anchor 和 shape 不兼容。start¶ (int 或 int 列表或 int 的 TensorList，可选) –
切片的起始坐标。
注意：提供命名参数
start/end或start/shape与提供位置输入 anchor 和 shape 不兼容。
- __call__(__data, __anchor=None, __shape=None, /, *, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], dtype=None, end=None, fill_values=[0.0], normalized_anchor=True, normalized_shape=True, out_of_bounds_policy='error', preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__data¶ (TensorList) – 包含输入数据的批次。
__anchor¶ (1D TensorList，类型为 float 或 int，可选) –
（可选）包含切片起点的归一化或绝对坐标的输入（x0、x1、x2 等）。
整数坐标被解释为绝对坐标，而浮点坐标可以解释为绝对坐标或相对坐标，具体取决于
normalized_anchor的值。__shape¶ (1D TensorList，类型为 float 或 int，可选) –
（可选）包含切片维度的归一化或绝对坐标的输入（s0、s1、s2 等）。
整数坐标被解释为绝对坐标，而浮点坐标可以解释为绝对坐标或相对坐标，具体取决于
normalized_shape的值。
- class nvidia.dali.ops.Spectrogram(*, bytes_per_sample_hint=[0], center_windows=True, layout='ft', nfft=None, power=2, preserve=False, reflect_padding=True, window_fn=[], window_length=512, window_step=256, device=None, name=None)#
从一维信号（例如，音频）生成频谱图。
输入数据应为单通道（形状为
(nsamples,)、(nsamples, 1)或(1, nsamples)），类型为 float32。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
center_windows¶ (bool, optional, default = True) –
指示是否应填充提取的窗口，以便窗口函数在
window_step的倍数处居中。如果设置为 False，则信号将不会被填充，也就是说，只会提取输入范围内的窗口。
layout¶ (layout str, optional, default = ‘ft’) – 输出布局：“ft”（频率优先）或“tf”（时间优先）。
nfft¶ (int，可选) –
FFT 的大小。
在输出中创建的 bin 数量为
nfft // 2 + 1。注意
输出仅表示频谱的正半部分。
power¶ (int, optional, default = 2) –
频谱幅度的指数。
支持的值
1- 幅度，2- 功率（计算速度更快）。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
reflect_padding¶ (bool, optional, default = True) –
指示在信号边界之外进行采样时的填充策略。
如果设置为 True，则信号将相对于边界进行镜像；否则，信号将用零填充。
注意
当
center_windows设置为 False 时，此选项将被忽略。window_fn¶ (float 或 float 列表，可选，默认值 = []) –
窗口函数的样本，在计算 STFT 时，它将与每个提取的窗口相乘。
如果提供了值，则它应为大小为
window_length的浮点数列表。如果未提供值，则将使用 Hann 窗口。window_length¶ (int, optional, default = 512) – 窗口大小，以样本数为单位。
window_step¶ (int, optional, default = 256) – STFT 窗口之间的步长，以样本数为单位。
- class nvidia.dali.ops.Sphere(*, bytes_per_sample_hint=[0], fill_value=0.0, interp_type=DALIInterpType.INTERP_NN, mask=1, preserve=False, device=None, name=None)#
执行球形增强。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
fill_value¶ (float, optional, default = 0.0) – 用于填充的颜色值。
interp_type¶ (
nvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_NN) – 使用的插值类型。mask¶ (int 或 int 的 TensorList，可选，默认值 = 1) –
确定是否将此增强应用于输入图像。
以下是值：
0：不应用此变换。
1：应用此变换。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- class nvidia.dali.ops.Squeeze(*, axes=[], axis_names='', bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
移除作为
axes或axis_names给定的维度。移除会导致总体积发生变化的维度是错误的。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 int 列表或 int 的 TensorList，可选，默认值 = []) –
应移除的维度的索引。
所有压缩的维度的大小都应为 1，除非张量的总体积在压缩前后均为 0。所有索引都必须在输入有效维度的范围内
axis_names¶ (layout str, optional, default = ‘’) –
应移除的布局列。
所有压缩的维度的大小都应为 1，除非张量的总体积在压缩前后均为 0。所有布局名称都应存在于数据布局中。
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- class nvidia.dali.ops.Stack(*, axis=0, axis_name=None, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
沿新轴连接输入张量。
输入中各个张量的形状必须匹配。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axis¶ (int, optional, default = 0) –
输出张量中输入沿其堆叠的轴。
该轴插入到输入中相应轴的前面。值为 0 表示堆叠整个张量。指定
axis等于输入的维度数会导致来自输入的值交错）。接受的范围是 [-ndim, ndim]。负索引从末尾开始计数。
axis_name¶ (str, optional) –
要插入的新轴的名称。
一个字符的字符串，表示输出布局中的新轴。输出布局将通过将该字符插入到输入布局中由
axis指示的位置来构建。例如，指定axis = 0和axis_name = "C"以及输入布局“HW”将产生输出布局“CHW”bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
- __call__(__input_0, /, *__input_, axis=0, axis_name=None, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.Stack()类。
- class nvidia.dali.ops.TFRecordReader(path, index_path, features, **kwargs)#
警告
此运算符现已弃用。请使用
readers.TFRecord()代替。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.tfrecord()的旧别名。
- class nvidia.dali.ops.ToDecibels(*, bytes_per_sample_hint=[0], cutoff_db=-200.0, multiplier=10.0, preserve=False, reference=0.0, device=None, name=None)#
将幅度（实数，正数）转换为分贝刻度。
转换根据以下公式完成
min_ratio = pow(10, cutoff_db / multiplier) out[i] = multiplier * log10( max(min_ratio, input[i] / reference) )
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
cutoff_db¶ (float, 可选, 默认值 = -200.0) –
dB 中的最小或截止比率。
任何低于此值的值都将饱和。例如，
cutoff_db=-80的值对应于1e-8的最小比率。multiplier¶ (float, 可选, 默认值 = 10.0) – 对数乘以的因子。该值通常为 10.0 或 20.0，具体取决于幅度是否平方。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
reference¶ (float, 可选, 默认值 = 0.0) –
参考幅度。
如果未提供值，则输入的maximum值将用作参考。
注意
输入的maximum值将按每个样本计算。
- class nvidia.dali.ops.TorchPythonFunction(*, batch_processing=True, bytes_per_sample_hint=[0], function=None, num_outputs=1, output_layouts=None, preserve=False, device=None, name=None)#
执行在 Torch 张量上运行的函数。
此类类似于
nvidia.dali.fn.python_function()，但张量数据作为 PyTorch 张量处理。此算子允许序列输入并支持体积数据。
此算子将**不会**从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
batch_processing¶ (bool, 可选, 默认值 = True) – 确定函数是否将整个批次作为输入。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
function¶ (object) –
定义算子功能的 Callable 对象。
警告
该函数不得持有对其使用的 Pipeline 的引用。如果持有，将形成对 Pipeline 的循环引用，并且 Pipeline 将永远不会被释放。
num_outputs¶ (int, 可选, 默认值 = 1) – 输出数量。
output_layouts¶ (layout str 或 layout str 列表, 可选) –
输出的 Tensor 数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则仅前几个输出设置了布局，其余输出未分配布局。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
- __call__(*input, batch_processing=True, bytes_per_sample_hint=[0], function=None, num_outputs=1, output_layouts=None, preserve=False, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.TorchPythonFunction()类。
- class nvidia.dali.ops.Transpose(*, bytes_per_sample_hint=[0], output_layout='', perm=None, preserve=False, transpose_layout=True, device=None, name=None)#
通过基于
perm参数重新排序维度来转置张量。目标维度
i从源维度perm[i]获得。例如，对于具有
HWC布局的源图像，shape = (100, 200, 3)，以及perm = [2, 0, 1]，它将生成具有CHW布局和shape = (3, 100, 200)的目标图像，保持以下等式\[dst(x_2, x_0, x_1) = src(x_0, x_1, x_2)\]这等效于
\[dst(x_{perm[0]}, x_{perm[1]}, x_{perm[2]}) = src(x_0, x_1, x_2)\]对于所有有效坐标。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
output_layout¶ (layout str, 可选, 默认值 = ‘’) –
显式设置输出数据布局。
如果指定此参数，则
transpose_layout将被忽略。perm¶ (int 或 int 列表，可选) –
输入维度的排列，例如，[2, 0, 1]。
如果未给出，则维度将反转。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
transpose_layout¶ (bool, 可选, 默认值 = True) –
设置为 True 时，输出数据布局中的轴名称将根据
perm进行排列。否则，输入布局将复制到输出。如果设置了
output_layout，则此参数将被忽略。
- class nvidia.dali.ops.Uniform(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, range=[-1.0, 1.0], seed=-1, shape=None, values=None, device=None, name=None)#
警告
此运算符现已弃用。请使用
random.Uniform()代替。生成服从均匀分布的随机数。
它可以配置为在
range[min, max) 范围内生成连续均匀分布，或者生成离散均匀分布，其中任何指定的values[v0, v1, …, vn] 以相等的概率出现。生成数据的形状可以通过
shape参数显式指定，也可以选择与__shape_like输入的形状匹配（如果提供）。如果两者都不存在，则每个样本生成一个值。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
range¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = [-1.0, 1.0]) –
连续均匀分布的范围
[min, max)。此参数与
values互斥。警告
当指定整数类型作为
dtype时，由于舍入，生成的数字可能会超出指定的范围。seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表或 int 的 TensorList, 可选) – 输出数据的形状。
values¶ (float 或 float 列表或 float 的 TensorList, 可选) –
离散均匀分布产生的离散值 [v0, v1, …, vn]。
此参数与
range互斥。
- class nvidia.dali.ops.VideoReader(*, additional_decode_surfaces=2, bytes_per_sample_hint=[0], channels=3, dont_use_mmap=False, dtype=DALIDataType.UINT8, enable_frame_num=False, enable_timestamps=False, file_list='', file_list_frame_num=False, file_list_include_preceding_frame=False, file_root='', filenames=[], image_type=DALIImageType.RGB, initial_fill=1024, labels=None, lazy_init=False, normalized=False, num_shards=1, pad_last_batch=False, pad_sequences=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, skip_vfr_check=False, step=-1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
警告
此运算符现已弃用。请使用
readers.Video()代替。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.video()的旧别名。
- class nvidia.dali.ops.VideoReaderResize(*, additional_decode_surfaces=2, antialias=True, bytes_per_sample_hint=[0], channels=3, dont_use_mmap=False, dtype=DALIDataType.UINT8, enable_frame_num=False, enable_timestamps=False, file_list='', file_list_frame_num=False, file_list_include_preceding_frame=False, file_root='', filenames=[], image_type=DALIImageType.RGB, initial_fill=1024, interp_type=DALIInterpType.INTERP_LINEAR, labels=None, lazy_init=False, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', normalized=False, num_shards=1, pad_last_batch=False, pad_sequences=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, seed=-1, sequence_length=None, shard_id=0, size=None, skip_cached_images=False, skip_vfr_check=False, step=-1, stick_to_shard=False, stride=1, subpixel_scale=True, temp_buffer_hint=0, tensor_init_bytes=1048576, device=None, name=None)#
警告
此运算符现已弃用。请使用
readers.VideoResize()代替。在 DALI 1.0 中，所有读取器都已移至专用的
readers子模块中，并已重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.video_resize()的旧别名。
- class nvidia.dali.ops.WarpAffine(*, bytes_per_sample_hint=[0], dtype=None, fill_value=None, interp_type=DALIInterpType.INTERP_LINEAR, inverse_map=True, matrix=[], preserve=False, size=[], device=None, name=None)#
对图像应用仿射变换。
此操作符支持体数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
如果未设置，则使用输入类型。
fill_value¶ (float, optional) –
用于填充源图像外部区域的值。
如果未指定值，则源坐标将被钳制，并且边界像素将被重复。
interp_type¶ (
nvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 使用的插值类型。inverse_map¶ (bool, optional, default = True) – 如果给定的变换是从目标到源的映射，则设置为
False，否则为True。matrix¶ (float or list of float or TensorList of float, optional, default = []) –
变换矩阵。
当
inverse_map选项设置为 true（默认）时，该矩阵表示从目标到源的映射。使用值列表(M11, M12, M13, M21, M22, M23)，此操作通过使用以下公式生成新图像dst(x,y) = src(M11 * x + M12 * y + M13, M21 * x + M22 * y + M23)
其中
[0, 0]坐标表示第一个像素的角。如果
inverse_map选项设置为 false，则矩阵表示从源到目标的变换，并在应用上述公式之前进行反转。它等效于 OpenCV 的
warpAffine操作，其中inverse_map参数类似于WARP_INVERSE_MAP标志。注意
除了此参数，运算符还可以接受第二个位置输入，在这种情况下，矩阵可以放置在 GPU 上。
支持
per-frame输入。output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
size¶ (float or list of float or TensorList of float, optional, default = []) –
输出大小，以像素/点为单位。
非整数大小将四舍五入到最接近的整数。通道维度应排除在外（例如，对于 RGB 图像，请指定
(480,640)，而不是(480,640,3)）。
- __call__(__data, __mtx=None, /, *, bytes_per_sample_hint=[0], dtype=None, fill_value=None, interp_type=DALIInterpType.INTERP_LINEAR, inverse_map=True, matrix=[], preserve=False, size=[], device=None, name=None)#
算子调用，用于图定义中。
- class nvidia.dali.ops.Water(*, ampl_x=10.0, ampl_y=10.0, bytes_per_sample_hint=[0], fill_value=0.0, freq_x=0.049087, freq_y=0.049087, interp_type=DALIInterpType.INTERP_NN, mask=1, phase_x=0.0, phase_y=0.0, preserve=False, device=None, name=None)#
执行水波增强，使图像看起来像在水下。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
ampl_x¶ (float, optional, default = 10.0) – x 方向波的振幅。
ampl_y¶ (float, optional, default = 10.0) – y 方向波的振幅。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
fill_value¶ (float, optional, default = 0.0) – 用于填充的颜色值。
freq_x¶ (float, optional, default = 0.049087) – x 方向波的频率。
freq_y¶ (float, optional, default = 0.049087) – y 方向波的频率。
interp_type¶ (
nvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_NN) – 使用的插值类型。mask¶ (int or TensorList of int, optional, default = 1) –
确定是否将此增强应用于输入图像。
以下是值：
0：不应用此变换。
1：应用此变换。
phase_x¶ (float, optional, default = 0.0) – x 方向波的相位。
phase_y¶ (float, optional, default = 0.0) – y 方向波的相位。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
- class nvidia.dali.ops.Zeros(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT32, preserve=False, shape=None, device=None, name=None)#
返回具有给定形状和类型的新数据，并用零填充。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.INT32) – 输出数据类型。preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
shape¶ (int or list of int or TensorList of int, optional) – 输出数据的形状。
- __call__(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT32, preserve=False, shape=None, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.ZerosLike(*, bytes_per_sample_hint=[0], dtype=DALIDataType.INT32, preserve=False, device=None, name=None)#
返回与输入数组具有相同形状和类型的新数据，并用零填充。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.INT32) – 覆盖输出数据类型。preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
- nvidia.dali.ops.python_op_factory(name, schema_name, internal_schema_name=None, generated=True)#
为运算符生成 ops API 类绑定。
nvidia.dali.ops.decoders#
- class nvidia.dali.ops.decoders.Audio(*, bytes_per_sample_hint=[0], downmix=False, dtype=DALIDataType.FLOAT, preserve=False, quality=50.0, sample_rate=0.0, device=None, name=None)#
从编码的音频数据中解码波形。
它支持以下音频格式：wav、flac 和 ogg。此运算符产生以下输出
output[0]: 一批解码后的数据
output[1]: 一批采样率 [Hz]。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
downmix¶ (bool, optional, default = False) –
如果设置为 True，则将所有输入通道下混为单声道。
如果启用下混，则解码器输出为 1D。如果禁用下混，则生成具有交错通道的 2D 输出。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) –输出数据类型。
支持的类型：
INT16,INT32,FLOAT。preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
quality¶ (float, optional, default = 50.0) –
重采样质量，其中 0 为最低，100 为最高。
0 提供 3 个 sinc 滤波器瓣，50 提供 16 个瓣，100 提供 64 个瓣。
sample_rate¶ (float or TensorList of float, optional, default = 0.0) – 如果指定，音频将被重采样到的目标采样率，单位为 Hz。
- class nvidia.dali.ops.decoders.Image(*, affine=True, bytes_per_sample_hint=[0], cache_batch_copy=True, cache_debug=False, cache_size=0, cache_threshold=0, cache_type='', device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, use_fast_idct=False, device=None, name=None)#
解码图像。
对于 jpeg 图像，根据选择的后端（“mixed”和“cpu”），实现分别使用 nvJPEG 库或 libjpeg-turbo。其他图像格式使用 OpenCV 或其他特定库（如 libtiff）解码。
如果与
mixed后端一起使用，并且硬件可用，则运算符将使用专用硬件解码器。警告
由于性能原因，对于驱动程序版本低于 455.x，硬件解码器将被禁用
解码器的输出采用 HWC 布局。
支持的格式：JPG、BMP、PNG、TIFF、PNM、PPM、PGM、PBM、JPEG 2000、WebP。请注意，JPEG 2000 解码的 GPU 加速仅适用于 CUDA 11 及更高版本。
注意
WebP 解码目前仅支持简单的文件格式（有损和无损压缩）。有关不同 WebP 文件格式的详细信息，请参阅 https://developers.google.com/speed/webp/docs/riff_container
注意
EXIF 方向元数据被忽略。
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
affine¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
cache_batch_copy¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则使用批量复制内核调用复制缓存中的多个图像。否则，除非批次中的顺序与缓存中的顺序相同，否则每个图像都使用
cudaMemcpy复制。cache_debug¶ (bool, optional, default = False) –
仅适用于
mixed后端类型。打印关于解码器缓存的调试信息。
cache_size¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。解码器缓存的总大小，以兆字节为单位。如果提供，则大于
cache_threshold的解码图像将被缓存在 GPU 内存中。cache_threshold¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。要缓存的解码图像的大小阈值（以字节为单位）。当图像被缓存时，在运算符输入处再次遇到它时，不再需要解码，从而节省处理时间。
cache_type¶ (str, optional, default = ‘’) –
仅适用于
mixed后端类型。以下是可用缓存类型的列表
threshold: 缓存每个大小大于cache_threshold的图像，直到缓存已满。阈值策略的预热时间为 1 个 epoch。
largest: 存储可以放入缓存的最大图像。最大策略的预热时间为 2 个 epoch注意
为了利用缓存，建议将读取器配置为 stick_to_shard=True，以限制多节点环境中每个解码器实例看到的唯一图像数量。
device_memory_padding¶ (int, optional, default = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符为每个线程预先分配一个请求大小的设备缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符根据提供的提示预先分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符为每个线程预先分配两个（由于双缓冲）请求大小的主机固定缓冲区。如果选择正确，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符根据提供的提示预先分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。hw_decoder_load¶ (float, optional, default = 0.65) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, optional, default = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ (bool, optional, default = False) –
仅适用于
mixed后端类型。打印关于 nvJPEG 分配的调试信息。关于最大分配的信息可能有助于确定数据集的
device_memory_padding和host_memory_padding的合适值。注意
统计信息是整个进程全局的，而不是每个运算符实例的，并且包括在构造期间进行的分配（如果填充提示为非零）。
output_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) –输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
preallocate_height_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
split_stages¶ (bool) –
警告
参数 split_stages 不再使用，将在未来版本中删除。
use_chunk_allocator¶ (bool) –
警告
参数 use_chunk_allocator 不再使用，将在未来版本中删除。
use_fast_idct¶ (bool, optional, default = False) –
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 时，或者当它设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__input, /, *, affine=True, bytes_per_sample_hint=[0], cache_batch_copy=True, cache_debug=False, cache_size=0, cache_threshold=0, cache_type='', device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.decoders.ImageCrop(*, affine=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rounding='round', use_fast_idct=False, device=None, name=None)#
解码图像并提取由固定窗口尺寸和可变锚点指定的感兴趣区域 (ROI)。
如果可能，此参数使用 ROI 解码 API（例如，libjpeg-turbo 和 nvJPEG）来减少解码时间和内存使用量。如果给定图像格式不支持 ROI 解码，它将解码整个图像并裁剪所选 ROI。
解码器的输出采用 HWC 布局。
支持的格式：JPG、BMP、PNG、TIFF、PNM、PPM、PGM、PBM、JPEG 2000、WebP。
注意
JPEG 2000 感兴趣区域 (ROI) 解码在 GPU 上未加速，并且将使用 CPU 实现，而与所选后端无关。对于 GPU 加速实现，请考虑使用单独的
decoders.image和crop算子。注意
EXIF 方向元数据被忽略。
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
affine¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 int 列表, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop¶ (float 或 float 列表 或 TensorList of float, optional) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 float 的 TensorList, optional, default = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w、crop_h和crop_d必须一起指定。为crop_w、crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 float 的 TensorList, optional, default = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 float 的 TensorList, optional, default = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，crop_W是裁剪窗口的宽度。有关
crop_x如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_y¶ (float 或 float 的 TensorList, optional, default = 0.5) –
裁剪窗口起始位置（通常为左上角）的归一化 (0.0 - 1.0) 垂直位置。
实际位置计算为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，crop_H是裁剪窗口的高度。有关
crop_y如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_z¶ (float 或 float 的 TensorList, optional, default = 0.5) –
仅适用于体积输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，crop_D是裁剪窗口的深度。有关
crop_z如何转换为整数值的更多详细信息，请参阅rounding参数。crop_w¶ (float 或 float 的 TensorList, optional, default = 0.0) –
裁剪窗口宽度（以像素为单位）。
device_memory_padding¶ (int, optional, default = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会为每个线程预分配一个请求大小的设备缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会根据提供的提示预分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会为每个线程预分配两个（由于双缓冲）请求大小的主机pinned缓冲区。如果选择正确，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会根据提供的提示预分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。hw_decoder_load¶ (float, optional, default = 0.65) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, optional, default = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ (bool, optional, default = False) –
仅适用于
mixed后端类型。打印有关 nvJPEG 分配的调试信息。有关最大分配的信息可能有助于确定数据集的
device_memory_padding和host_memory_padding的合适值。注意
统计信息是整个进程全局的，而不是每个运算符实例的，并且包括在构造期间进行的分配（如果填充提示为非零）。
output_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) –输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
preallocate_height_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
rounding¶ (str, optional, default = ‘round’) –
确定用于将窗口的起始坐标转换为整数值的舍入函数（参见
crop_pos_x、crop_pos_y、crop_pos_z）。可能的值为
"round"- 四舍五入到最接近的整数值，中间值四舍五入到远离零的值。"truncate"- 丢弃数字的小数部分（向零截断）。
split_stages¶ (bool) –
警告
参数 split_stages 不再使用，将在未来版本中删除。
use_chunk_allocator¶ (bool) –
警告
参数 use_chunk_allocator 不再使用，将在未来版本中删除。
use_fast_idct¶ (bool, optional, default = False) –
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为“cpu”或设置为“mixed”但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__input, /, *, affine=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rounding='round', use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.decoders.ImageRandomCrop(*, affine=True, bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, num_attempts=10, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, use_fast_idct=False, device=None, name=None)#
解码图像并随机裁剪它们。
裁剪窗口的面积（相对于整个图像）和纵横比可以分别限制为由
area和 aspect_ratio 参数指定的值范围。如果可能，该运算符使用 ROI 解码 API（例如，libjpeg-turbo 和 nvJPEG）来减少解码时间和内存使用量。如果给定图像格式不支持 ROI 解码，它将解码整个图像并裁剪所选 ROI。
解码器的输出采用 HWC 布局。
支持的格式：JPG、BMP、PNG、TIFF、PNM、PPM、PGM、PBM、JPEG 2000、WebP。
注意
JPEG 2000 感兴趣区域 (ROI) 解码在 GPU 上未加速，并且将使用 CPU 实现，而与所选后端无关。对于 GPU 加速实现，请考虑使用单独的
decoders.image和random_crop算子。注意
EXIF 方向元数据被忽略。
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
affine¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 int 列表, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
device_memory_padding¶ (int, optional, default = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会为每个线程预分配一个请求大小的设备缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会根据提供的提示预分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会为每个线程预分配两个（由于双缓冲）请求大小的主机pinned缓冲区。如果选择正确，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符会根据提供的提示预分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数完整运行数据集，然后复制统计信息中打印的最大分配值。hw_decoder_load¶ (float, optional, default = 0.65) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, optional, default = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ (bool, optional, default = False) –
仅适用于
mixed后端类型。打印关于 nvJPEG 分配的调试信息。关于最大分配的信息可能有助于确定数据集的
device_memory_padding和host_memory_padding的合适值。注意
统计信息是整个进程全局的，而不是每个运算符实例的，并且包括在构造期间进行的分配（如果填充提示为非零）。
num_attempts¶ (int, optional, default = 10) – 用于选择随机区域和宽高比的最大尝试次数。
output_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) –输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
preallocate_height_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
random_area¶ (float or list of float, optional, default = [0.08, 1.0]) –
从中选择随机面积分数
A的范围。裁剪图像的面积将等于
A* 原始图像的面积。random_aspect_ratio¶ (float or list of float, optional, default = [0.75, 1.333333]) – 选择随机宽高比（宽度/高度）的范围。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
split_stages¶ (bool) –
警告
参数 split_stages 不再使用，将在未来版本中删除。
use_chunk_allocator¶ (bool) –
警告
参数 use_chunk_allocator 不再使用，将在未来版本中删除。
use_fast_idct¶ (bool, optional, default = False) –
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 时，或者当它设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__input, /, *, affine=True, bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, num_attempts=10, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.decoders.ImageSlice(*, affine=True, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, end=None, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, normalized_anchor=True, normalized_shape=True, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, use_fast_idct=False, device=None, name=None)#
解码图像并提取感兴趣区域。
可以通过提供切片的起始和结束坐标，或起始坐标和形状来指定切片。坐标和形状都可以以绝对或相对方式提供。
切片参数可以通过以下命名参数指定
start：切片起始坐标（绝对坐标）rel_start：切片起始坐标（相对坐标）end：切片结束坐标（绝对坐标）rel_end：切片结束坐标（相对坐标）shape：切片形状（绝对坐标）rel_shape：切片形状（相对坐标）
可以通过提供起始和结束坐标，或起始和形状来配置切片。相对和绝对参数可以混合使用（例如，
rel_start可以与shape一起使用），只要起始和形状或结束坐标被唯一确定。或者，可以提供两个额外的位置输入，指定
__anchor和__shape。当使用位置输入时，可以使用两个额外的布尔参数normalized_anchor/normalized_shape来指定所提供参数的性质。为锚点和形状使用位置输入与上面指定的命名参数不兼容。切片参数应提供与
axis_names或axes参数指定的维度数量相同的维度。默认情况下，
nvidia.dali.fn.decoders.image_slice()运算符对切片参数使用归一化坐标和 “WH” 顺序。在可能的情况下，该参数使用 ROI 解码 API（例如，libjpeg-turbo 和 nvJPEG）来优化解码时间和内存使用量。当给定图像格式不支持 ROI 解码时，它将解码整个图像并裁剪选定的 ROI。
解码器的输出采用 HWC 布局。
支持的格式：JPG、BMP、PNG、TIFF、PNM、PPM、PGM、PBM、JPEG 2000、WebP。
注意
JPEG 2000 感兴趣区域 (ROI) 解码在 GPU 上未加速，并且无论选择哪个后端，都将使用 CPU 实现。对于 GPU 加速实现，请考虑使用单独的
decoders.image和slice运算符。注意
EXIF 方向元数据被忽略。
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
affine¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
axes¶ (int or list of int or TensorList of int, optional, default = [1, 0]) –
用作维度索引的锚点和形状切片输入的维度顺序。
负值被解释为从后往前计数维度。有效范围：
[-ndim, ndim-1]，其中 ndim 是输入数据中的维度数。axis_names¶ (layout str, optional, default = ‘WH’) –
用作锚点和形状切片输入的维度的顺序，如布局中所述。
如果提供值，则
axis_names的优先级高于axes。bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
device_memory_padding¶ (int, optional, default = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符为每个线程预分配一个请求大小的设备缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符根据提供的提示预分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。end¶ (int or list of int or TensorList of int, optional) –
切片的结束坐标。
注意：提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入锚点和形状不兼容。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符为每个线程预分配两个（由于双缓冲）请求大小的主机固定缓冲区。如果选择正确，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则运算符根据提供的提示预分配必要数量的缓冲区。如果正确选择该值，则在管道执行期间不会发生额外的分配。找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。hw_decoder_load¶ (float, optional, default = 0.65) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, optional, default = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ (bool, optional, default = False) –
仅适用于
mixed后端类型。打印关于 nvJPEG 分配的调试信息。关于最大分配的信息可能有助于确定数据集的
device_memory_padding和host_memory_padding的合适值。注意
统计信息是整个进程全局的，而不是每个运算符实例的，并且包括在构造期间进行的分配（如果填充提示为非零）。
normalized_anchor¶ (bool, optional, default = True) –
确定是否应将锚点位置输入解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
注意
此参数仅在锚点数据类型为
float时相关。对于整数类型，坐标始终是绝对坐标。normalized_shape¶ (bool, optional, default = True) –
确定是否应将形状位置输入解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
注意
此参数仅在锚点数据类型为
float时相关。对于整数类型，坐标始终是绝对坐标。output_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) –输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
preallocate_height_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 及更新架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
rel_end¶ (float or list of float or TensorList of float, optional) –
切片的结束相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入锚点和形状不兼容。rel_shape¶ (float or list of float or TensorList of float, optional) –
切片的相对形状（范围 [0.0 - 1.0]）。
提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入锚点和形状不兼容。rel_start¶ (float or list of float or TensorList of float, optional) –
切片的起始相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入锚点和形状不兼容。shape¶ (int or list of int or TensorList of int, optional) –
切片的形状。
提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入锚点和形状不兼容。split_stages¶ (bool) –
警告
参数 split_stages 不再使用，将在未来版本中删除。
start¶ (int or list of int or TensorList of int, optional) –
切片的起始坐标。
use_chunk_allocator¶ (bool) –
警告
参数 use_chunk_allocator 不再使用，将在未来版本中删除。
use_fast_idct¶ (bool, optional, default = False) –
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 时，或者当它设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__data, __anchor=None, __shape=None, /, *, affine=True, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, end=None, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.65, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, memory_stats=False, normalized_anchor=True, normalized_shape=True, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__data¶ (TensorList) – 包含输入数据的批次。
__anchor¶ (1D TensorList of float or int, optional) –
包含切片起点的归一化或绝对坐标的输入 (x0, x1, x2, …)。
整数坐标被解释为绝对坐标，而浮点坐标可以解释为绝对坐标或相对坐标，具体取决于
normalized_anchor的值。__shape¶ (1D TensorList of float or int, optional) –
包含切片维度归一化或绝对坐标的输入 (s0, s1, s2, …)。
整数坐标被解释为绝对坐标，而浮点坐标可以被解释为绝对或相对坐标，具体取决于
normalized_shape的值。
nvidia.dali.ops.experimental#
- class nvidia.dali.ops.experimental.AudioResample(*, bytes_per_sample_hint=[0], dtype=None, in_rate=None, out_length=None, out_rate=None, preserve=False, quality=50.0, scale=None, device=None, name=None)#
-
audio_resample()的旧别名。
- class nvidia.dali.ops.experimental.Debayer(*, algorithm='bilinear_npp', blue_position=None, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
执行图像去马赛克/拜耳化 (demosaicing/debayering) 操作。
使用指定的颜色滤镜阵列将单通道图像转换为 RGB 图像。
支持的输入类型为
uint8_t和uint16_t。输入图像必须是 2D 张量 (HW) 或 3D 张量 (HWC)，其中通道数为 1。该运算符支持图像/视频类输入序列（布局FHW）。例如，以下代码片段展示了对批量图像序列进行去马赛克操作
def bayered_sequence(sample_info): # some actual source of video inputs with corresponding pattern # as opencv-style string video, bayer_pattern = get_sequence(sample_info) if bayer_pattern == "bggr": blue_position = [0, 0] elif bayer_pattern == "gbrg": blue_position = [0, 1] elif bayer_pattern == "grbg": blue_position = [1, 0] else: assert bayer_pattern == "rggb" blue_position = [1, 1] return video, np.array(blue_position, dtype=np.int32) @pipeline_def def debayer_pipeline(): bayered_sequences, blue_positions = fn.external_source( source=bayered_sequence, batch=False, num_outputs=2, layout=["FHW", None]) # note the "FHW" layout, for plain images it would be "HW" debayered_sequences = fn.experimental.debayer( bayered_sequences.gpu(), blue_position=blue_positions) return debayered_sequences
此运算符允许序列输入。
- 支持的后端
‘gpu’
- 关键字参数:
algorithm¶ (str, optional, default = ‘bilinear_npp’) –
用于推断任何给定像素缺失颜色的算法。目前仅支持
bilinear_npp。bilinear_npp算法使用双线性插值来推断红色和蓝色值。对于绿色值，使用带有色彩相关的双线性插值，如 NPP 文档中所述。
blue_position¶ (int 或 list of int 或 TensorList of int) –
颜色滤镜阵列/拜耳瓦片 (bayer tile) 的布局。
2x2 拜耳瓦片中蓝色值的位置。支持的值对应于以下 OpenCV 拜耳布局
(0, 0)-BG/BGGR(0, 1)-GB/GBRG(1, 0)-GR/GRBG(1, 1)-RG/RGGB
该参数遵循 OpenCV 的约定，指的是从传感器矩阵的第二行和第二列开始的 2x2 瓦片。
例如，
(0, 0)/BG/BGGR对应于以下传感器矩阵R
G
R
G
R
G
B
G
B
G
R
G
R
G
R
G
B
G
B
G
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。（可选参数，默认值为 False）
- class nvidia.dali.ops.experimental.Dilate(*, anchor=[-1, -1], border_mode='constant', bytes_per_sample_hint=[0], iterations=1, mask_size=[3, 3], preserve=False, device=None, name=None)#
对输入图像执行膨胀操作。
此运算符允许序列输入。
- 支持的后端
‘gpu’
- 关键字参数:
anchor¶ (int 或 list of int 或 TensorList of int, optional, default = [-1, -1]) –
设置结构元素的锚点。默认值 (-1, -1) 使用元素的中心作为锚点。
支持
per-frame输入。border_mode¶ (str, optional, default = ‘constant’) – 访问输入图像外部的元素时要使用的边界模式。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
iterations¶ (int, optional, default = 1) – 执行操作的次数，通常设置为 1。设置为大于 1 的值相当于每次额外迭代将掩码大小增加 (mask_width - 1, mask_height -1)。
mask_size¶ (int 或 list of int 或 TensorList of int, optional, default = [3, 3]) –
结构元素的大小。
支持
per-frame输入。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。（可选参数，默认值为 False）
- class nvidia.dali.ops.experimental.Equalize(*, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
执行灰度/逐通道直方图均衡化。
支持的输入是 uint8_t 类型的图像和视频。
此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
- class nvidia.dali.ops.experimental.Erode(*, anchor=[-1, -1], border_mode='constant', bytes_per_sample_hint=[0], iterations=1, mask_size=[3, 3], preserve=False, device=None, name=None)#
对输入图像执行腐蚀操作。
此运算符允许序列输入。
- 支持的后端
‘gpu’
- 关键字参数:
anchor¶ (int 或 list of int 或 TensorList of int, optional, default = [-1, -1]) –
设置结构元素的锚点。默认值 (-1, -1) 使用元素的中心作为锚点。
支持
per-frame输入。border_mode¶ (str, optional, default = ‘constant’) – 访问输入图像外部的元素时要使用的边界模式。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
iterations¶ (int, optional, default = 1) – 执行操作的次数，通常设置为 1。设置为大于 1 的值相当于每次额外迭代将掩码大小增加 (mask_width - 1, mask_height -1)。
mask_size¶ (int 或 list of int 或 TensorList of int, optional, default = [3, 3]) –
结构元素的大小。
支持
per-frame输入。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。（可选参数，默认值为 False）
- class nvidia.dali.ops.experimental.Filter(*, anchor=[-1], border='reflect_101', bytes_per_sample_hint=[0], dtype=None, mode='same', preserve=False, device=None, name=None)#
使用提供的滤波器对图像进行卷积。
注意
实际上，该运算符计算的是相关性，而不是卷积，即在计算滤波器和图像的乘积时，滤波器元素的顺序不会翻转。
此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
anchor¶ (int 或 list of int 或 TensorList of int, optional, default = [-1]) –
指定滤波器在输入上的位置。
如果滤波器大小为
(r, s)，锚点为(a, b)，则位置(x, y)的输出是滤波器与输入矩形的乘积，矩形角点为：左上角(x - a, y - b)和右下角(x - a + r - 1, x - b + s - 1)。如果指定 -1（默认值），则使用滤波器范围的中间值（向下舍入为整数），对于奇数大小的滤波器，这将使滤波器在输入上居中。
锚点必须是，取决于输入维度，一个 2D 或 3D 点，其每个维度都位于滤波器边界内 (
[0, ..., filter_extent - 1])。锚点维度的顺序对应于滤波器维度的顺序。在
"valid"模式下，此参数将被忽略。支持
per-frame输入。border¶ (str, optional, default = ‘reflect_101’) –
控制如何处理样本上超出边界的滤波器位置。
支持的值为：
"reflect_101","reflect_1001","wrap","clamp","constant"。"reflect_101"(默认值), 反射输入，但不重复最外层的值 (dcb|abcdefghi|hgf)。"reflect_1001": 反射输入，包括最外层的值 (cba|abcdefghi|ihg)"wrap": 环绕输入 (ghi|abcdefghi|abc)。"clamp": 输入用最外层的值填充 (aaa|abcdefghi|iii)。"constant": 输入用用户提供的标量（默认为零）填充。在样本内。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。输出类型可以是浮点型，也可以与输入类型相同。如果未设置，则使用输入类型。
注意
用于实际计算的中间类型为 float32。如果输出是整数类型，则值将被钳制到输出类型范围。
mode¶ (str, optional, default = ‘same’) –
支持的值为：
"same"和"valid"。"same"(默认值): 输入和输出大小相同，并且border用于处理超出边界的滤波器位置。"valid": 输出样本被裁剪（裁剪量为filter_extent - 1），以便所有滤波器位置都完全位于输入样本内。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。（可选参数，默认值为 False）
- __call__(__data, __filter, __fill_value=None, /, *, anchor=[-1], border='reflect_101', bytes_per_sample_hint=[0], dtype=None, mode='same', preserve=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__data¶ (TensorList) –
批量输入样本。
样本可以是图像、视频或体积 (3D) 数据。样本可以包含通道：支持通道优先和通道最后的布局。对于视频/序列，帧维度必须在通道维度之前，例如，支持
"FCHW"布局的视频，但不支持"CFHW"样本。支持以下类型的样本：int8、int16、uint8、uint16、float16、float32。
请注意，计算中使用的中间类型始终为 float32。
注意
CPU 版本不支持体积 (3D) 数据，也不支持 int8 和 float16 类型的输入。
__filter¶ (TensorList) –
滤波器批次。
对于具有两个空间维度（图像或视频）的输入，每个滤波器必须是 2D 数组（或要
per-frame应用于视频输入的 2D 数组序列）。对于体积输入，滤波器必须是 3D 数组。滤波器值必须为 float32 类型。__fill_value¶ (TensorList, optional) –
用于填充的标量批次。
如果
"border"设置为"constant"，则当输入样本与滤波器卷积时，将使用相应的标量进行填充。标量必须与输入样本类型相同。对于视频/序列输入，可以指定一个标量数组以per-frame应用。
- class nvidia.dali.ops.experimental.Inflate(*, algorithm='LZ4', bytes_per_sample_hint=[0], chunk_offsets=None, chunk_sizes=None, dtype=DALIDataType.UINT8, layout='', preserve=False, sequence_axis_name='F', shape=None, device=None, name=None)#
使用指定的解压缩算法解压缩输入。
输入必须是字节 (uint8) 的 1D 张量。需要传递解压缩样本的
shape和dtype。每个输入样本可以是单个压缩块，也可以由多个压缩块组成，这些压缩块在解压缩时具有相同的形状和类型，因此可以将它们合并到单个张量中，其中张量的最外层维度对应于块的数量。
如果样本由多个块组成，则必须指定
chunk_offsets或chunk_sizes。在这种情况下，shape必须描述单个解压缩（输出）块的形状。块的数量将自动作为最外层维度添加到输出张量中。例如，以下代码片段展示了类似视频序列的解压缩。每个视频序列都通过以下方式进行解压缩：首先，单独压缩每一帧，然后连接来自相应序列的压缩帧。
@pipeline_def def inflate_sequence_pipeline(): compres_seq, uncompres_hwc_shape, compres_chunk_sizes = fn.external_source(...) sequences = fn.experimental.inflate( compres_seq.gpu(), chunk_sizes=compres_chunk_sizes, # refers to sizes in ``compres_seq`` shape=uncompres_hwc_shape, layout="HWC", sequence_axis_name="F") return sequences
- 支持的后端
‘gpu’
- 关键字参数:
algorithm¶ (str, optional, default = ‘LZ4’) –
用于解码数据的算法。
目前仅支持
LZ4。bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
chunk_offsets¶ (int or list of int or TensorList of int, optional) –
输入样本内偏移量的列表，描述连续块的起始位置。
如果未指定
chunk_sizes，则假定块在输入张量中密集打包，并且最后一个块以样本的结尾结束。chunk_sizes¶ (int or list of int or TensorList of int, optional) –
相应输入块的大小列表。
如果未指定
chunk_offsets，则假定块在输入张量中密集打包，并且第一个块从样本的开头开始。dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.UINT8) – 输出（解压缩）数据类型。layout¶ (layout str, optional, default = ‘’) –
输出（解压缩）块的布局。
如果样本由多个块组成，则
sequence_axis_name维度将添加到指定布局的开头。preserve¶ (bool, optional, default = False) – 即使其输出未使用，也防止运算符从图中移除。
sequence_axis_name¶ (layout str, optional, default = ‘F’) –
序列轴的名称。
如果样本由多个块组成，则额外的外部维度将添加到输出张量。默认情况下，假定为视频帧，因此默认标签为 ‘F’。
如果未指定
layout或输入不是序列（既未指定chunk_offsets也未指定chunk_sizes），则该值将被忽略。shape¶ (int or list of int or TensorList of int) – 输出（解压缩）块的形状。
- class nvidia.dali.ops.experimental.MedianBlur(*, bytes_per_sample_hint=[0], preserve=False, window_size=[3, 3], device=None, name=None)#
中值模糊通过将每个像素替换为周围矩形区域的中值颜色来平滑图像或图像序列。
- 支持的后端
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, optional, default = False) – 即使其输出未使用，也防止运算符从图中移除。
window_size¶ (int or list of int or TensorList of int, optional, default = [3, 3]) – 执行平滑的窗口大小
- class nvidia.dali.ops.experimental.PeekImageShape(*, adjust_orientation=True, bytes_per_sample_hint=[0], dtype=DALIDataType.INT64, image_type=DALIImageType.RGB, preserve=False, device=None, name=None)#
获取已编码图像的形状。
此运算符返回图像在解码后将具有的形状。
注意
不建议将此运算符与动态执行器（管道构造函数中的 exec_dynamic=True）一起使用。请改为在解码后的图像上使用
nvidia.dali.pipeline.DataNode.shape()。- 支持的后端
‘cpu’
- 关键字参数:
adjust_orientation¶ (bool, optional, default = True) – 在计算形状时使用 EXIF 方向元数据。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.INT64) – 数据类型，尺寸将转换为此类型。image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 图像的颜色格式。preserve¶ (bool, optional, default = False) – 即使其输出未使用，也防止运算符从图中移除。
- class nvidia.dali.ops.experimental.Remap(*, bytes_per_sample_hint=[0], interp=DALIInterpType.INTERP_LINEAR, pixel_origin='corner', preserve=False, device=None, name=None)#
Remap 操作将通用的几何变换应用于图像。换句话说，它从输入图像中的一个位置获取像素，并将它们放置在输出图像中的另一个位置。变换由
mapx和mapy参数描述，其中output(x,y) = input(mapx(x,y),mapy(x,y))
输出张量的类型将与输入张量的类型匹配。
仅处理 HWC 布局。
目前不支持选择边框策略。
DALIBorderType将始终为CONSTANT，值为0。此运算符允许序列输入。
- 支持的后端
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
interp¶ (
nvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 插值类型。pixel_origin¶ (str, optional, default = ‘corner’) –
像素原点。可能的值：
"corner","center"。定义像素的哪个部分（左上角或中心）被解释为其原点。此值会影响插值结果。要匹配 OpenCV，请选择
"center"。preserve¶ (bool, optional, default = False) – 即使其输出未使用，也防止运算符从图中移除。
- __call__(__input, __mapx, __mapy, /, *, bytes_per_sample_hint=[0], interp=DALIInterpType.INTERP_LINEAR, pixel_origin='corner', preserve=False, device=None, name=None)#
算子调用，用于图定义中。
- class nvidia.dali.ops.experimental.Resize(*, antialias=True, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, save_attrs=False, size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
调整图像大小。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘gpu’
- 关键字参数:
antialias¶ (bool, optional, default = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
必须与输入类型或
float相同。 如果未设置，则使用输入类型。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 不再使用，将在未来版本中删除。
interp_type¶ (
nvidia.dali.types.DALIInterpTypeor TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter为缩小和放大指定不同的滤波。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
启用抗锯齿的 INTERP_LINEAR。
mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。max_size¶ (float 或 float 列表, 可选) –
输出尺寸的限制。
当算子配置为保持宽高比且仅指定较小尺寸时，另一维度（或多个维度）可能会变得非常大。当使用
resize_shorter参数或 “not_smaller” 模式，或者当某些范围未指定时，可能会发生这种情况。此参数限制了输出可以变得多大。此值可以按轴指定，也可以对所有轴统一指定。
注意
当与 “not_smaller” 模式或
resize_shorter参数一起使用时，max_size优先，并且保持宽高比 - 例如，使用mode="not_smaller", size=800, max_size=1400调整大小，尺寸为 1200x600 的图像将被调整为 1400x700。min_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, 可选, 默认值 = 32) – 内核调用中处理的最大图像数量。
mode¶ (str, 可选, 默认值 = ‘default’) –
调整大小模式。
以下是支持模式的列表
"default"- 图像被调整为指定大小。缺失的尺寸范围将使用提供的尺寸范围的平均比例进行缩放。"stretch"- 图像被调整为指定大小。缺失的尺寸范围根本不进行缩放。"not_larger"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不超过指定大小。例如，对于 1280x720 的图像，期望的输出大小为 640x480，实际会生成 640x360 的输出。"not_smaller"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不小于指定大小。例如，对于 640x480 的图像，期望的输出大小为 1920x1080，实际会生成 1920x1440 的输出。此参数与
resize_longer和resize_shorter互斥。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未使用，也阻止从图中删除该算子。
resize_longer¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像较长尺寸的长度。
此选项与
resize_shorter和显式 size 参数互斥，并且算子保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_larger"。resize_shorter¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像较短尺寸的长度。
此选项与
resize_longer和显式 size 参数互斥，并且算子保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_smaller"。可以通过设置max_size参数来限制较长维度。有关更多信息，请参见max_size参数文档。resize_x¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像 X 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_y未指定或为 0，则算子保持原始图像的宽高比。负值会翻转图像。resize_y¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后图像 Y 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_x未指定或为 0，则算子保持原始图像的宽高比。负值会翻转图像。resize_z¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) –
调整大小后体积 Z 维度的长度。
此选项与
resize_shorter,resize_longer和size互斥。如果resize_x和resize_y未指定或为 0，则算子将保持原始体积的宽高比。负值会翻转体积。roi_end¶ (float 或 float 列表或 float 的 TensorList, 可选) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果任何维度中的 ROI 原点大于 ROI 终点，则该区域在该维度中翻转。roi_relative¶ (bool, 可选, 默认值 = False) – 如果为 true，则 ROI 坐标相对于输入大小，其中 0 表示顶部/左侧，1 表示底部/右侧
roi_start¶ (float 或 float 列表或 float 的 TensorList, 可选) –
输入感兴趣区域 (ROI) 的原点。
必须与
roi_end一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果任何维度中的 ROI 原点大于 ROI 终点，则该区域在该维度中翻转。save_attrs¶ (bool, 可选, 默认值 = False) – 保存重塑属性以进行测试。
size¶ (float 或 float 列表或 float 的 TensorList, 可选) –
期望的输出大小。
必须是列表/元组，每个空间维度一个条目，不包括视频帧和通道。维度范围为 0 的维度被视为不存在，输出大小将根据其他范围和
mode参数计算。subpixel_scale¶ (bool, 可选, 默认值 = True) –
如果为 True，则直接指定或计算的分数大小将导致调整输入 ROI 以保持缩放因子。
否则，将调整缩放因子，以便源图像映射到舍入后的输出大小。
temp_buffer_hint¶ (int, 可选, 默认值 = 0) –
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
- __call__(__input, /, *, antialias=True, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', preserve=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, save_attrs=False, size=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList ('HWC', 'FHWC', 'CHW', 'FCHW', 'CFHW', 'DHWC', 'FDHWC', 'CDHW', 'FCDHW', 'CFDHW')) – 算子的输入。
- class nvidia.dali.ops.experimental.TensorResize(*, alignment=[0.5], antialias=True, axes=None, axis_names=None, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', preserve=False, roi_end=None, roi_relative=False, roi_start=None, scales=None, size_rounding='round', sizes=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
调整张量大小。
此算子允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
alignment¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = [0.5]) –
确定使用比例（提供或计算）时 ROI 的位置。
实际输出大小必须是整数，并且可能与通过输入（或 ROI）大小乘以比例因子计算出的“理想”输出大小不同。在这种情况下，输出大小将被四舍五入（根据
size_rounding策略），并且需要调整输入 ROI 以保持比例因子。此参数定义了 ROI 的哪个相对点应在输出中保持其位置。此点计算为
center = (1 - alignment) * roi_start + alignment * roi_end。对齐方式 0.0 表示与 ROI 的起始位置对齐，0.5 表示与区域中心对齐，1.0 表示与末尾对齐。请注意，当未指定 ROI 时，假定 roi_start=0 和 roi_end=input_size。当使用 0.5（默认值）时，调整大小操作具有翻转不变性属性（调整大小后翻转在数学上等效于翻转后调整大小）。
此参数的值包含与为 sizes/scales 提供的维度一样多的元素。如果仅提供一个值，则将其应用于所有维度。
antialias¶ (bool, 可选, 默认值 = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
axes¶ (int 或 int 列表, 可选) –
sizes,scales,max_size,roi_start,roi_end引用的维度索引。接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
默认情况下，假定所有维度。
axis_names和axes参数互斥。sizes,scales,max_size,roi_start,roi_end引用的轴名称。默认情况下，假定所有维度。
axis_names和axes参数互斥。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
必须与输入类型或
float相同。 如果未设置，则使用输入类型。interp_type¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来为缩小和放大指定不同的滤波。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。max_size¶ (float 或 float 列表, 可选) –
输出尺寸的限制。
当算子配置为保持宽高比且仅指定较小尺寸时，另一维度（或多个维度）可能会变得非常大。当使用 resize_shorter 参数或 “not_smaller” 模式，或者当某些范围未指定时，可能会发生这种情况。
此参数限制了输出可以变得多大。此值可以按轴指定，也可以对所有轴统一指定。
注意
当与 “not_smaller” 模式或 resize_shorter 参数一起使用时，
max_size优先，并且保持宽高比 - 例如，使用mode="not_smaller", size=800, max_size=1400调整大小，尺寸为 1200x600 的图像将被调整为 1400x700。min_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的 TensorList, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, optional, default = 32) – Kernel 调用中处理的最大图像数量。
mode¶ (str, optional, default = ‘default’) – 模式。
调整大小模式。
以下是支持模式的列表
"default"- 图像被调整为指定大小。缺失的尺寸范围将使用提供的尺寸范围的平均比例进行缩放。"stretch"- 图像被调整为指定大小。缺失的尺寸范围根本不进行缩放。"not_larger"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不超过指定大小。例如，对于 1280x720 的图像，期望的输出大小为 640x480，实际会生成 640x360 的输出。"not_smaller"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不小于指定大小。例如，对于 640x480 的图像，期望的输出大小为 1920x1080，实际会生成 1920x1440 的输出。此参数与 resize_longer 和 resize_shorter 互斥。
preserve¶ (bool, optional, default = False) – 即使算子的输出未被使用，也阻止其从图中移除。
roi_end¶ (float 或 float 列表或 float 的 TensorList，可选) – 感兴趣区域结束坐标。
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，与 size 相同。坐标可以是绝对坐标（像素，默认）或相对坐标（0..1），具体取决于relative_roi参数的值。如果任何维度中 ROI 起点大于 ROI 终点，则该区域在该维度上会翻转。roi_relative¶ (bool, optional, default = False) – 如果为 true，则 ROI 坐标相对于输入尺寸，其中 0 表示顶部/左侧，1 表示底部/右侧。
roi_start¶ (float 或 float 列表或 float 的 TensorList，可选) – 感兴趣区域起始坐标。
输入感兴趣区域 (ROI) 的原点。
必须与
roi_end一起指定。坐标遵循张量形状顺序，与 size 相同。坐标可以是绝对坐标（像素，默认）或相对坐标（0..1），具体取决于relative_roi参数的值。如果任何维度中 ROI 起点大于 ROI 终点，则该区域在该维度上会翻转。scales¶ (float 或 float 列表或 float 的 TensorList，可选) – 缩放因子。
缩放因子。
结果输出尺寸计算为
out_size = size_rounding(scale_factor * original_size)。 有关支持的舍入策略列表，请参阅size_rounding。size_rounding¶ (str, optional, default = ‘round’) – 尺寸舍入策略。
确定使用缩放因子时的舍入策略。
可能的值为：* |
"round"- 将结果尺寸四舍五入到最接近的整数值，中间值远离零舍入。 * |"truncate"- 丢弃结果尺寸的小数部分。 * |"ceil"- 将结果尺寸向上舍入到下一个整数值。sizes¶ (float 或 float 列表或 float 的 TensorList，可选) – 输出尺寸。
输出尺寸。
subpixel_scale¶ (bool, optional, default = True) – 亚像素缩放。
如果为 True，则直接指定或计算的分数大小将导致调整输入 ROI 以保持缩放因子。
否则，将调整缩放因子，以便源图像映射到舍入后的输出大小。
temp_buffer_hint¶ (int, optional, default = 0) – 临时缓冲区提示大小。
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
- __call__(__input, /, *, alignment=[0.5], antialias=True, axes=None, axis_names=None, bytes_per_sample_hint=[0], dtype=None, interp_type=DALIInterpType.INTERP_LINEAR, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', preserve=False, roi_end=None, roi_relative=False, roi_start=None, scales=None, size_rounding='round', sizes=None, subpixel_scale=True, temp_buffer_hint=0, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 算子的输入。
- class nvidia.dali.ops.experimental.WarpPerspective(*, border_mode='constant', bytes_per_sample_hint=[0], fill_value=[], interp_type=DALIInterpType.INTERP_LINEAR, inverse_map=True, matrix=[], pixel_origin='corner', preserve=False, size=[], device=None, name=None)#
对图像执行透视变换。
- 支持的后端
‘gpu’
- 关键字参数:
border_mode¶ (str, optional, default = ‘constant’) – 访问输入图像外部元素时使用的边界模式。支持的值为：“constant”、“replicate”、“reflect”、“reflect_101”、“wrap”。
bytes_per_sample_hint¶ (int 或 int 列表，可选, default = [0]) – 每样本字节数提示。
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
fill_value¶ (float 或 float 列表，可选, default = []) – 当选择 “constant” 边界模式时，用于填充源图像外部区域的值。
interp_type¶ (
nvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 插值类型。inverse_map¶ (bool, optional, default = True) – 如果设置为 true（默认），则矩阵被解释为目标坐标到源坐标的映射。否则，它被解释为源坐标到目标坐标的映射。
matrix¶ (float 或 float 列表或 float 的 TensorList，可选, default = []) – 透视变换矩阵，用于将目标坐标映射到源坐标。
- 透视变换矩阵，用于将目标坐标映射到源坐标。
如果
inverse_map参数设置为 false，则该矩阵被解释为从源坐标到目标坐标的映射。
它等效于 OpenCV 的
warpPerspective操作，其中inverse_map参数类似于WARP_INVERSE_MAP标志。注意
除了此参数，运算符还可以接受第二个位置输入，在这种情况下，矩阵可以放置在 GPU 上。
支持
per-frame输入。pixel_origin¶ (str, optional, default = ‘corner’) – 像素原点。
像素原点。可能的值：“corner”、“center”。
确定 (0, 0) 坐标的含义 - “corner” 将原点放置在左上角像素的左上角（如 OpenGL 中）；“center” 将 (0, 0) 放置在左上角像素的中心（如 OpenCV 中）。
preserve¶ (bool, optional, default = False) – 即使算子的输出未被使用，也阻止其从图中移除。
size¶ (float 或 float 列表或 float 的 TensorList，optional, default = []) – 输出尺寸。
输出大小，以像素/点为单位。
通道维度应排除在外（例如，对于 RGB 图像，指定
(480,640)，而不是(480,640,3)）。
- __call__(__input, __matrix_gpu=None, /, *, border_mode='constant', bytes_per_sample_hint=[0], fill_value=[], interp_type=DALIInterpType.INTERP_LINEAR, inverse_map=True, matrix=[], pixel_origin='corner', preserve=False, size=[], device=None, name=None)#
算子调用，用于图定义中。
nvidia.dali.ops.experimental.decoders#
- class nvidia.dali.ops.experimental.decoders.Image(*, adjust_orientation=True, affine=True, bytes_per_sample_hint=[0], cache_batch_copy=True, cache_debug=False, cache_size=0, cache_threshold=0, cache_type='', device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, use_fast_idct=False, device=None, name=None)#
解码图像。
支持的格式：JPEG、JPEG 2000、TIFF、PNG、BMP、PNM、PPM、PGM、PBM、WebP。
解码器的输出采用 HWC 布局。
该实现使用 NVIDIA nvImageCodec 解码图像。
注意
GPU 加速解码仅适用于部分图像格式（JPEG 和 JPEG2000）。对于其他格式，使用基于 CPU 的解码器。对于 JPEG，当可用时将使用专用硬件解码器。
注意
WebP 解码目前仅支持简单的文件格式（有损和无损压缩）。有关不同 WebP 文件格式的详细信息，请参阅 https://developers.google.com/speed/webp/docs/riff_container
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
adjust_orientation¶ (bool, optional, default = True) – 使用 EXIF 方向元数据来校正图像方向。
affine¶ (bool, optional, default = True) – 是否使用仿射变换。
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 int 列表，可选, default = [0]) – 每样本字节数提示。
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
cache_batch_copy¶ (bool, optional, default = True) – 缓存批次复制。
仅适用于
mixed后端类型。如果设置为 True，则使用批量复制内核调用复制缓存中的多个图像。否则，除非批次中的顺序与缓存中的顺序相同，否则每个图像都使用
cudaMemcpy复制。cache_debug¶ (bool, optional, default = False) – 缓存调试模式。
仅适用于
mixed后端类型。打印关于解码器缓存的调试信息。
cache_size¶ (int, optional, default = 0) – 解码器缓存的总大小（以 MB 为单位）。
仅适用于
mixed后端类型。解码器缓存的总大小（以 MB 为单位）。如果提供，则解码后尺寸大于
cache_threshold的图像将被缓存在 GPU 内存中。cache_threshold¶ (int, optional, default = 0) – 缓存阈值。
仅适用于
mixed后端类型。要缓存的解码图像的大小阈值（以字节为单位）。当图像被缓存时，在运算符输入处再次遇到它时，不再需要解码，从而节省处理时间。
cache_type¶ (str, optional, default = ‘’) – 缓存类型。
仅适用于
mixed后端类型。以下是可用缓存类型的列表
threshold：缓存每个尺寸大于cache_threshold的图像，直到缓存大小达到上限。缓存已满。阈值策略的预热时间为 1 个 epoch。
largest: 存储可以放入缓存的最大图像。最大策略的预热时间为 2 个 epoch注意
为了利用缓存，建议将读取器配置为 stick_to_shard=True，以限制多节点环境中每个解码器实例看到的唯一图像数量。
device_memory_padding¶ (int, optional, default = 16777216) – 设备内存填充大小。
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配一个请求大小的设备缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
device_memory_padding_jpeg2k¶ (int, optional, default = 0) – JPEG2K 设备内存填充大小。
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.UINT8) – 输出图像的数据类型。输出图像的数据类型。
值将转换为请求类型的动态范围。
host_memory_padding¶ (int, optional, default = 8388608) – 主机内存填充大小。
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配两个（由于双缓冲）请求大小的主机 pinned 缓冲区。如果选择正确，则在 pipeline 执行期间不会发生额外的分配。
host_memory_padding_jpeg2k¶ (int, optional, default = 0) – JPEG2K 主机内存填充大小。
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
hw_decoder_load¶ (float, optional, default = 0.9) – 硬件解码器负载。
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, optional, default = 1000000) – 混合霍夫曼解码阈值。
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) – JPEG 精细上采样。
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ – 内存统计信息。
- output_type
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB 输出类型。 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, optional, default = 0 预分配高度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preallocate_width_hintint, optional, default = 0 预分配宽度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preservebool, optional, default = False 保留算子。
防止运算符从图中移除，即使其输出未被使用。
split_stages : bool, 可选, 默认值 = False
警告
参数 split_stages 现已弃用，不建议使用。
use_chunk_allocator : bool, 可选, 默认值 = False
警告
参数 use_chunk_allocator 现已弃用，不建议使用。
- use_fast_idctbool, 可选, 默认值 = False
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 时，或者当它设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__input, /, *, adjust_orientation=True, affine=True, bytes_per_sample_hint=[0], cache_batch_copy=True, cache_debug=False, cache_size=0, cache_threshold=0, cache_type='', device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.experimental.decoders.ImageCrop(*, adjust_orientation=True, affine=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rounding='round', use_fast_idct=False, device=None, name=None)#
解码图像并提取由固定窗口尺寸和可变锚点指定的感兴趣区域 (ROI)。
支持的格式：JPEG、JPEG 2000、TIFF、PNG、BMP、PNM、PPM、PGM、PBM、WebP。
解码器的输出采用 HWC 布局。
该实现使用 NVIDIA nvImageCodec 解码图像。
在可能的情况下，该运算符使用 ROI 解码，从而减少解码时间和内存消耗。
注意
GPU 加速解码仅适用于部分图像格式（JPEG 和 JPEG2000）。对于其他格式，使用基于 CPU 的解码器。对于 JPEG，当可用时将使用专用硬件解码器。
注意
WebP 解码目前仅支持简单的文件格式（有损和无损压缩）。有关不同 WebP 文件格式的详细信息，请参阅 https://developers.google.com/speed/webp/docs/riff_container
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
adjust_orientation¶ (bool, 可选, 默认值 = True) – 使用 EXIF 方向元数据来校正图像
affine¶ (bool, 可选, 默认值 = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
crop¶ (float 或 float 列表 或 TensorList of float, 可选) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w,crop_h, 和crop_d必须一起指定。为crop_w,crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，crop_W是裁剪窗口的宽度。有关
crop_x如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_y¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
裁剪窗口起始位置（通常为左上角）的归一化 (0.0 - 1.0) 垂直位置。
实际位置计算为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，crop_H是裁剪窗口的高度。有关
crop_y如何转换为整数值的更多详细信息，请参阅rounding参数。crop_pos_z¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
仅适用于体积输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，crop_D是裁剪窗口的深度。有关
crop_z如何转换为整数值的更多详细信息，请参阅rounding参数。crop_w¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
裁剪窗口宽度（以像素为单位）。
device_memory_padding¶ (int, 可选, 默认值 = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配一个请求大小的设备缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
device_memory_padding_jpeg2k¶ (int, 可选, 默认值 = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.UINT8) –输出图像的数据类型。
值将转换为请求类型的动态范围。
host_memory_padding¶ (int, 可选, 默认值 = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配两个（由于双缓冲）请求大小的主机 pinned 缓冲区。如果选择正确，则在 pipeline 执行期间不会发生额外的分配。
host_memory_padding_jpeg2k¶ (int, 可选, 默认值 = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
hw_decoder_load¶ (float, 可选, 默认值 = 0.9) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, 可选, 默认值 = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, 可选, 默认值 = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ –
- output_type
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB 输出类型。 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, optional, default = 0 预分配高度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preallocate_width_hintint, optional, default = 0 预分配宽度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preservebool, optional, default = False 保留算子。
防止运算符从图中移除，即使其输出未被使用。
- roundingstr, 可选, 默认值 = ‘round’
确定用于将窗口的起始坐标转换为整数值的舍入函数（请参阅
crop_pos_x,crop_pos_y,crop_pos_z）。可能的值为
"round"- 四舍五入到最接近的整数值，中间值四舍五入到远离零的值。"truncate"- 丢弃数字的小数部分（向零截断）。
split_stages : bool, 可选, 默认值 = False
警告
参数 split_stages 现已弃用，不建议使用。
use_chunk_allocator : bool, 可选, 默认值 = False
警告
参数 use_chunk_allocator 现已弃用，不建议使用。
- use_fast_idctbool, 可选, 默认值 = False
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 时，或者当它设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__input, /, *, adjust_orientation=True, affine=True, bytes_per_sample_hint=[0], crop=None, crop_d=0.0, crop_h=0.0, crop_pos_x=0.5, crop_pos_y=0.5, crop_pos_z=0.5, crop_w=0.0, device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rounding='round', use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.experimental.decoders.ImageRandomCrop(*, adjust_orientation=True, affine=True, bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, num_attempts=10, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, use_fast_idct=False, device=None, name=None)#
解码图像并随机裁剪它们。
支持的格式：JPEG、JPEG 2000、TIFF、PNG、BMP、PNM、PPM、PGM、PBM、WebP。
解码器的输出采用 HWC 布局。
该实现使用 NVIDIA nvImageCodec 解码图像。
裁剪窗口的面积（相对于整个图像）和纵横比可以分别限制为由
area和 aspect_ratio 参数指定的值范围。在可能的情况下，该运算符使用 ROI 解码，从而减少解码时间和内存消耗。
注意
GPU 加速解码仅适用于部分图像格式（JPEG 和 JPEG2000）。对于其他格式，使用基于 CPU 的解码器。对于 JPEG，当可用时将使用专用硬件解码器。
注意
WebP 解码目前仅支持简单的文件格式（有损和无损压缩）。有关不同 WebP 文件格式的详细信息，请参阅 https://developers.google.com/speed/webp/docs/riff_container
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
adjust_orientation¶ (bool, 可选, 默认值 = True) – 使用 EXIF 方向元数据来校正图像
affine¶ (bool, 可选, 默认值 = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
device_memory_padding¶ (int, 可选, 默认值 = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配一个请求大小的设备缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
device_memory_padding_jpeg2k¶ (int, 可选, 默认值 = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.UINT8) –输出图像的数据类型。
值将转换为请求类型的动态范围。
host_memory_padding¶ (int, 可选, 默认值 = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配两个（由于双缓冲）请求大小的主机 pinned 缓冲区。如果选择正确，则在 pipeline 执行期间不会发生额外的分配。
host_memory_padding_jpeg2k¶ (int, 可选, 默认值 = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
hw_decoder_load¶ (float, 可选, 默认值 = 0.9) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, 可选, 默认值 = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, 可选, 默认值 = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ –
- num_attemptsint, 可选, 默认值 = 10
用于选择随机区域和宽高比的最大尝试次数。
- output_type
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB 输出类型。 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, optional, default = 0 预分配高度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preallocate_width_hintint, optional, default = 0 预分配宽度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preservebool, optional, default = False 保留算子。
防止运算符从图中移除，即使其输出未被使用。
- random_areafloat 或 float 列表, 可选, 默认值 = [0.08, 1.0]
从中选择随机面积分数
A的范围。裁剪图像的面积将等于
A* 原始图像的面积。- random_aspect_ratiofloat 或 float 列表, 可选, 默认值 = [0.75, 1.333333]
从中选择随机宽高比（宽度/高度）的范围。
- seedint, 可选, 默认值 = -1
随机种子；如果未设置，将自动分配一个。
split_stages : bool, 可选, 默认值 = False
警告
参数 split_stages 现已弃用，不建议使用。
use_chunk_allocator : bool, 可选, 默认值 = False
警告
参数 use_chunk_allocator 现已弃用，不建议使用。
- use_fast_idctbool, 可选, 默认值 = False
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 时，或者当它设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__input, /, *, adjust_orientation=True, affine=True, bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, num_attempts=10, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, random_area=[0.08, 1.0], random_aspect_ratio=[0.75, 1.333333], seed=-1, use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 算子的输入。
- class nvidia.dali.ops.experimental.decoders.ImageSlice(*, adjust_orientation=True, affine=True, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, end=None, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, normalized_anchor=True, normalized_shape=True, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, use_fast_idct=False, device=None, name=None)#
解码图像并提取感兴趣区域。
支持的格式：JPEG、JPEG 2000、TIFF、PNG、BMP、PNM、PPM、PGM、PBM、WebP。
解码器的输出采用 HWC 布局。
该实现使用 NVIDIA nvImageCodec 解码图像。
可以通过提供切片的起始和结束坐标，或起始坐标和形状来指定切片。坐标和形状都可以以绝对或相对方式提供。
切片参数可以通过以下命名参数指定
start: 切片起始坐标（绝对坐标）rel_start: 切片起始坐标（相对坐标）end: 切片结束坐标（绝对坐标）rel_end: 切片结束坐标（相对坐标）shape: 切片形状（绝对坐标）rel_shape: 切片形状（相对坐标）
可以通过提供起始和结束坐标或起始和形状来配置切片。相对和绝对参数可以混合使用（例如，
rel_start可以与shape一起使用），只要起始和形状或结束坐标是唯一确定的。或者，可以提供两个额外的位置输入，分别指定
__anchor和__shape。当使用位置输入时，可以使用两个额外的布尔参数normalized_anchor/normalized_shape来指定所提供参数的性质。使用位置输入作为锚点和形状与上面指定的命名参数不兼容。切片参数应提供与
axis_names或axes参数指定的维度数量相同。默认情况下，
nvidia.dali.fn.decoders.image_slice()运算符对切片参数使用归一化坐标和 “WH” 顺序。在可能的情况下，该运算符使用 ROI 解码，从而减少解码时间和内存消耗。
注意
GPU 加速解码仅适用于部分图像格式（JPEG 和 JPEG2000）。对于其他格式，使用基于 CPU 的解码器。对于 JPEG，当可用时将使用专用硬件解码器。
注意
WebP 解码目前仅支持简单的文件格式（有损和无损压缩）。有关不同 WebP 文件格式的详细信息，请参阅 https://developers.google.com/speed/webp/docs/riff_container
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
adjust_orientation¶ (bool, optional, default = True) – 使用 EXIF 方向元数据来校正图像
affine¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
axes¶ (int 或 list of int 或 TensorList of int, optional, default = [1, 0]) –
用作维度索引的锚点和形状切片输入的维度顺序。
负值被解释为从后往前计数维度。有效范围：
[-ndim, ndim-1]，其中 ndim 是输入数据中的维度数。axis_names¶ (layout str, optional, default = ‘WH’) –
用作锚点和形状切片输入的维度的顺序，如布局中所述。
如果提供了值，
axis_names将比axes具有更高的优先级。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
device_memory_padding¶ (int, optional, default = 16777216) –
仅适用于
mixed后端类型。nvJPEG 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配一个请求大小的设备缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.UINT8) –输出图像的数据类型。
值将转换为请求类型的动态范围。
end¶ (int 或 list of int 或 TensorList of int, optional) –
切片的结束坐标。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子为每个线程预分配两个（由于双缓冲）请求大小的主机 pinned 缓冲区。如果选择正确，则在 pipeline 执行期间不会发生额外的分配。
host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供大于 0 的值，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。
hw_decoder_load¶ (float, optional, default = 0.9) –
要由 HW JPEG 解码器处理的图像数据百分比。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。确定要卸载到硬件解码器（如果可用）的工作负载的百分比。最佳工作负载取决于提供给 DALI 管道的线程数，应通过经验找到。更多详细信息可以在 https://developer.nvidia.com/blog/loading-data-fast-with-dali-and-new-jpeg-decoder-in-a100 中找到
hybrid_huffman_threshold¶ (int, optional, default = 1000000) –
仅适用于
mixed后端类型。像素总数（
height * width）高于此阈值的图像将使用 nvJPEG 混合 Huffman 解码器。像素较少的图像将使用 nvJPEG 主机端 Huffman 解码器。注意
混合 Huffman 解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ –
- normalized_anchorbool, optional, default = True
确定是否应将锚点位置输入解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
注意
此参数仅在锚点数据类型为
float时相关。对于整数类型，坐标始终是绝对坐标。- normalized_shapebool, optional, default = True
确定是否应将形状位置输入解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
注意
此参数仅在锚点数据类型为
float时相关。对于整数类型，坐标始终是绝对坐标。- output_type
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB 输出类型。 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, optional, default = 0 预分配高度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preallocate_width_hintint, optional, default = 0 预分配宽度提示。
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。此提示用于为 HW JPEG 解码器预先分配内存。
- preservebool, optional, default = False 保留算子。
防止运算符从图中移除，即使其输出未被使用。
- rel_endfloat 或 list of float 或 TensorList of float, optional
切片的结束相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。- rel_shapefloat 或 list of float 或 TensorList of float, optional
切片的相对形状（范围 [0.0 - 1.0]）。
提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。- rel_startfloat 或 list of float 或 TensorList of float, optional
切片的起始相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。- shapeint 或 list of int 或 TensorList of int, optional
切片的形状。
提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入锚点和形状不兼容。
split_stages : bool, 可选, 默认值 = False
警告
参数 split_stages 现已弃用，不建议使用。
- startint 或 list of int 或 TensorList of int, optional
切片的起始坐标。
use_chunk_allocator : bool, 可选, 默认值 = False
警告
参数 use_chunk_allocator 现已弃用，不建议使用。
- use_fast_idctbool, 可选, 默认值 = False
在基于 libjpeg-turbo 的 CPU 解码器中启用快速 IDCT，当
device设置为 “cpu” 或设置为 “mixed” 但特定图像无法由 GPU 实现处理时使用。根据 libjpeg-turbo 文档，解压缩性能最多可提高 14%，而质量几乎没有降低。
- __call__(__data, __anchor=None, __shape=None, /, *, adjust_orientation=True, affine=True, axes=[1, 0], axis_names='WH', bytes_per_sample_hint=[0], device_memory_padding=16777216, device_memory_padding_jpeg2k=0, dtype=DALIDataType.UINT8, end=None, host_memory_padding=8388608, host_memory_padding_jpeg2k=0, hw_decoder_load=0.9, hybrid_huffman_threshold=1000000, jpeg_fancy_upsampling=False, normalized_anchor=True, normalized_shape=True, output_type=DALIImageType.RGB, preallocate_height_hint=0, preallocate_width_hint=0, preserve=False, rel_end=None, rel_shape=None, rel_start=None, shape=None, start=None, use_fast_idct=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__data¶ (TensorList) – 包含输入数据的批次。
__anchor¶ (1D TensorList of float or int, optional) –
包含切片起点的归一化或绝对坐标的输入 (x0, x1, x2, …)。
整数坐标被解释为绝对坐标，而浮点坐标可以被解释为绝对坐标或相对坐标，具体取决于
normalized_anchor的值。__shape¶ (1D TensorList of float or int, optional) –
包含切片维度归一化或绝对坐标的输入 (s0, s1, s2, …)。
整数坐标被解释为绝对坐标，而浮点坐标可以被解释为绝对坐标或相对坐标，具体取决于
normalized_shape的值。
- class nvidia.dali.ops.experimental.decoders.Video(*, affine=True, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
从内存缓冲区（例如，由外部源提供）解码视频文件。
- 视频流可以是大多数容器文件格式。FFmpeg 用于解析视频
容器，并返回形状为 (F, H, W, C) 的帧序列批次，其中 F 是序列中帧的数量，并且每个样本可能不同。
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
affine¶ (bool, optional, default = True) –
仅适用于混合后端类型。
- 如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。
否则，线程可以由操作系统重新分配给任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
nvidia.dali.ops.experimental.inputs#
- class nvidia.dali.ops.experimental.inputs.Video(*, affine=True, blocking=False, bytes_per_sample_hint=[0], last_sequence_policy='partial', no_copy=False, preserve=False, sequence_length=None, device=None, name=None)#
从内存缓冲区流式传输和解码视频。适用于长视频和高分辨率视频。
返回帧序列的批次，布局为：
(F, H, W, C)，其中F- 序列中的帧数，H- 帧的高度，W- 帧的宽度，C- 帧中的通道数。
当在 DALI Pipeline 中使用
fn.inputs.video算子时，用户需要使用Pipeline.feed_input()提供数据。当算子被馈送数据时，Pipeline 可以多次运行，并且fn.inputs.video算子将返回连续的序列，只要有足够的数据进行解码。当帧的来源（视频文件）耗尽时，用户需要再次调用feed_input以向算子提供下一个视频文件。此算子具有用于数据的内部队列，因此feed_input可以多次调用，并且当给定的视频文件结束时，算子将自动从队列顶部获取下一个视频文件。在fn.inputs.video没有数据运行时运行 pipeline 会导致错误。此算子仅接受一个视频作为输入（即
input_batch_size=1），并将返回序列批次。每个输出批次都将具有在 Pipeline 创建期间设置的max_batch_size样本。当视频文件中的帧数不允许跨批次均匀分割帧时，此算子为给定视频返回的最后一个批次将是部分批次，并且此批次中的最后一个序列将使用last_sequence_policy参数确定。例如This is a video that consists of 67 frames (every '-' is a frame): ------------------------------------------------------------------- User decided that there shall be 5 frames per sequence and the last_sequence_policy='partial': ------------------------------------------------------------------- [ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][] ------------------------------------------------------------------- Since there are not enough frames, the last sequence comprises 2 frames. The Pipeline has max_batch_size=3, therefore the operator will return 5 batches of sequences. First 4 batches comprise 3 sequences and the last batch is partial and comprises 2 sequences. --------------- --------------- --------------- --------------- ------- [ ][ ][ ] [ ][ ][ ] [ ][ ][ ] [ ][ ][ ] [ ][] --------------- --------------- --------------- --------------- ------- With the last_sequence_policy='pad', the last sequence of the last batch will be padded with 0: --------------- --------------- --------------- --------------- -------000 [ ][ ][ ] [ ][ ][ ] [ ][ ][ ] [ ][ ][ ] [ ][ ] --------------- --------------- --------------- --------------- -------000
fn.inputs.video和fn.readers.video之间的区别在于，前者从内存中读取编码的视频，而后者从磁盘中读取编码的视频。fn.inputs.video和fn.decoders.video之间的区别在于，前者不会一次解码整个视频文件。对于较长的视频，此行为是必需的。例如，5 分钟、4k、30fps 解码视频大约需要 1.7 TB 的内存。此算子接受大多数视频容器和文件格式。FFmpeg 用于解析视频容器。在容器不包含所需的元数据（例如，帧大小、帧数等）的情况下，算子需要自行查找，这可能会导致速度减慢。
- 支持的后端
‘cpu’
‘mixed’
- 关键字参数:
affine¶ (bool, optional, default = True) –
仅适用于混合后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。
否则，线程可以由操作系统重新分配给任何 CPU 核心。
blocking¶ (bool, optional, default = False) – 高级 如果
True，此运算符将阻塞，直到数据可用（例如，通过调用feed_input）。如果False，如果数据不可用，运算符将引发错误。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
last_sequence_policy¶ (str, optional, default = ‘partial’) –
指定如何处理视频文件中的最后一个序列。
对于视频文件中给定的帧数和
frames_per_sequence参数，可能会发生视频无法在序列之间均匀分割的情况。如果last_sequence_policy='partial'，则最后一个序列可能具有少于frames_per_sequence值指定的帧数。如果last_sequence_policy='partial'，则最后一个序列将始终具有frames_per_sequence帧，并将用空帧填充。允许的值为
'partial'和'pad'。no_copy¶ (bool, optional, default = False) –
确定当调用
feed_input时，DALI 是否应复制缓冲区。如果设置为 True，DALI 会将用户的内存直接传递给 pipeline，而不是复制它。用户有责任保持缓冲区处于活动状态且未被修改，直到它被 pipeline 使用。
在相关迭代的输出被使用后，可以再次修改或释放缓冲区。实际上，这发生在
prefetch_queue_depth或cpu_queue_depth * gpu_queue_depth（当它们不相等时）在feed_input调用之后的迭代之后。内存位置必须与运算符的指定
device参数匹配。对于 CPU，提供的内存可以是一个连续的缓冲区或连续的 Tensor 列表。对于 GPU，为避免额外的复制，提供的缓冲区必须是连续的。如果您提供单独的 Tensor 列表，则会在内部进行额外的复制，从而消耗内存和带宽。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
sequence_length¶ (int) – 每个序列中的帧数。
- __call__(*, affine=True, blocking=False, bytes_per_sample_hint=[0], last_sequence_policy='partial', no_copy=False, preserve=False, sequence_length=None, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
nvidia.dali.ops.experimental.readers#
- class nvidia.dali.ops.experimental.readers.Fits(*, bytes_per_sample_hint=[0], dont_use_mmap=False, dtypes=None, file_filter='*.fits', file_list=None, file_root=None, files=None, hdu_indices=[2], initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
从目录读取 Fits 图像 HDU。
此运算符可以在以下模式中使用
读取由
file_root指示的目录中与给定file_filter匹配的所有文件。从
file_list参数中指示的文本文件读取文件名。读取
files参数中列出的文件。
4. 每个样本的输出数对应于
hdu_indices参数的长度。默认情况下，从每个文件中读取第一个带有数据的 HDU，因此输出数默认为 1。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
dtypes¶ (DALIDataType 或 list of DALIDataType, optional) –
各个输出的数据类型。
如果指定，则必须是各个输出的类型列表。默认情况下，所有输出都假定为 UINT8。”
file_filter¶ (str, optional, default = ‘*.fits’) –
如果指定了值，则该字符串被解释为 glob 字符串，以过滤
file_root的子目录中的文件列表。file_list¶ (str, optional) –
文本文件的路径，其中包含文件名（每行一个）。文件名相对于文本文件的位置或
file_root（如果指定）的位置。此参数与
files互斥。file_root¶ (str, optional) –
包含数据文件的目录的路径。
如果不使用
file_list或files。将遍历此目录以发现文件。在这种操作模式下，file_root是必需的。files¶ (str 或 list of str, optional) –
要从中读取数据的文件的文件路径列表。
如果提供了
file_root，则路径被视为相对于它。此参数与
file_list互斥。hdu_indices¶ (int 或 list of int, optional, default = [2]) – 要读取的 HDU 索引。如果未提供，将产生主 HDU 之后的第一个 HDU。由于 HDU 的索引从 1 开始，因此默认值如下：hdu_indices = [2]。提供的列表 hdu_indices 的大小定义了每个样本的输出数。
initial_fill¶ (int, optional, default = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, optional, default = False) – 仅在首次运行时而不是在构造函数中解析和准备数据集元数据。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机 shuffle 数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, optional, default = 0) – 要读取的分片的索引。
shuffle_after_epoch¶ (bool, optional, default = False) –
如果设置为 True，则读取器在每个 epoch 后 shuffle 整个数据集。
当此参数设置为 True 时，不能使用
stick_to_shard和random_shuffle。skip_cached_images¶ (bool, optional, default = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, optional, default = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, optional, default = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], dont_use_mmap=False, dtypes=None, file_filter='*.fits', file_list=None, file_root=None, files=None, hdu_indices=[2], initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.experimental.readers.Video(*, bytes_per_sample_hint=[0], dont_use_mmap=False, enable_frame_num=False, filenames=[], initial_fill=1024, labels=None, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, step=-1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
使用 FFmpeg 加载和解码视频文件。
视频流可以是大多数容器文件格式。FFmpeg 用于解析视频容器，并返回一批
sequence_length帧的序列，形状为(N, F, H, W, C)，其中N是批次大小，F是帧数）。注意
不支持索引的容器（如 MPEG）需要 DALI 构建索引。
DALI 将遍历视频并标记关键帧，以便即使在可变帧率场景中也能有效地查找。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
enable_frame_num¶ (bool, optional, default = False) – 如果设置，则返回解码序列中第一帧的索引作为附加输出。
filenames¶ (str 或 list of str, optional, default = []) – 要加载的视频文件的绝对路径。
initial_fill¶ (int, optional, default = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。labels¶ (int 或 list of int, optional) – 与
filenames参数中列出的文件关联的标签。如果未提供，则不会产生标签。lazy_init¶ (bool, optional, default = False) – 仅在首次运行时而不是在构造函数中解析和准备数据集元数据。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机 shuffle 数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
sequence_length¶ (int) – 每个序列要加载的帧数。
shard_id¶ (int, optional, default = 0) – 要读取的分片的索引。
skip_cached_images¶ (bool, optional, default = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
step¶ (int, optional, default = -1) –
每个序列之间的帧间隔。
当该值小于 0 时，
step将设置为sequence_length。stick_to_shard¶ (bool, 可选, 默认 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
stride¶ (int, 可选, 默认 = 1) – 序列中连续帧之间的距离。
tensor_init_bytes¶ (int, 可选, 默认 = 1048576) – 每个图像分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], dont_use_mmap=False, enable_frame_num=False, filenames=[], initial_fill=1024, labels=None, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, step=-1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
nvidia.dali.ops.io#
此模块中的运算符是数据读取运算符，用于从操作符输入在运行时指定的源读取数据。 对于能够在管道构建时构建数据集的无输入数据读取器，请参阅 nvidia.dali.fn.readers 模块。
nvidia.dali.ops.io.file#
- class nvidia.dali.ops.io.file.Read(*, bytes_per_sample_hint=[0], dont_use_mmap=False, preserve=False, use_o_direct=False, device=None, name=None)#
从由 1D 字节数组表示的编码文件名中读取原始文件内容。
注意
要从 Python 生成兼容的编码文件路径（例如，在 external_source 节点生成器中），请使用 np.frombuffer(filepath_str.encode(“utf-8”), dtype=types.UINT8)。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, 可选, 默认 = False) –
如果设置为 True，它将使用普通文件 I/O 而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但对于大多数网络文件系统，它不提供优势
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中删除，即使其输出未使用。
use_o_direct¶ (bool, 可选, 默认 = False) –
如果设置为 True，数据将直接从存储读取，绕过系统缓存。
与
dont_use_mmap=False互斥。
nvidia.dali.ops.noise#
- class nvidia.dali.ops.noise.Gaussian(*, bytes_per_sample_hint=[0], mean=0.0, preserve=False, seed=-1, stddev=1.0, device=None, name=None)#
将高斯噪声应用于输入。
输出的形状和数据类型将与输入匹配。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
mean¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) – 分布的均值。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中删除，即使其输出未使用。
seed¶ (int, 可选, 默认 = -1) – 随机种子；如果未设置，将自动分配一个。
stddev¶ (float 或 float 的 TensorList, 可选, 默认 = 1.0) – 分布的标准差。
- class nvidia.dali.ops.noise.SaltAndPepper(*, bytes_per_sample_hint=[0], pepper_val=None, per_channel=False, preserve=False, prob=0.05, salt_val=None, salt_vs_pepper=0.5, seed=-1, device=None, name=None)#
将椒盐噪声应用于输入。
输出的形状和数据类型将与输入匹配。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
pepper_val¶ (float 或 float 的 TensorList, 可选) –
“pepper” 的值。
如果未提供，对于浮点类型，pepper 值将为 -1.0，否则为输入数据类型的最小值（转换为输入数据类型）。
per_channel¶ (bool, 可选, 默认 = False) –
确定是否应独立地为每个通道生成噪声。
如果设置为 True，则为每个通道独立生成噪声，从而导致某些通道损坏，而其他通道保持完整。 如果设置为 False，则生成一次噪声并将其应用于所有通道，以便像素中的所有通道都应保持完整、取“pepper”值或“salt”值。
注意：按通道生成噪声需要输入布局包含通道（'C'）维度，或者为空。 如果布局为空，则假定为通道优先布局。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中删除，即使其输出未使用。
prob¶ (float 或 float 的 TensorList, 可选, 默认 = 0.05) – 输出值采用 salt 或 pepper 值的概率。
salt_val¶ (float 或 float 的 TensorList, 可选) –
“salt” 的值。
如果未提供，对于浮点类型，salt 值将为 1.0，否则为输入数据类型的最大值（转换为输入数据类型）。
salt_vs_pepper¶ (float 或 float 的 TensorList, 可选, 默认 = 0.5) – 损坏的输出值采用 salt 值的概率。
seed¶ (int, 可选, 默认 = -1) – 随机种子；如果未设置，将自动分配一个。
- class nvidia.dali.ops.noise.Shot(*, bytes_per_sample_hint=[0], factor=20.0, preserve=False, seed=-1, device=None, name=None)#
将散粒噪声应用于输入。
散粒噪声通过应用以下公式生成
output[:] = poisson_dist(max(0, input[:] / factor)) * factor) if factor != 0 output[:] = input[:] if factor == 0
其中
poisson_dist表示泊松分布。散粒噪声是泊松过程生成的数据中存在的噪声，例如图像传感器注册光子。 此运算符模拟数据采集过程，其中每个事件都将输出值增加
factor，并且输入张量包含相应输出点的期望值。 例如，factor为 0.1 表示需要 10 个事件才能将输出值增加 1，而 factor 为 10 表示单个事件将输出增加 10。 输出值被量化为factor的倍数。 因子越大，输出中存在的噪声就越多。 因子为 0 使其成为恒等运算。输出的形状和数据类型将与输入匹配。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
nvidia.dali.ops.plugin#
nvidia.dali.ops.plugin.video#
注意
此模块属于 nvidia-dali-video 插件，需要作为单独的软件包安装。 有关更多详细信息，请参阅 安装指南。
- class nvidia.dali.ops.plugin.video.Decoder(*, affine=True, bytes_per_sample_hint=[0], end_frame=0, preserve=False, device=None, name=None)#
从内存缓冲区（例如，由外部源提供）解码视频文件。
- 视频流可以是大多数容器文件格式。FFmpeg 用于解析视频
容器，并返回形状为 (F, H, W, C) 的帧序列批次，其中 F 是序列中帧的数量，并且每个样本可能不同。
- 支持的后端
‘mixed’
- 关键字参数:
affine¶ (bool, 可选, 默认 = True) –
仅适用于混合后端类型。
- 如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。
否则，线程可以由操作系统重新分配给任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
end_frame¶ (int, 可选, 默认 = 0) – 要解码的结束帧的索引。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中删除，即使其输出未使用。
nvidia.dali.ops.random#
- class nvidia.dali.ops.random.Beta(*, alpha=1.0, beta=1.0, bytes_per_sample_hint=[0], dtype=None, preserve=False, seed=-1, shape=None, device=None, name=None)#
从
[0, 1]范围生成遵循 beta 分布的随机数。beta 分布具有以下概率分布函数
\[f(x) = \frac{\Gamma(\alpha + \beta)}{\Gamma(\alpha)\Gamma(\beta)} x^{\alpha-1} (1-x)^{\beta-1}\]其中
Г是定义为以下公式的 gamma 函数\[\Gamma(\alpha) = \int_0^\infty x^{\alpha-1} e^{-x} \, dx\]该运算符支持
float32和float64输出类型。生成数据的形状可以通过
shape参数显式指定，或者选择为与提供的__shape_like输入的形状匹配。 如果两者都不存在，则每个样本生成一个值。- 支持的后端
‘cpu’
- 关键字参数:
alpha¶ (float 或 float 的 TensorList, 可选, 默认 = 1.0) – alpha 参数，一个正
float32标量。beta¶ (float 或 float 的 TensorList, 可选, 默认 = 1.0) – beta 参数，一个正
float32标量。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 阻止算子从图中移除，即使其输出未被使用。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表或 int 的 TensorList，可选) – 输出数据的形状。
- class nvidia.dali.ops.random.Choice(*, bytes_per_sample_hint=[0], p=None, preserve=False, seed=-1, shape=None, device=None, name=None)#
从给定的 1D 数组生成随机样本。
从输入中选择样本的概率由
p参数中指定的相应概率决定。生成数据的形状可以通过
shape参数显式指定，也可以选择与__shape_like输入的形状匹配（如果提供）。如果两者都不存在，则每个样本生成单个值。输出的类型与输入的类型匹配。对于标量输入，仅支持整数类型；否则，可以使用任何类型。该算子支持从包含 DALI 枚举类型元素（即
nvidia.dali.types.DALIDataType(),nvidia.dali.types.DALIImageType(), 或nvidia.dali.types.DALIInterpType()）的输入中进行选择。- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
p¶ (float 或 float 列表或 float 的 TensorList，可选) – 概率分布。如果未指定，则假定为均匀分布。
preserve¶ (bool, 可选, 默认值 = False) – 阻止算子从图中移除，即使其输出未被使用。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表或 int 的 TensorList，可选) – 输出数据的形状。
- __call__(__a, __shape_like=None, /, *, bytes_per_sample_hint=[0], p=None, preserve=False, seed=-1, shape=None, device=None, name=None)#
算子调用，用于图定义中。
- class nvidia.dali.ops.random.CoinFlip(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, probability=0.5, seed=-1, shape=None, device=None, name=None)#
生成服从伯努利分布的随机布尔值。
生成值 1 (true) 的概率由
probability参数决定。生成数据的形状可以通过
shape参数显式指定，也可以选择与__shape_like输入的形状匹配（如果提供）。如果两者都不存在，则每个样本生成单个值。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 阻止算子从图中移除，即使其输出未被使用。
probability¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.5) – 值 1 的概率。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表或 int 的 TensorList，可选) – 输出数据的形状。
- class nvidia.dali.ops.random.Normal(*, bytes_per_sample_hint=[0], dtype=None, mean=0.0, preserve=False, seed=-1, shape=None, stddev=1.0, device=None, name=None)#
生成服从正态分布的随机数。
生成数据的形状可以通过
shape参数显式指定，也可以选择与__shape_like输入的形状匹配（如果提供）。如果两者都不存在，则每个样本生成单个值。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
mean¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) – 分布的均值。
preserve¶ (bool, 可选, 默认值 = False) – 阻止算子从图中移除，即使其输出未被使用。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表或 int 的 TensorList，可选) – 输出数据的形状。
stddev¶ (float 或 float 的 TensorList, 可选, 默认值 = 1.0) – 分布的标准差。
- class nvidia.dali.ops.random.Uniform(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, range=[-1.0, 1.0], seed=-1, shape=None, values=None, device=None, name=None)#
生成服从均匀分布的随机数。
它可以配置为生成在
range[min, max) 范围内的连续均匀分布，或离散均匀分布，其中任何指定的values[v0, v1, …, vn] 以相等的概率出现。生成数据的形状可以通过
shape参数显式指定，也可以选择与__shape_like输入的形状匹配（如果提供）。如果两者都不存在，则每个样本生成单个值。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表，可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行四舍五入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 阻止算子从图中移除，即使其输出未被使用。
range¶ (float 或 float 列表或 float 的 TensorList, 可选, 默认值 = [-1.0, 1.0]) –
连续均匀分布的范围
[min, max)。此参数与
values互斥。警告
当指定整数类型作为
dtype时，由于舍入，生成的数字可能会超出指定的范围。seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 列表或 int 的 TensorList，可选) – 输出数据的形状。
values¶ (float 或 float 列表或 float 的 TensorList，可选) –
离散均匀分布产生的离散值 [v0, v1, …, vn]。
此参数与
range互斥。
nvidia.dali.ops.readers#
此模块中的算子是数据生成算子，它们从存储或不同的源读取数据，并且数据位置在通过参数构建管道时已知。 对于能够从通过常规输入动态指定的源读取数据的读取器，请参阅 nvidia.dali.fn.io 模块。
- class nvidia.dali.ops.readers.COCO(*, annotations_file='', avoid_class_remapping=False, bytes_per_sample_hint=[0], dont_use_mmap=False, file_root=None, image_ids=False, images=None, include_iscrowd=True, initial_fill=1024, lazy_init=False, ltrb=False, num_shards=1, pad_last_batch=False, pixelwise_masks=False, polygon_masks=False, prefetch_queue_depth=1, preprocessed_annotations='', preserve=False, random_shuffle=False, ratio=False, read_ahead=False, save_preprocessed_annotations=False, save_preprocessed_annotations_dir='', seed=-1, shard_id=0, shuffle_after_epoch=False, size_threshold=0.1, skip_cached_images=False, skip_empty=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
从 COCO 数据集中读取数据，该数据集由包含图像和注释 JSON 文件的目录组成。
此读取器生成以下输出
images, bounding_boxes, labels, ((polygons, vertices) | (pixelwise_masks)), (image_ids)
images（图像） 每个样本包含图像数据，布局为
HWC（高度、宽度、通道数）。bounding_boxes（边界框） 每个样本可以有任意数量
M的边界框，每个边界框由 4 个坐标描述[[x_0, y_0, w_0, h_0], [x_1, y_1, w_1, h_1] ... [x_M, y_M, w_M, h_M]]
或者，如果需要，可以使用
[l, t, r, b]格式（请参阅ltrb参数）。labels（标签） 每个边界框都与一个整数标签关联，表示类别标识符
[label_0, label_1, ..., label_M]
polygons（多边形） 和 vertices（顶点） （可选，如果
polygon_masks设置为 True 时存在） 如果polygon_masks启用，则会输出两个额外的输出，用于通过一组多边形描述掩码。每个掩码包含任意数量P的多边形，每个多边形与范围 [0, M) 内的掩码索引相关联，并由一组V个顶点组成。输出polygons描述多边形如下[[mask_idx_0, start_vertex_idx_0, end_vertex_idx_0], [mask_idx_1, start_vertex_idx_1, end_vertex_idx_1], ... [mask_idx_P, start_vertex_idx_P, end_vertex_idx_P]]
其中
mask_idx是多边形所属掩码的索引，范围为[0, M)，start_vertex_idx和end_vertex_idx定义了顶点索引的范围，这些顶点索引出现在输出vertices中，属于此多边形。vertices中的每个样本都包含组成样本中不同多边形的顶点列表，表示为 2D 坐标[[x_0, y_0], [x_1, y_1], ... [x_V, y_V]]
pixelwise_masks（像素级掩码） （可选，如果参数
pixelwise_masks设置为 True 时存在） 包含类似图像的数据，形状和布局与images相同，表示像素级分割掩码。image_ids（图像 ID） （可选，如果参数
image_ids设置为 True 时存在） 每个样本一个元素，表示图像标识符。
- 支持的后端
‘cpu’
- 关键字参数:
annotations_file（注释文件）¶ (str, 可选, 默认值 = ‘’) – JSON 注释文件的路径列表。
avoid_class_remapping（避免类别重映射）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则类别 ID 值将直接返回，与它们在清单文件中的定义保持一致。
否则，类别 ID 值将被映射到从 1 到类别数量的连续值，而忽略清单文件中的确切值（0 保留给特殊的背景类别）。
bytes_per_sample_hint（每样本字节数提示）¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap（不使用内存映射）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
dump_meta_files（转储元文件）¶ (bool) –
警告
参数 dump_meta_files 是
save_preprocessed_annotations的已弃用别名。请使用save_preprocessed_annotations代替。dump_meta_files_path（转储元文件路径）¶ (str) –
警告
参数 dump_meta_files_path 是
save_preprocessed_annotations_dir的已弃用别名。请使用save_preprocessed_annotations_dir代替。file_root（文件根目录）¶ (str, 可选) –
包含数据文件的目录的路径。
如果未提供文件列表，则此参数为必需参数。
image_ids（图像 ID）¶ (bool, 可选, 默认值 = False) – 如果设置为 True，图像 ID 将在额外的输出中生成。
images（图像）¶ (str 或 str 列表, 可选) –
图像路径列表。
如果提供，则指定将要读取的图像。图像将按照它们在列表中出现的顺序读取，如果存在重复项，则将生成相关样本的多个副本。
如果未指定或设置为 None，则将读取注释文件中列出的所有图像，每个图像仅读取一次，并按其图像 ID 排序。
要保留的路径应与注释文件中的路径完全匹配。
注意：此参数与
preprocessed_annotations互斥。include_iscrowd（包含 iscrowd）¶ (bool, 可选, 默认值 = True) – 如果设置为 True，则标记为
iscrowd=1的注释也将被包含在内。initial_fill（初始填充）¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init（延迟初始化）¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
ltrb¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则边界框以 [左, 上, 右, 下] 的形式返回。
如果设置为 False，则边界框以 [x, y, 宽度, 高度] 的形式返回。
masks（掩码）¶ (bool, 可选, 默认值 = False) –
启用多边形掩码。
警告
请使用
polygon_masks代替。请注意，多边形格式已从mask_id, start_coord, end_coord更改为mask_id, start_vertex, end_vertex，其中 start_coord 和 end_coord 是坐标总数，实际上start_coord = 2 * start_vertex和end_coord = 2 * end_vertex。 示例：具有顶点[[x0, y0], [x1, y1], [x2, y2]]的多边形在使用已弃用的参数masks时将表示为[mask_id, 0, 6]，但在使用新参数polygon_masks时将表示为[mask_id, 0, 3]。meta_files_path（元文件路径）¶ (str) –
警告
参数 meta_files_path 是
preprocessed_annotations的已弃用别名。请使用preprocessed_annotations代替。num_shards（分片数）¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch（填充最后一个批次）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
pixelwise_masks（像素级掩码）¶ (bool, 可选, 默认值 = False) – 如果为 true，则读取分割掩码并将其作为像素级掩码返回。此参数与
polygon_masks互斥。polygon_masks（多边形掩码）¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则以两种输出形式读取分割掩码多边形：
polygons和vertices。此参数与pixelwise_masks互斥。prefetch_queue_depth（预取队列深度）¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preprocessed_annotations（预处理注释）¶ (str, 可选, 默认值 = ‘’) – 包含预处理 COCO 注释的元文件的目录路径。
preserve（保留）¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止将其从图中删除。
random_shuffle（随机打乱）¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。ratio（比例）¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则返回的边界框和掩码多边形坐标相对于图像尺寸。
read_ahead（预读）¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
save_img_ids（保存图像 ID）¶ (bool) –
save_preprocessed_annotations（保存预处理注释）¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则运算符保存一组文件，其中包含预处理 COCO 注释的二进制表示。
save_preprocessed_annotations_dir（保存预处理注释目录）¶ (str, 可选, 默认值 = ‘’) – 用于保存预处理 COCO 注释文件的目录路径。
seed（种子）¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id（分片 ID）¶ (int, 可选, 默认值 = 0) – 要读取的分片的索引。
shuffle_after_epoch（每个 epoch 后打乱）¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则读取器在每个 epoch 后打乱整个数据集。
size_threshold（尺寸阈值）¶ (float, 可选, 默认值 = 0.1) – 如果表示对象实例的边界框的宽度或高度（以像素数为单位）低于此值，则该对象将被忽略。
skip_cached_images（跳过缓存图像）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
skip_empty（跳过空样本）¶ (bool, 可选, 默认值 = False) – 如果为 true，则读取器将跳过其中没有对象实例的样本
stick_to_shard（坚持分片）¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes（张量初始化字节数）¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, annotations_file='', avoid_class_remapping=False, bytes_per_sample_hint=[0], dont_use_mmap=False, file_root=None, image_ids=False, images=None, include_iscrowd=True, initial_fill=1024, lazy_init=False, ltrb=False, num_shards=1, pad_last_batch=False, pixelwise_masks=False, polygon_masks=False, prefetch_queue_depth=1, preprocessed_annotations='', preserve=False, random_shuffle=False, ratio=False, read_ahead=False, save_preprocessed_annotations=False, save_preprocessed_annotations_dir='', seed=-1, shard_id=0, shuffle_after_epoch=False, size_threshold=0.1, skip_cached_images=False, skip_empty=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.Caffe(*, bytes_per_sample_hint=[0], dont_use_mmap=False, image_available=True, initial_fill=1024, label_available=True, lazy_init=False, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
从 Caffe LMDB 读取 (图像, 标签) 对。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint（每样本字节数提示）¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap（不使用内存映射）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
image_available（图像可用）¶ (bool, 可选, 默认值 = True) – 确定在此 LMDB 中是否提供图像。
initial_fill（初始填充）¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。label_available（标签可用）¶ (bool, 可选, 默认值 = True) – 确定是否提供标签。
lazy_init（延迟初始化）¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
num_shards（分片数）¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch（填充最后一个批次）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
path（路径）¶ (str 或 str 列表) – Caffe LMDB 目录的路径列表。
prefetch_queue_depth（预取队列深度）¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve（保留）¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止将其从图中删除。
random_shuffle（随机打乱）¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。read_ahead（预读）¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed（种子）¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id（分片 ID）¶ (int, 可选, 默认值 = 0) – 要读取的分片的索引。
skip_cached_images（跳过缓存图像）¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard（坚持分片）¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes（张量初始化字节数）¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], dont_use_mmap=False, image_available=True, initial_fill=1024, label_available=True, lazy_init=False, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.Caffe2(*, additional_inputs=0, bbox=False, bytes_per_sample_hint=[0], dont_use_mmap=False, image_available=True, initial_fill=1024, label_type=0, lazy_init=False, num_labels=1, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
从 Caffe2 Lightning 内存映射数据库 (LMDB) 读取样本数据。
- 支持的后端
‘cpu’
- 关键字参数:
additional_inputs¶ (int, 可选, 默认值 = 0) – 为每个样本提供的额外辅助数据张量。
bbox¶ (bool, 可选, 默认值 = False) – 表示是否存在边界框信息。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
image_available¶ (bool, 可选, 默认值 = True) – 确定此 LMDB 中是否有图像可用。
initial_fill¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。label_type¶ (int, 可选, 默认值 = 0) –
数据集中存储的标签类型。
以下是可用值的列表
0 = SINGLE_LABEL：这是多类分类的整数标签。
1 = MULTI_LABEL_SPARSE：这是多标签分类的稀疏活动标签索引。
2 = MULTI_LABEL_DENSE：这是标签嵌入回归的密集标签嵌入向量。
3 = MULTI_LABEL_WEIGHTED_SPARSE：这是多标签分类的每个标签权重的稀疏活动标签索引。
4 = NO_LABEL：没有可用的标签。
lazy_init¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
num_labels¶ (int, 可选, 默认值 = 1) –
数据集中的类别数量。
当使用稀疏标签时是必需的。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
path¶ (str 或 str 列表) – Caffe2 LMDB 目录的路径列表。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, 可选, 默认值 = 0) – 要读取的分片索引。
skip_cached_images¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, additional_inputs=0, bbox=False, bytes_per_sample_hint=[0], dont_use_mmap=False, image_available=True, initial_fill=1024, label_type=0, lazy_init=False, num_labels=1, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.File(*, bytes_per_sample_hint=[0], case_sensitive_filter=False, dir_filters=None, dont_use_mmap=False, file_filters=['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tif', '*.tiff', '*.pnm', '*.ppm', '*.pgm', '*.pbm', '*.jp2', '*.webp', '*.flac', '*.ogg', '*.wav'], file_list=None, file_root=None, files=None, initial_fill=1024, labels=None, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
读取文件内容并返回文件-标签对。
此运算符可以在以下模式中使用
从目录中列出文件，根据子目录结构分配标签。
在此模式下，
file_root参数中指示的目录应包含一个或多个子目录。将列出这些子目录中的文件，并根据子目录的字典顺序分配标签。如果您提供带有 glob 模式字符串列表的file_filters参数，则运算符将列出与至少一个模式匹配的文件。否则，将使用默认的过滤器集（有关详细信息，请参见file_filters的默认值）。例如，此目录结构
<file_root>/0/image0.jpg <file_root>/0/world_map.jpg <file_root>/0/antarctic.png <file_root>/1/cat.jpeg <file_root>/1/dog.tif <file_root>/2/car.jpeg <file_root>/2/truck.jp2
默认情况下将产生以下输出
<contents of 0/image0.jpg> 0 <contents of 0/world_map.jpg> 0 <contents of 0/antarctic.png> 0 <contents of 1/cat.jpeg> 1 <contents of 1/dog.tif> 1 <contents of 2/car.jpeg> 2 <contents of 2/truck.jp2> 2
并且使用
file_filters = ["*.jpg", "*.jpeg"]将产生以下输出<contents of 0/image0.jpg> 0 <contents of 0/world_map.jpg> 0 <contents of 1/cat.jpeg> 1 <contents of 2/car.jpeg> 2
使用文本文件中存储的文件名和标签。
file_list参数指向一个文件，该文件每行包含一个文件名和标签。例如dog.jpg 0 cute kitten.jpg 1 doge.png 0
文件名中间可以包含空格，但不能包含尾随空格。
使用作为字符串列表和整数列表分别提供的文件名和标签。
与其他读取器一样，此运算符返回的（文件，标签）对可以随机打乱，并且可以应用各种分片策略。有关详细信息，请参见此运算符参数的文档。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
case_sensitive_filter¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则过滤器将区分大小写匹配，否则不区分大小写。
dir_filters¶ (str 或 str 列表，可选) –
用于过滤
file_root下子目录列表的 glob 模式字符串列表。dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
file_filters¶ (str 或 str 列表, 可选, 默认值 = [‘*.jpg’, ‘*.jpeg’, ‘*.png’, ‘*.bmp’, ‘*.tif’, ‘*.tiff’, ‘*.pnm’, ‘*.ppm’, ‘*.pgm’, ‘*.pbm’, ‘*.jp2’, ‘*.webp’, ‘*.flac’, ‘*.ogg’, ‘*.wav’]) –
用于过滤
file_root的子目录中的文件列表的 glob 模式字符串列表。file_list¶ (str, 可选) –
指向文本文件的路径，该文本文件每行包含一个空格分隔的
filename label对。文件名相对于该文件的位置或file_root（如果指定）。此参数与
files互斥。file_root¶ (str, 可选) –
包含数据文件的目录的路径。
如果不使用
file_list或files，则遍历此目录以发现文件。在这种操作模式下，file_root是必需的。files¶ (str 或 str 列表，可选) –
要从中读取数据的文件的文件路径列表。
如果提供了
file_root，则路径被视为相对于它。当使用files时，标签从labels参数获取，或者，如果未提供，则包含给定文件在files列表中出现的索引。此参数与
file_list互斥。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。labels¶ (int 或 int 列表，可选) –
伴随
files参数中列出的文件内容的标签。如果未使用，则顺序的从 0 开始的索引将用作标签
lazy_init¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, 可选, 默认值 = 0) – 要读取的分片索引。
shuffle_after_epoch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则读取器在每个 epoch 后 shuffle 整个数据集。
stick_to_shard和random_shuffle在此参数设置为 True 时不能使用。skip_cached_images¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], case_sensitive_filter=False, dir_filters=None, dont_use_mmap=False, file_filters=['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tif', '*.tiff', '*.pnm', '*.ppm', '*.pgm', '*.pbm', '*.jp2', '*.webp', '*.flac', '*.ogg', '*.wav'], file_list=None, file_root=None, files=None, initial_fill=1024, labels=None, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.MXNet(*, bytes_per_sample_hint=[0], dont_use_mmap=False, index_path=None, initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
从 MXNet RecordIO 读取数据。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
index_path¶ (str 或 str 列表) –
包含索引 (.idx) 文件路径的列表（长度为 1）。
该文件由 MXNet 的
im2rec.py脚本随 RecordIO 文件一起生成。该列表也可以使用随 DALI 分发的rec2idx脚本生成。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析并准备数据集元数据，而不是在构造函数中。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
path¶ (str 或 str 列表) – RecordIO 文件路径列表。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, 可选, 默认值 = False) – 即使操作符的输出未使用，也阻止将其从图中移除。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, 可选, 默认值 = 0) – 要读取的分片索引。
skip_cached_images¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], dont_use_mmap=False, index_path=None, initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, path=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.NemoAsr(*, bytes_per_sample_hint=[0], dont_use_mmap=False, downmix=True, dtype=DALIDataType.FLOAT, initial_fill=1024, lazy_init=False, manifest_filepaths=None, max_duration=0.0, min_duration=0.0, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, quality=50.0, random_shuffle=False, read_ahead=False, read_idxs=False, read_sample_rate=True, read_text=True, sample_rate=-1.0, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
从 NVIDIA NeMo 兼容的 manifest 文件中读取自动语音识别 (ASR) 数据（音频、文本）。
Manifest 文件示例
{ "audio_filepath": "path/to/audio1.wav", "duration": 3.45, "text": "this is a nemo tutorial" } { "audio_filepath": "path/to/audio1.wav", "offset": 3.45, "duration": 1.45, "text": "same audio file but using offset" } { "audio_filepath": "path/to/audio2.wav", "duration": 3.45, "text": "third transcript in this example" }
注意
只有
audio_filepath字段是强制性的。如果未指定duration，将使用整个音频文件。 缺少text字段将生成一个空字符串作为文本。警告
尚未实现对
duration和offset字段的处理。当前实现始终读取整个音频文件。此读取器生成 1 到 3 个输出：
解码后的音频数据：float，
shape=(audio_length,)（可选，如果
read_sample_rate=True）音频采样率：float，shape=(1,)（可选，如果
read_text=True）转录文本，以空字符结尾的字符串：uint8，shape=(text_len + 1,)（可选，如果
read_idxs=True）manifest 条目的索引：int64，shape=(1,)
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
downmix¶ (bool, 可选, 默认值 = True) – 如果为 True，则将所有输入通道下混合为单声道。如果启用下混合，解码器将始终生成 1 维输出
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.FLOAT) –输出数据类型。
支持的类型：
INT16,INT32, 和FLOAT。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析并准备数据集元数据，而不是在构造函数中。
manifest_filepaths¶ (str 或 str 列表) – NeMo 兼容 manifest 文件路径列表。
max_duration¶ (float, 可选, 默认值 = 0.0) –
如果提供大于 0 的值，则指定音频样本的最大允许时长（秒）。
时长超过此值的样本将被忽略。
min_duration¶ (float, 可选, 默认值 = 0.0) –
- 如果提供大于 0 的值，则指定音频样本的最小允许时长（秒）。
秒，音频样本的最小允许时长。
时长短于此值的样本将被忽略。
normalize_text¶ (bool) –
警告
参数 normalize_text 不再使用，并将在未来的版本中移除。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, 可选, 默认值 = False) – 即使操作符的输出未使用，也阻止将其从图中移除。
quality¶ (float, 可选, 默认值 = 50.0) –
重采样质量，0 为最低，100 为最高。
0 对应于 sinc 滤波器的 3 个波瓣；50 给出 16 个波瓣，100 给出 64 个波瓣。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
read_idxs¶ (bool, 可选, 默认值 = False) –
- 是否将样本的索引作为单独的输出，索引是它们在 manifest 文件中出现的顺序
作为单独的输出
read_sample_rate¶ (bool, 可选, 默认值 = True) – 是否将每个样本的采样率作为单独的输出
read_text¶ (bool, 可选, 默认值 = True) – 是否将每个样本的转录文本作为单独的输出
sample_rate¶ (float, 可选, 默认值 = -1.0) – 如果指定，则为目标采样率（Hz），音频将重采样到此采样率。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, 可选, 默认值 = 0) – 要读取的分片索引。
shuffle_after_epoch¶ (bool, 可选, 默认值 = False) – 如果为 true，则读取器在每个 epoch 后对整个数据集进行洗牌
skip_cached_images¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], dont_use_mmap=False, downmix=True, dtype=DALIDataType.FLOAT, initial_fill=1024, lazy_init=False, manifest_filepaths=None, max_duration=0.0, min_duration=0.0, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, quality=50.0, random_shuffle=False, read_ahead=False, read_idxs=False, read_sample_rate=True, read_text=True, sample_rate=-1.0, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.Numpy(*, bytes_per_sample_hint=[0], cache_header_information=False, dont_use_mmap=False, file_filter='*.npy', file_list=None, file_root=None, files=None, fill_value=0.0, initial_fill=1024, lazy_init=False, num_shards=1, out_of_bounds_policy='error', pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, register_buffers=True, rel_roi_end=None, rel_roi_shape=None, rel_roi_start=None, roi_axes=[], roi_end=None, roi_shape=None, roi_start=None, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, use_o_direct=False, device=None, name=None)#
从目录中读取 Numpy 数组。
此运算符可以在以下模式中使用
读取由
file_root指示的目录中，所有匹配给定file_filter的文件。从
file_list参数中指示的文本文件读取文件名。读取在
files参数中列出的文件。
注意
gpu后端需要 cuFile/GDS 支持 (418.x 驱动系列或更新版本)，它随 CUDA 工具包一起发布，从 CUDA 11.4 开始。请查看 GDS 文档以获取更多详细信息。gpu读取器以块读取文件。块的大小可以通过进程范围的环境变量DALI_GDS_CHUNK_SIZE控制。有效值是介于 4096 和 16M 之间的 2 的幂，默认值为 2M。为了方便起见，该值可以使用 k 或 M 后缀指定，分别应用 1024 和 2^20 的乘数。- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
cache_header_information¶ (bool, 可选, 默认值 = False) – 如果设置为 True，则缓存每个文件的标头信息，从而提高访问速度。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
file_filter¶ (str, 可选, 默认值 = ‘*.npy’) –
如果指定了值，则该字符串将被解释为 glob 字符串，以过滤
file_root的子目录中的文件列表。file_list¶ (str, 可选) –
文本文件的路径，其中包含文件名（每行一个），文件名相对于该文件的位置或
file_root（如果指定）的位置。此参数与
files互斥。file_root¶ (str, 可选) –
包含数据文件的目录的路径。
如果不使用
file_list或files，则会遍历此目录以发现文件。在这种操作模式下，file_root是必需的。files¶ (str 或 str 列表, 可选) –
要从中读取数据的文件的文件路径列表。
如果提供了
file_root，则路径将被视为相对于它。此参数与
file_list互斥。fill_value¶ (float, 可选, 默认值 = 0.0) – 当
out_of_bounds_policy设置为 “pad” 时，确定填充值。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, 可选, 默认值 = False) – 仅在第一次运行时解析和准备数据集元数据，而不是在构造函数中。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
out_of_bounds_policy¶ (str, 可选, 默认值 = ‘error’) –
确定读取超出 numpy 数组边界时的策略。
以下是支持值的列表
"error"(默认): 尝试读取超出图像边界的内容将产生错误。"pad": 数组将根据需要用零或使用fill_value参数指定的任何其他值进行填充。"trim_to_shape": ROI 将被裁剪到数组的边界。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, 可选, 默认值 = False) – 即使操作符的输出未使用，也阻止将其从图中删除。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机 shuffle 数据。
使用大小等于
initial_fill的预取缓冲区顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
register_buffers¶ (bool, 可选, 默认值 = True) –
仅适用于
gpu后端类型。警告
此参数暂时禁用，并保留以实现向后兼容性。它将在未来的版本中重新启用。
如果为 true，则设备 I/O 缓冲区将注册到 cuFile。如果样本大小差异很大，则不建议这样做。
rel_roi_end¶ (float 或 float 列表或 TensorList of float, 可选) –
感兴趣区域的结束位置，以相对坐标表示（范围 [0.0 - 1.0]）。
此参数与 “roi_end”、“roi_shape” 和 “rel_roi_shape” 不兼容。
rel_roi_shape¶ (float 或 float 列表或 TensorList of float, 可选) –
感兴趣区域的形状，以相对坐标表示（范围 [0.0 - 1.0]）。
此参数与 “roi_shape”、“roi_end” 和 “rel_roi_end” 不兼容。
rel_roi_start¶ (float 或 float 列表或 TensorList of float, 可选) –
感兴趣区域的起始位置，以相对坐标表示（范围 [0.0 - 1.0]）。
此参数与 “roi_start” 不兼容。
roi_axes¶ (int 或 int 列表, 可选, 默认值 = []) –
用于 ROI 锚点和形状参数的维度顺序，作为维度索引。
如果未提供，则应在 ROI 参数中指定所有维度。
roi_end¶ (int 或 int 列表或 TensorList of int, 可选) –
感兴趣区域的结束位置，以绝对坐标表示。
此参数与 “rel_roi_end”、“roi_shape” 和 “rel_roi_shape” 不兼容。
roi_shape¶ (int 或 int 列表或 TensorList of int, 可选) –
感兴趣区域的形状，以绝对坐标表示。
此参数与 “rel_roi_shape”、“roi_end” 和 “rel_roi_end” 不兼容。
roi_start¶ (int 或 int 列表或 TensorList of int, 可选) –
感兴趣区域的起始位置，以绝对坐标表示。
此参数与 “rel_roi_start” 不兼容。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, 可选, 默认值 = 0) – 要读取的分片索引。
shuffle_after_epoch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则读取器在每个 epoch 后 shuffle 整个数据集。
当此参数设置为 True 时，不能使用
stick_to_shard和random_shuffle。skip_cached_images¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, 可选, 默认值 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, 可选, 默认值 = 1048576) – 每个图像要分配多少内存的提示。
use_o_direct¶ (bool, 可选, 默认值 = False) –
如果设置为 True，数据将直接从存储读取，绕过系统缓存。
与
dont_use_mmap=False互斥。
- __call__(*, bytes_per_sample_hint=[0], cache_header_information=False, dont_use_mmap=False, file_filter='*.npy', file_list=None, file_root=None, files=None, fill_value=0.0, initial_fill=1024, lazy_init=False, num_shards=1, out_of_bounds_policy='error', pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, register_buffers=True, rel_roi_end=None, rel_roi_shape=None, rel_roi_start=None, roi_axes=[], roi_end=None, roi_shape=None, roi_start=None, seed=-1, shard_id=0, shuffle_after_epoch=False, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, use_o_direct=False, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.Sequence(*, bytes_per_sample_hint=[0], dont_use_mmap=False, file_root=None, image_type=DALIImageType.RGB, initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, step=1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
警告
此算子现已弃用。
此操作符可能在未来的版本中移除。
可以使用
external_source()来实现自定义读取模式。 对于读取视频序列，可以使用nvidia.dali.fn.readers.video(),nvidia.dali.fn.experimental.readers.video(),nvidia.dali.fn.experimental.decoders.video()或nvidia.dali.fn.experimental.inputs.video()中的一个。从表示流集合的目录中读取 [帧] 序列。
此操作符期望
file_root包含一组目录，其中每个目录代表一个提取的视频流。 此流由每个帧一个文件表示，并按字典顺序排序。 序列不会跨越流边界，并且仅考虑完整的序列，因此没有填充。目录结构示例
- file_root - 0 - 00001.png - 00002.png - 00003.png - 00004.png - 00005.png - 00006.png .... - 1 - 00001.png - 00002.png - 00003.png - 00004.png - 00005.png - 00006.png ....
注意
此操作符是视频读取器的类似物，适用于作为单独图像提取的视频帧。 其主要目的是用于测试基线。 对于常规使用，建议使用视频读取器。
此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
file_root¶ (str) – 包含流的目录的路径，其中目录代表流。
image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 输入和输出图像的色彩空间。initial_fill¶ (int, optional, default = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, optional, default = False) – 仅在首次运行时解析并准备数据集元数据，而不是在构造函数中。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, optional, default = False) – 即使操作符的输出未使用，也阻止其从图中移除。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机 shuffle 数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
sequence_length¶ (int) – 每个样本加载的序列长度。
shard_id¶ (int, optional, default = 0) – 要读取的分片的索引。
skip_cached_images¶ (bool, optional, default = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
step¶ (int, optional, default = 1) – 连续序列的起始帧之间的距离。
stick_to_shard¶ (bool, optional, default = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
stride¶ (int, optional, default = 1) – 序列中连续帧之间的距离。
tensor_init_bytes¶ (int, optional, default = 1048576) – 每个图像要分配多少内存的提示。
- __call__(*, bytes_per_sample_hint=[0], dont_use_mmap=False, file_root=None, image_type=DALIImageType.RGB, initial_fill=1024, lazy_init=False, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, step=1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.TFRecord(path, index_path, features, **kwargs)#
从 TensorFlow TFRecord 文件读取样本。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
features¶ (dict of (string, nvidia.dali.tfrecord.Feature)) –
一个字典，将要提取的 TFRecord 特征的名称映射到特征类型。
通常通过使用
dali.tfrecord.FixedLenFeature和dali.tfrecord.VarLenFeature辅助函数获得，它们分别等同于 TensorFlow 的tf.FixedLenFeature和tf.VarLenFeature类型。为了获得额外的灵活性，dali.tfrecord.VarLenFeature支持partial_shape参数。如果提供，数据将被重塑以匹配其值，并且第一维度将从数据大小推断出来。如果命名的特征在处理的 TFRecord 条目中不存在，则返回一个空张量。
index_path¶ (str or list of str) –
索引文件路径列表。每个 TFRecord 文件应该有一个索引文件。
索引文件可以通过使用随 DALI 分发的
tfrecord2idx脚本从 TFRecord 文件获得。initial_fill¶ (int, optional, default = 1024) –
用于 shuffle 的缓冲区大小。
如果 random_shuffle 为 False，则忽略此参数。
lazy_init¶ (bool, optional, default = False) – 仅在首次运行时解析并准备数据集元数据，而不是在构造函数中。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
path¶ (str or list of str) – TFRecord 文件路径列表。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, optional, default = False) – 即使操作符的输出未使用，也阻止其从图中移除。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机 shuffle 数据。
大小等于 initial_fill 的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。
read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, optional, default = 0) – 要读取的分片的索引。
skip_cached_images¶ (bool, optional, default = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, optional, default = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, optional, default = 1048576) – 每个图像要分配多少内存的提示。
use_o_direct¶ (bool, optional, default = False) –
如果设置为 True，数据将直接从存储读取，绕过系统缓存。
与
dont_use_mmap=False互斥。
- class nvidia.dali.ops.readers.Video(*, additional_decode_surfaces=2, bytes_per_sample_hint=[0], channels=3, dont_use_mmap=False, dtype=DALIDataType.UINT8, enable_frame_num=False, enable_timestamps=False, file_list='', file_list_frame_num=False, file_list_include_preceding_frame=False, file_root='', filenames=[], image_type=DALIImageType.RGB, initial_fill=1024, labels=None, lazy_init=False, normalized=False, num_shards=1, pad_last_batch=False, pad_sequences=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, skip_vfr_check=False, step=-1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
使用 FFmpeg 和 NVDECODE 加载和解码视频文件，NVDECODE 是 NVIDIA(R) GPU 中的硬件加速视频解码功能。
视频流可以是大多数容器文件格式。FFmpeg 用于解析视频容器，并返回形状为
(N, F, H, W, C)的sequence_length帧序列批次（其中N是批次大小，F是帧数）。此类仅支持恒定帧率视频。注意
不支持索引的容器（如 mpeg）需要 DALI 在每次需要解码新序列时查找序列。
- 支持的后端
‘gpu’
- 关键字参数:
additional_decode_surfaces¶ (int, optional, default = 2) –
超出最低要求使用的额外解码表面数。
当解码器无法确定最少解码表面数时，将忽略此参数
注意
当驱动程序版本较旧时，可能会发生这种情况。
此参数可用于权衡内存使用量和性能。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
channels¶ (int, optional, default = 3) – 通道数。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.UINT8) –输出数据类型。
支持的类型：
UINT8或FLOAT。enable_frame_num¶ (bool, optional, default = False) – 如果传递了
file_list或filenames参数，则返回帧号输出。enable_timestamps¶ (bool, optional, default = False) – 如果传递了
file_list或filenames参数，则返回时间戳输出。file_list¶ (str, optional, default = ‘’) –
包含
file label [start_frame [end_frame]]值的列表的文件路径。正值表示确切的帧，负值从末尾开始计数为第 N 帧（它遵循 python 数组索引模式），开始帧和结束帧的相等值将产生一个空序列和一个警告。此选项与
filenames和file_root互斥。file_list_frame_num¶ (bool, optional, default = False) –
如果在 file_list 中提供了开始/结束时间戳，您可以将它们解释为帧号而不是时间戳。
如果提供了浮点值，开始帧号将向上舍入，结束帧号将向下舍入。
帧号从 0 开始。
file_list_include_preceding_frame¶ (bool, optional, default = False) –
更改
file_list开始和结束帧时间戳如何转换为帧号的行为。如果在 file_list 中将开始/结束时间戳作为时间戳提供，则开始帧计算为
ceil(start_time_stamp * FPS)，结束帧计算为floor(end_time_stamp * FPS)。如果此参数设置为 True，则等式变为floor(start_time_stamp * FPS)和ceil(end_time_stamp * FPS)。实际上，第一个返回的帧不晚于，且结束帧不早于提供的时间戳。此行为更符合可见时间戳与显示的视频帧的关联方式。注意
当
file_list_frame_num设置为 True 时，此选项不起作用。警告
此选项可用于旧版行为兼容性。
file_root¶ (str, optional, default = ‘’) –
包含数据文件的目录的路径。
filenames¶ (str or list of str, optional, default = []) –
要加载的视频文件的文件名。
image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 输出帧的色彩空间（RGB 或 YCbCr）。initial_fill¶ (int, optional, default = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。labels¶ (int or list of int, optional) –
与
filenames参数中列出的文件关联的标签。如果提供了空列表，则顺序的从 0 开始的索引用作标签。如果未提供，则不会生成标签。
lazy_init¶ (bool, optional, default = False) – 仅在首次运行时解析并准备数据集元数据，而不是在构造函数中。
normalized¶ (bool, optional, default = False) – 将输出作为归一化数据获取。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
pad_sequences¶ (bool, optional, default = False) –
如果在视频的末尾没有足够的帧，则允许创建不完整的序列。
冗余帧被置零。 相应的时间戳和帧号设置为 -1。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, optional, default = False) – 即使操作符的输出未使用，也阻止其从图中移除。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机 shuffle 数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个种子。
sequence_length¶ (int) – 每个序列加载的帧数。
shard_id¶ (int, optional, default = 0) – 要读取的分片的索引。
skip_cached_images¶ (bool, optional, default = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
skip_vfr_check¶ (bool, optional, default = False) –
跳过可变帧率 (VFR) 视频的检查。
使用此标志可抑制对 VFR 视频的误报检测。
警告
当数据集确实包含 VFR 文件时，设置此标志可能会导致解码器故障。
step¶ (int, optional, default = -1) –
每个序列之间的帧间隔。
当值小于 0 时，
step将设置为sequence_length。stick_to_shard¶ (bool, optional, default = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
stride¶ (int, optional, default = 1) – 序列中连续帧之间的距离。
tensor_init_bytes¶ (int, optional, default = 1048576) – 每个图像要分配的内存大小提示。
- __call__(*, additional_decode_surfaces=2, bytes_per_sample_hint=[0], channels=3, dont_use_mmap=False, dtype=DALIDataType.UINT8, enable_frame_num=False, enable_timestamps=False, file_list='', file_list_frame_num=False, file_list_include_preceding_frame=False, file_root='', filenames=[], image_type=DALIImageType.RGB, initial_fill=1024, labels=None, lazy_init=False, normalized=False, num_shards=1, pad_last_batch=False, pad_sequences=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, sequence_length=None, shard_id=0, skip_cached_images=False, skip_vfr_check=False, step=-1, stick_to_shard=False, stride=1, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.VideoResize(*, additional_decode_surfaces=2, antialias=True, bytes_per_sample_hint=[0], channels=3, dont_use_mmap=False, dtype=DALIDataType.UINT8, enable_frame_num=False, enable_timestamps=False, file_list='', file_list_frame_num=False, file_list_include_preceding_frame=False, file_root='', filenames=[], image_type=DALIImageType.RGB, initial_fill=1024, interp_type=DALIInterpType.INTERP_LINEAR, labels=None, lazy_init=False, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', normalized=False, num_shards=1, pad_last_batch=False, pad_sequences=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, seed=-1, sequence_length=None, shard_id=0, size=None, skip_cached_images=False, skip_vfr_check=False, step=-1, stick_to_shard=False, stride=1, subpixel_scale=True, temp_buffer_hint=0, tensor_init_bytes=1048576, device=None, name=None)#
使用 FFmpeg 和 NVDECODE 加载、解码和调整视频文件大小，NVDECODE 是 NVIDIA GPU 的硬件加速视频解码。
视频流可以是大多数容器文件格式。FFmpeg 用于解析视频容器，并返回形状为
(N, F, H, W, C)的序列批次，其中 N 是批次大小，F 是序列中的帧数。此运算符结合了
nvidia.dali.fn.video_reader()和nvidia.dali.fn.resize()的功能。注意
解码器仅支持恒定帧率视频。
- 支持的后端
‘gpu’
- 关键字参数:
additional_decode_surfaces¶ (int, optional, default = 2) –
超出最低要求使用的额外解码表面数。
当解码器无法确定最少解码表面数时，将忽略此参数
注意
当驱动程序版本较旧时，可能会发生这种情况。
此参数可用于权衡内存使用量和性能。
antialias¶ (bool, optional, default = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
channels¶ (int, optional, default = 3) – 通道数。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.UINT8) –输出数据类型。
支持的类型：
UINT8或FLOAT。enable_frame_num¶ (bool, optional, default = False) – 如果传递了
file_list或filenames参数，则返回帧号输出。enable_timestamps¶ (bool, optional, default = False) – 如果传递了
file_list或filenames参数，则返回时间戳输出。file_list¶ (str, optional, default = ‘’) –
包含
file label [start_frame [end_frame]]值的列表的文件路径。正值表示确切的帧，负值表示从末尾开始的第 N 帧（遵循 python 数组索引模式），start 和 end 帧的相等值将产生一个空序列和一个警告。此选项与
filenames和file_root互斥。file_list_frame_num¶ (bool, optional, default = False) –
如果在 file_list 中提供了开始/结束时间戳，您可以将它们解释为帧号而不是时间戳。
如果提供了浮点值，开始帧号将向上舍入，结束帧号将向下舍入。
帧号从 0 开始。
file_list_include_preceding_frame¶ (bool, optional, default = False) –
更改
file_list开始和结束帧时间戳如何转换为帧号的行为。如果在 file_list 中将开始/结束时间戳作为时间戳提供，则开始帧计算为
ceil(start_time_stamp * FPS)，结束帧计算为floor(end_time_stamp * FPS)。如果此参数设置为 True，则等式变为floor(start_time_stamp * FPS)和ceil(end_time_stamp * FPS)。实际上，第一个返回的帧不晚于，且结束帧不早于提供的时间戳。此行为更符合可见时间戳与显示的视频帧的关联方式。注意
当
file_list_frame_num设置为 True 时，此选项不起作用。警告
此选项可用于旧版行为兼容性。
file_root¶ (str, optional, default = ‘’) –
包含数据文件的目录的路径。
filenames¶ (str or list of str, optional, default = []) –
要加载的视频文件的文件名。
image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 输出帧的色彩空间（RGB 或 YCbCr）。initial_fill¶ (int, optional, default = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。interp_type¶ (
nvidia.dali.types.DALIInterpTypeor TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来指定用于缩小和放大的不同滤波。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为以下组合：
INTERP_LINEAR 启用
antialias。labels¶ (int or list of int, optional) –
与
filenames参数中列出的文件关联的标签。如果提供了空列表，则顺序的从 0 开始的索引用作标签。如果未提供，则不会生成标签。
lazy_init¶ (bool, optional, default = False) – 仅在第一次运行时解析和准备数据集元数据，而不是在构造函数中。
mag_filter¶ (
nvidia.dali.types.DALIInterpTypeor TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。max_size¶ (float or list of float, optional) –
输出尺寸的限制。
当运算符配置为保持宽高比且仅指定较小尺寸时，另一个（或多个）尺寸可能会变得非常大。当使用
resize_shorter参数或 “not_smaller” 模式，或者当某些范围未指定时，可能会发生这种情况。此参数限制了输出可以变得多大。此值可以按轴指定，也可以对所有轴统一指定。
注意
与 “not_smaller” 模式或
resize_shorter参数一起使用时，max_size优先，并且保持宽高比 - 例如，使用mode="not_smaller", size=800, max_size=1400调整大小，大小为 1200x600 的图像将调整为 1400x700。min_filter¶ (
nvidia.dali.types.DALIInterpTypeor TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, optional, default = 32) – 内核调用中处理的最大图像数量。
mode¶ (str, optional, default = ‘default’) –
调整大小模式。
以下是支持模式的列表
"default"- 图像被调整为指定大小。缺失的尺寸范围将使用提供的尺寸范围的平均比例进行缩放。"stretch"- 图像被调整为指定大小。缺失的尺寸范围根本不进行缩放。"not_larger"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不超过指定大小。例如，对于 1280x720 的图像，期望的输出大小为 640x480，实际会生成 640x360 的输出。"not_smaller"- 图像被调整大小，保持宽高比，以便输出图像的任何尺寸范围都不小于指定大小。例如，对于 640x480 的图像，期望的输出大小为 1920x1080，实际会生成 1920x1440 的输出。此参数与
resize_longer和resize_shorter互斥
normalized¶ (bool, optional, default = False) – 获取归一化数据作为输出。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
pad_sequences¶ (bool, optional, default = False) –
如果在视频的末尾没有足够的帧，则允许创建不完整的序列。
冗余帧被置零。 相应的时间戳和帧号设置为 -1。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机 shuffle 数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
resize_longer¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像较长尺寸的长度。
此选项与
resize_shorter和显式 size 参数互斥，并且运算符保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_larger"。resize_shorter¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像较短尺寸的长度。
此选项与
resize_longer和显式 size 参数互斥，并且运算符保持原始图像的宽高比。此选项等效于为所有维度指定相同的大小和mode="not_smaller"。较长维度可以通过设置max_size参数来限制。有关更多信息，请参阅max_size参数文档。resize_x¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像 X 维度的长度。
此选项与
resize_shorter、resize_longer和size互斥。如果resize_y未指定或为 0，则运算符保持原始图像的宽高比。负值会翻转图像。resize_y¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像 Y 维度的长度。
此选项与
resize_shorter、resize_longer和size互斥。如果resize_x未指定或为 0，则运算符保持原始图像的宽高比。负值会翻转图像。resize_z¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后体积 Z 维度的长度。
此选项与
resize_shorter、resize_longer和size互斥。如果resize_x和resize_y未指定或为 0，则此操作将保持原始体积的宽高比。负值会翻转体积。roi_end¶ (float 或 float 列表或 float 的 TensorList，可选) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果任何维度中 ROI 原点大于 ROI 终点，则该区域在该维度中会被翻转。roi_relative¶ (bool, 可选, 默认 = False) – 如果为 true，则 ROI 坐标相对于输入大小，其中 0 表示顶部/左侧，1 表示底部/右侧
roi_start¶ (float 或 float 列表或 float 的 TensorList，可选) –
输入感兴趣区域 (ROI) 的原点。
必须与
roi_end一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标（0..1），具体取决于relative_roi参数的值。如果任何维度中 ROI 原点大于 ROI 终点，则该区域在该维度中会被翻转。seed¶ (int, 可选, 默认 = -1) – 随机种子；如果未设置，将自动分配一个。
sequence_length¶ (int) – 每个序列加载的帧数。
shard_id¶ (int, 可选, 默认 = 0) – 要读取的分片索引。
size¶ (float 或 float 列表或 float 的 TensorList，可选) –
期望的输出大小。
必须是列表/元组，每个空间维度一项，不包括视频帧和通道。维度为 0 范围的将被视作不存在，输出大小将根据其他范围和
mode参数计算。skip_cached_images¶ (bool, 可选, 默认 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
skip_vfr_check¶ (bool, 可选, 默认 = False) –
跳过可变帧率 (VFR) 视频的检查。
使用此标志可抑制对 VFR 视频的误报检测。
警告
当数据集确实包含 VFR 文件时，设置此标志可能会导致解码器故障。
step¶ (int, 可选, 默认 = -1) –
每个序列之间的帧间隔。
当值小于 0 时，
step将设置为sequence_length。stick_to_shard¶ (bool, 可选, 默认 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
stride¶ (int, 可选, 默认 = 1) – 序列中连续帧之间的距离。
subpixel_scale¶ (bool, 可选, 默认 = True) –
如果为 True，则直接指定或计算的分数大小将导致调整输入 ROI 以保持缩放因子。
否则，将调整缩放因子，以便源图像映射到舍入后的输出大小。
temp_buffer_hint¶ (int, 可选, 默认 = 0) –
用于重采样的临时缓冲区的初始大小（以字节为单位）。
注意
此参数对于 CPU 变体将被忽略。
tensor_init_bytes¶ (int, 可选, 默认 = 1048576) – 每个图像要分配的内存大小提示。
- __call__(*, additional_decode_surfaces=2, antialias=True, bytes_per_sample_hint=[0], channels=3, dont_use_mmap=False, dtype=DALIDataType.UINT8, enable_frame_num=False, enable_timestamps=False, file_list='', file_list_frame_num=False, file_list_include_preceding_frame=False, file_root='', filenames=[], image_type=DALIImageType.RGB, initial_fill=1024, interp_type=DALIInterpType.INTERP_LINEAR, labels=None, lazy_init=False, mag_filter=DALIInterpType.INTERP_LINEAR, max_size=None, min_filter=DALIInterpType.INTERP_LINEAR, minibatch_size=32, mode='default', normalized=False, num_shards=1, pad_last_batch=False, pad_sequences=False, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, resize_longer=0.0, resize_shorter=0.0, resize_x=0.0, resize_y=0.0, resize_z=0.0, roi_end=None, roi_relative=False, roi_start=None, seed=-1, sequence_length=None, shard_id=0, size=None, skip_cached_images=False, skip_vfr_check=False, step=-1, stick_to_shard=False, stride=1, subpixel_scale=True, temp_buffer_hint=0, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
- class nvidia.dali.ops.readers.Webdataset(*, bytes_per_sample_hint=[0], case_sensitive_extensions=True, dont_use_mmap=False, dtypes=None, ext=None, index_paths=[], initial_fill=1024, lazy_init=False, missing_component_behavior='', num_shards=1, pad_last_batch=False, paths=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
用于 webdataset 格式的读取器。
webdataset 格式是一种提供对存储在 tar 存档中的数据集进行高效访问的方法。
将数据存储在 POSIX tar 存档中，可以极大地加快机械存储设备和网络文件系统上的 I/O 操作，因为它允许操作系统减少 I/O 操作的数量并预读数据。
WebDataset 的功能类似于 Tensorflow 的 TFRecord/tf.Example 类，但更容易采用，因为它实际上不需要任何数据转换。数据以与磁盘上完全相同的格式存储在 tar 文件中，并且所有预处理和数据增强代码保持不变。
数据集由一个或多个 tar 存档组成，每个存档进一步拆分为样本。一个样本包含一个或多个组件，这些组件对应于存档中包含的实际文件。属于特定样本的组件通过不带扩展名的文件名聚合（有关扩展名的详细信息，请阅读下面
ext参数的描述）。请注意，文件名以点开头以及非普通文件的条目将不会被加载。除了包含数据的 tar 存档外，每个存档都应附带相应的索引文件。索引文件可以使用专用脚本生成
<path_to_dali>/tools/wds2idx.py <path_to_archive> <path_to_index_file>
如果未提供索引文件，将自动从 tar 文件中推断出来。但请记住，这会为大型数据集增加相当多的启动时间。
索引文件的格式为
v1.2 <num_samples> <component1_ext> <component1_data_offset> <component1_size> <component2_ext> <component2_data_offset> <component2_size> ... ...
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
case_sensitive_extensions¶ (bool, 可选, 默认 = True) –
确定通过
ext提供的扩展名是否应区分大小写。允许在
ext参数以及 webdataset 容器中混合大小写。例如，当关闭此选项时：jpg、JPG、jPG 应该都可以工作。如果扩展字符无法表示为 ASCI，则关闭此选项的结果是未定义的。
dont_use_mmap¶ (bool, 可选, 默认 = False) –
如果设置为 True，Loader 将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供了一点性能优势，但大多数网络文件系统不提供最佳性能。
dtypes¶ (DALIDataType 或 DALIDataType 列表，可选) –
各个输出的数据类型。
默认输出数据类型为 UINT8。但是，如果设置，则应指定每个输出数据类型。此外，应构造 tar 文件，使其仅输出字节大小可被数据类型大小整除的样本。
ext¶ (str 或 str 列表) –
为每个生成的输出设置扩展名。
扩展名集合的数量决定了读取器的输出数量。组件的扩展名被计为文件名中第一个点之后的文本（不包括以点开头的样本）。不同的扩展名选项应以分号（‘;’）分隔，并且可以包含点。
示例：“left.png;right.jpg”
index_paths¶ (str 或 str 列表, 可选, 默认 = []) –
与各自的 webdataset 存档对应的索引文件列表。
必须与
paths参数的长度相同。如果未提供，将自动从 webdataset 存档中推断出来。initial_fill¶ (int, 可选, 默认 = 1024) –
用于 shuffle 的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, 可选, 默认 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
missing_component_behavior¶ (str, 可选, 默认 = ‘’) –
指定在样本中没有任何文件对应于某个输出时该怎么做。
- 可能的行为
“empty”（默认）- 在这种情况下，未设置的输出将只包含一个空张量
“skip” - 在这种情况下，整个样本将被跳过（除了减少存档缓存外，对性能没有影响）
“error” - 在这种情况下，将引发异常并且执行停止
num_shards¶ (int, 可选, 默认 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数量不同，则此选项可能会导致将整个重复样本批次添加到数据集中。
paths¶ (str 或 str 列表) –
webdataset 存档的（一个或多个）路径列表。
必须与
index_paths参数的长度相同。prefetch_queue_depth¶ (int, 可选, 默认 = 1) –
指定内部 Loader 要预取的批次数量。
当 pipeline 受 CPU 阶段限制时，应增加此值，从而以内存消耗为代价来更好地与 Loader 线程交错。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中删除，即使其输出未使用。
random_shuffle¶ (bool, 可选, 默认 = False) –
确定是否随机 shuffle 数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认 = False) –
确定是否应预读访问的数据。
对于 LMDB、RecordIO 或 TFRecord 等大型文件，此参数会减慢首次访问速度，但会减少所有后续访问的时间。
seed¶ (int, 可选, 默认 = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, 可选, 默认 = 0) – 要读取的分片索引。
skip_cached_images¶ (bool, 可选, 默认 = False) –
如果设置为 True，则当样本位于解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
stick_to_shard¶ (bool, 可选, 默认 = False) –
确定读取器是否应坚持数据分片而不是遍历整个数据集。
如果使用解码器缓存，它可以显着减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, 可选, 默认 = 1048576) – 每个图像要分配的内存大小提示。
- __call__(*, bytes_per_sample_hint=[0], case_sensitive_extensions=True, dont_use_mmap=False, dtypes=None, ext=None, index_paths=[], initial_fill=1024, lazy_init=False, missing_component_behavior='', num_shards=1, pad_last_batch=False, paths=None, prefetch_queue_depth=1, preserve=False, random_shuffle=False, read_ahead=False, seed=-1, shard_id=0, skip_cached_images=False, stick_to_shard=False, tensor_init_bytes=1048576, device=None, name=None)#
算子调用，用于图定义中。此算子没有任何输入。
nvidia.dali.ops.reductions#
- class nvidia.dali.ops.reductions.Max(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的最大输入元素。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list 的 int, 可选) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, 可选) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
keep_dims¶ (bool, 可选, 默认值 = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中移除该运算符。
- class nvidia.dali.ops.reductions.Mean(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], dtype=None, keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素的均值。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list 的 int, 可选) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, 可选) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) – 输出数据类型。此类型用于累积结果。keep_dims¶ (bool, 可选, 默认值 = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中移除该运算符。
- class nvidia.dali.ops.reductions.MeanSquare(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], dtype=None, keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素的均方值。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list 的 int, 可选) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, 可选) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) – 输出数据类型。此类型用于累积结果。keep_dims¶ (bool, 可选, 默认值 = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中移除该运算符。
- class nvidia.dali.ops.reductions.Min(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的最小输入元素。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list 的 int, 可选) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, 可选) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
keep_dims¶ (bool, 可选, 默认值 = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中移除该运算符。
- class nvidia.dali.ops.reductions.RMS(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], dtype=None, keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素的均方根值。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list 的 int, 可选) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, 可选) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) – 输出数据类型。此类型用于累积结果。keep_dims¶ (bool, 可选, 默认值 = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中移除该运算符。
- class nvidia.dali.ops.reductions.StdDev(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], ddof=0, keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素的标准差。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list 的 int, 可选) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, 可选) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
ddof¶ (int, 可选, 默认值 = 0) – 自由度增量。调整计算中使用的除数，即 N - ddof。
keep_dims¶ (bool, 可选, 默认值 = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, 可选, 默认值 = False) – 即使运算符的输出未使用，也阻止从图中移除该运算符。
- class nvidia.dali.ops.reductions.Sum(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], dtype=None, keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素总和。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list of int, optional) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, optional) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局为 “FHWC” 的
axis_names="HW"，等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) – 输出数据类型。此类型用于累加结果。keep_dims¶ (bool, optional, default = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
- class nvidia.dali.ops.reductions.Variance(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], ddof=0, keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素方差。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
axes¶ (int 或 list of int, optional) –
执行归约运算的轴或轴。
接受的范围是 [-ndim, ndim-1]。 负索引从后往前计数。
不提供任何轴将导致对所有元素执行归约运算。
axis_names¶ (layout str, optional) –
执行归约运算的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局为 “FHWC” 的
axis_names="HW"，等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
ddof¶ (int, optional, default = 0) – Delta 自由度。调整计算中使用的除数，即 N - ddof。
keep_dims¶ (bool, optional, default = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
nvidia.dali.ops.segmentation#
- class nvidia.dali.ops.segmentation.RandomMaskPixel(*, bytes_per_sample_hint=[0], foreground=0, preserve=False, seed=-1, threshold=0.0, value=None, device=None, name=None)#
在掩码中选择随机像素坐标，从均匀分布中采样。
根据运行时参数
foreground，它返回仅前景像素或任何像素。当像素值超过给定
threshold或等于特定value时，像素被分类为前景。- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
foreground¶ (int 或 TensorList of int, optional, default = 0) –
如果非 0，则像素位置从所有前景像素中均匀采样。
如果为 0，则像素位置从所有可用像素中均匀采样。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
threshold¶ (float 或 TensorList of float, optional, default = 0.0) –
所有值高于此阈值的像素都被解释为前景。
此参数与
value参数互斥。value¶ (int 或 TensorList of int, optional) –
所有等于此值的像素都被解释为前景。
此参数与
threshold参数互斥，并且仅用于整数输入。
- class nvidia.dali.ops.segmentation.RandomObjectBBox(*, background=0, bytes_per_sample_hint=[0], cache_objects=False, class_weights=None, classes=None, foreground_prob=1.0, format='anchor_shape', ignore_class=False, k_largest=None, output_class=False, preserve=False, seed=-1, threshold=None, device=None, name=None)#
从掩码中随机选择一个对象并返回其边界框。
此运算符将标记的分割图作为输入。以
foreground_prob的概率，它随机选择一个标签（均匀地或根据作为class_weights给出的分布），提取具有所选标签的像素连通区域，并随机选择其中一个区域。可以根据k_largest和threshold进一步过滤这些区域。输出是以format中描述的格式之一表示的所选区域的边界框。以 1-foreground_prob 的概率，返回输入的整个区域。
- 支持的后端
‘cpu’
- 关键字参数:
background¶ (int 或 TensorList of int, optional, default = 0) –
背景标签。
如果未指定，则为 0 或任何不在
classes中的值。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
cache_objects¶ (bool, optional, default = False) –
缓存对象边界框，以避免在先前看到的输入中查找对象区域的计算成本。
搜索连通像素区域和查找框可能需要很长时间。当数据集项目较少但项目大小较大时，您可以使用缓存来保存框，并在再次看到相同的输入时重复使用它们。输入基于 256 位哈希进行比较，这比重新计算对象框要快得多。
class_weights¶ (float 或 list of float 或 TensorList of float, optional) –
前景类别的相对概率。
每个值对应于
classes中的类标签。如果未指定classes，则会分配连续的从 1 开始的标签。权重之和不必等于 1 - 如果不等于 1，则权重将被归一化。
classes¶ (int 或 list of int 或 TensorList of int, optional) –
被视为前景的标签列表。
如果未指定，则所有不等于
background的标签都被视为前景。foreground_prob¶ (float 或 TensorList of float, optional, default = 1.0) – 选择前景边界框的概率。
format¶ (str, optional, default = ‘anchor_shape’) –
数据返回的格式。
- 可能的选择有：
“anchor_shape”（默认）- 有两个输出：锚点和形状
“start_end” - 有两个输出：边界框的起始坐标和终止坐标（后一个坐标不包含在框内）
“box” - 有一个输出，其中包含连接的起始和终止坐标
ignore_class¶ (bool, optional, default = False) –
如果为 True，则以相同的概率选择所有对象，而与其所属的类别无关。否则，首先选择一个类别，然后从此类别中随机选择一个对象。
此参数与
classes、class_weights或output_class不兼容。注意
此标志仅影响选择区域的概率。它不会导致不同类别的区域合并。
k_largest¶ (int, optional) –
如果指定，则框按体积降序排序，并且仅考虑
k_largest个最大的框。如果
ignore_class为 True，则k_largest指的是所有框；否则，它指的是所选类别。output_class¶ (bool, optional, default = False) –
如果为 True，则会生成一个额外的输出，其中包含所选框所属类别的标签，如果所选框不是对象边界框，则包含背景标签。
- 当发生以下任何情况时，输出可能不是对象边界框：
样本是随机选择的（根据
foreground_prob）不作为前景框样本不包含前景对象
没有边界框满足所需的大小阈值。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
threshold¶ (int 或 list of int 或 TensorList of int, optional) –
要返回的边界框的每轴最小尺寸。
如果所选类别不包含任何满足此条件的边界框，则会拒绝该类别，并选择另一个类别。如果没有任何类别包含令人满意的框，则返回整个输入区域。
- __call__(__input, /, *, background=0, bytes_per_sample_hint=[0], cache_objects=False, class_weights=None, classes=None, foreground_prob=1.0, format='anchor_shape', ignore_class=False, k_largest=None, output_class=False, preserve=False, seed=-1, threshold=None, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.segmentation.SelectMasks(*, bytes_per_sample_hint=[0], preserve=False, reindex_masks=False, device=None, name=None)#
通过掩码 ID 选择多边形的子集。
该运算符需要三个输入，描述属于不同掩码 ID 的多个分割掩码多边形和所选掩码 ID 的列表。
每个样本可以包含属于不同掩码的多个多边形，并且每个多边形可以由任意数量的顶点（至少 3 个）组成。掩码多边形由输入
polygons和vertices描述，运算符生成输出polygons和vertices，其中仅存在与所选掩码关联的多边形。注意
polygons和vertices的格式与 COCOReader 生成的格式相同。示例
让我们假设以下输入掩码，其中使用符号坐标以获得更清晰的示例
polygons = [[0, 0, 3], [1, 3, 7], [2, 7, 10]] vertices = [[x0, y0], [x1, y1], [x2, y2], [x3, y3], [x4, y4], [x5, y5], [x6, y6], [x7, y7], [x8, y8], [x9, y9]]
示例 1：选择 id 为
1的单个掩码，保持原始 idmask_ids = [1], :paramref:`~nvidia.dali.ops.segmentation.SelectMasks.reindex_masks` = False out_polygons = [[1, 0, 4]] out_vertices = [[x3, y3], [x4, y4], [x5, y5], [x6, y6]]
示例 2：从三个掩码中选择两个，将掩码 id 替换为它们在
mask_ids输入中出现的索引mask_ids = [2, 0] reindex_masks = True out_polygons = [[0, 3, 6], [1, 0, 3]] out_vertices = [[x0, y0], [x1, y1], [x2, y2], [x7, y7], [x8, y8], [x9, y9]]
- 支持的后端
‘cpu’
- 关键字参数:
- __call__(__mask_ids, __polygons, __vertices, /, *, bytes_per_sample_hint=[0], preserve=False, reindex_masks=False, device=None, name=None)#
算子调用，用于图定义中。
- 参数:
__mask_ids¶ (int 的 1D TensorList) – 要选择的掩码的标识符列表。该列表不应包含重复项。
__polygons¶ (int 的 2D TensorList) –
多边形，由 3 列描述
[[mask_id0, start_vertex_idx0, end_vertex_idx0], [mask_id1, start_vertex_idx1, end_vertex_idx1], ..., [mask_idn, start_vertex_idxn, end_vertex_idxn],]
其中
mask_id是此多边形所属的掩码的标识符，[start_vertex_idx, end_vertex_idx)描述了属于此多边形的vertices中的索引范围。__vertices¶ (2D TensorList) –
以交错格式存储的顶点数据
[[x0, y0, ...], [x1, y1, ...], ... , [xn, yn, ...]]
运算符接受具有任意坐标数的顶点。
nvidia.dali.ops.transforms#
此模块中的所有运算符仅支持 CPU 设备，因为它们旨在作为命名关键字运算符参数的输入提供。有关更多详细信息，请查看相关的 pipeline 文档部分。
- class nvidia.dali.ops.transforms.Combine(*, bytes_per_sample_hint=[0], preserve=False, reverse_order=False, device=None, name=None)#
组合两个或多个仿射变换。
- 默认情况下，变换被组合，使得将结果变换应用于点等效于
按照列出的顺序应用输入变换。
- 示例：组合 [T1, T2, T3] 对于默认顺序等效于 T3(T2(T1(…)))，对于反向顺序等效于 T1(T2(T3(…)))
对于反向顺序。
此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未被使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认），则运算符的仿射变换将应用于输入变换。如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
- __call__(__input_0, __input_1, /, *__input_, bytes_per_sample_hint=[0], preserve=False, reverse_order=False, device=None, name=None)#
有关完整信息，请参阅
nvidia.dali.ops.transforms.Combine()类。
- class nvidia.dali.ops.transforms.Crop(*, absolute=False, bytes_per_sample_hint=[0], from_end=[1.0], from_start=[0.0], preserve=False, reverse_order=False, to_end=[1.0], to_start=[0.0], device=None, name=None)#
生成一个仿射变换矩阵，将参考坐标空间映射到另一个坐标空间。
此变换可用于在裁剪操作后调整坐标，以便
from_start点将映射到to_start，并且from_end将映射到to_end。如果将另一个变换矩阵作为输入传递，则运算符将变换应用于提供的矩阵。
注意
此运算符的输出可以直接馈送到
CoordTransform和WarpAffine运算符。此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
absolute¶ (bool, 可选, 默认 = False) – 如果设置为 true，则当 start > end 时，将交换起始坐标和结束坐标。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
from_end¶ (float 或 float 列表 或 float 的 TensorList, 可选, 默认 = [1.0]) –
原始坐标空间的上界。
注意
如果留空，则将假定为全 1 向量。如果提供单个值，它将被重复以匹配维度数
支持
per-frame输入。from_start¶ (float 或 float 列表 或 float 的 TensorList, 可选, 默认 = [0.0]) –
原始坐标空间的下界。
注意
如果留空，则将假定为全 0 向量。如果提供单个值，它将被重复以匹配维度数
支持
per-frame输入。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未被使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认），则运算符的仿射变换将应用于输入变换。如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
to_end¶ (float 或 float 列表 或 float 的 TensorList, 可选, 默认 = [1.0]) –
目标坐标空间的上界。
注意
如果留空，则将假定为全 1 向量。如果提供单个值，它将被重复以匹配维度数
支持
per-frame输入。to_start¶ (float 或 float 列表 或 float 的 TensorList, 可选, 默认 = [0.0]) –
目标坐标空间的下界。
注意
如果留空，则将假定为全 0 向量。如果提供单个值，它将被重复以匹配维度数
支持
per-frame输入。
- class nvidia.dali.ops.transforms.Rotation(*, angle=None, axis=None, bytes_per_sample_hint=[0], center=None, preserve=False, reverse_order=False, device=None, name=None)#
生成旋转仿射变换矩阵。
如果将另一个变换矩阵作为输入传递，则运算符将旋转应用于提供的矩阵。
如果提供了旋转轴，则维度数假定为 3；否则假定为 2。
注意
此运算符的输出可以直接馈送到
CoordTransform和WarpAffine运算符。此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
angle¶ (float 或 float 的 TensorList) –
角度，以度为单位。
支持
per-frame输入。axis¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
旋转轴（仅适用于 3D 变换）。
该向量不需要归一化，但必须具有非零长度。
反转向量等效于更改
angle的符号。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
center¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
旋转中心。
如果提供，则元素的数量应与变换的维度匹配。
支持
per-frame输入。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未被使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认），则运算符的仿射变换将应用于输入变换。如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
- class nvidia.dali.ops.transforms.Scale(*, bytes_per_sample_hint=[0], center=None, ndim=None, preserve=False, reverse_order=False, scale=None, device=None, name=None)#
生成缩放仿射变换矩阵。
如果将另一个变换矩阵作为输入传递，则运算符将缩放应用于提供的矩阵。
注意
此运算符的输出可以直接馈送到
CoordTransform和WarpAffine运算符。此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
center¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
缩放操作的中心。
如果提供，则元素的数量应与
scale参数的数量匹配。支持
per-frame输入。ndim¶ (int, 可选) –
维度数。
当无法推断维度数时，应提供此参数。例如，当
scale是标量值且没有输入变换时。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未被使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认），则运算符的仿射变换将应用于输入变换。如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
scale¶ (float 或 float 列表 或 float 的 TensorList) –
每个维度的缩放因子。
变换的维度数从此参数推断。
支持
per-frame输入。
- class nvidia.dali.ops.transforms.Shear(*, angles=None, bytes_per_sample_hint=[0], center=None, preserve=False, reverse_order=False, shear=None, device=None, name=None)#
生成剪切仿射变换矩阵。
如果将另一个变换矩阵作为输入传递，则运算符将剪切映射应用于提供的矩阵。
注意
此运算符的输出可以直接馈送到
CoordTransform和WarpAffine运算符。此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
angles¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
剪切角，以度为单位。
此参数与
shear互斥。对于 2D，
angles包含两个元素：angle_x、angle_y。对于 3D，
angles包含六个元素：angle_xy、angle_xz、angle_yx、angle_yz、angle_zx、angle_zy。剪切角转换为剪切因子，如下所示
shear_factor = tan(deg2rad(shear_angle))
注意
值的有效范围在 -90 度到 90 度之间。此参数与
shear互斥。如果提供，则变换的维度数从此参数推断。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
center¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
剪切操作的中心。
如果提供，则元素的数量应与变换的维度匹配。
支持
per-frame输入。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未被使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认），则运算符的仿射变换将应用于输入变换。如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
shear¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
剪切因子。
对于 2D，
shear包含两个元素：shear_x、shear_y。对于 3D，
shear包含六个元素：shear_xy、shear_xz、shear_yx、shear_yz、shear_zx、shear_zy。剪切因子值可以解释为沿第二轴移动时要在第一轴上应用的偏移量。
注意
此参数与
angles互斥。如果提供，则变换的维度数从此参数推断。支持
per-frame输入。
- class nvidia.dali.ops.transforms.Translation(*, bytes_per_sample_hint=[0], offset=None, preserve=False, reverse_order=False, device=None, name=None)#
生成平移仿射变换矩阵。
如果另一个变换矩阵作为输入传递，则运算符将平移应用于提供的矩阵。
注意
此运算符的输出可以直接馈送到
CoordTransform和WarpAffine运算符。此运算符允许序列输入。
- 支持的后端
‘cpu’
- 关键字参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
offset¶ (float or list of float or TensorList of float) –
平移向量。
变换的维度数从此参数推断。
支持
per-frame输入。preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
reverse_order¶ (bool, optional, default = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认），则运算符的仿射变换将应用于输入变换。如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
nvidia.dali.plugin.numba.experimental#
- class nvidia.dali.plugin.numba.experimental.NumbaFunction(run_fn, out_types, in_types, outs_ndim, ins_ndim, setup_fn=None, device='cpu', batch_processing=False, blocks=None, threads_per_block=None, **kwargs)#
调用 njit 编译的 Numba 函数。
run 函数应该是一个 Python 函数，可以在 Numba
nopython模式下编译。 接受单个输入并产生单个输出的函数应遵循以下定义def run_fn(out0, in0)
其中
out0和in0是输入和输出张量的 numpy 数组视图。 如果运算符配置为在批处理模式下运行，则数组的第一个维度是样本索引。请注意，该函数最多可以接受 6 个输入和 6 个输出。
此外，还有一个可选的 setup 函数，用于计算输出的形状，以便 DALI 可以为输出分配内存，其定义如下
def setup_fn(outs, ins)
setup 函数会针对整个批次调用一次。
outs、ins的第一个维度分别是输出/输入的数量。 第二个维度是样本索引。 例如，可以通过outs[1][0]访问第二个输出上的第一个样本。如果未提供 setup 函数，则输出形状和数据类型将与输入相同。
注意
此运算符是实验性的，其 API 可能会在不另行通知的情况下更改。
警告
当管道启用条件执行时，必须采取额外的步骤来防止
run_fn和setup_fn函数被 AutoGraph 重写。 有两种方法可以实现这一点在全局作用域（即
pipeline_def作用域之外）定义函数。如果函数是另一个“工厂”函数的结果，则工厂函数必须在 pipeline 定义函数之外定义，并使用
@do_not_convert进行装饰。
更多详细信息可以在
@do_not_convert文档中找到。示例 1
以下示例显示了一个简单的 setup 函数，该函数置换形状中维度的顺序。
def setup_change_out_shape(outs, ins): out0 = outs[0] in0 = ins[0] perm = [1, 0, 2] for sample_idx in range(len(out0)): for d in range(len(perm)): out0[sample_idx][d] = in0[sample_idx][perm[d]]
由于 setup 函数是针对整个批次运行的，因此我们需要迭代并单独置换每个样本的形状。 对于
shapes = [(10, 20, 30), (20, 10, 30)]，它将生成形状为shapes = [(20, 10, 30), (10, 20, 30)]的输出。此外，让我们提供 run 函数
def run_fn(out0, in0): for i in range(in0.shape[0]): for j in range(in0.shape[1]): out0[j, i] = in0[i, j]
运行函数可以按样本或按批次工作，具体取决于
batch_processing参数。按批次工作的 run 函数可能如下所示
def run_fn(out0_samples, in0_samples): for out0, in0 in zip(out0_samples, in0_samples): for i in range(in0.shape[0]): for j in range(in0.shape[1]): out0[j, i] = in0[i, j]
按样本工作的 run 函数可能如下所示
def run_fn(out0, in0): for i in range(in0.shape[0]): for j in range(in0.shape[1]): out0[j, i] = in0[i, j]
此算子允许序列输入并支持体积数据。
此算子将**不会**从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
batch_processing¶ (bool, optional, default = False) –
确定函数是每个批次调用一次，还是为批次中的每个样本单独调用。
当
batch_processing设置为True时，该函数处理整个批次。如果函数必须执行跨样本操作，并且如果可以重用大部分工作，则这是必要的。对于其他用例，指定 False 并使用每样本处理函数允许运算符并行处理样本。blocks¶ (int or list of int, optional) –
- 3 项列表，指定用于每个网格的块数，用于
执行 CUDA 内核
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
in_types¶ (DALIDataType or list of DALIDataType) – 输入的类型。
ins_ndim¶ (int or list of int) – 输入形状应具有的维度数。
out_types¶ (DALIDataType or list of DALIDataType) – 输出的类型。
outs_ndim¶ (int or list of int) – 输出形状应具有的维度数。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
run_fn¶ (object) – 要调用的函数。此函数必须在 Numba
nopython模式下工作。setup_fn¶ (object, optional) – 设置输出形状的设置函数。此函数在每个批次调用一次。此外，此函数必须在 Numba
nopython模式下工作。threads_per_block¶ (int or list of int, optional) –
- 3 项列表，指定每个线程数
用于执行 CUDA 内核的块
- __call__(*inputs, **kwargs)#
有关完整信息，请参阅
nvidia.dali.ops.NumbaFunction()类。
nvidia.dali.plugin.pytorch#
- class nvidia.dali.plugin.pytorch.TorchPythonFunction(function, num_outputs=1, device='cpu', batch_processing=False, **kwargs)#
执行在 Torch 张量上运行的函数。
此类类似于
nvidia.dali.fn.python_function()，但张量数据作为 PyTorch 张量处理。此算子允许序列输入并支持体积数据。
此算子将**不会**从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键字参数:
batch_processing¶ (bool, optional, default = True) – 确定函数是否将整个批次作为输入。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以字节/样本为单位。
如果指定，则驻留在 GPU 或分页锁定主机内存中的运算符输出将被预先分配，以容纳此大小的样本批次。
function¶ (object) –
定义算子功能的 Callable 对象。
警告
该函数不得持有对其使用的 Pipeline 的引用。如果持有，将形成对 Pipeline 的循环引用，并且 Pipeline 将永远不会被释放。
num_outputs¶ (int, optional, default = 1) – 输出的数量。
output_layouts¶ (layout str or list of layout str, optional) –
输出的 Tensor 数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则仅前几个输出设置了布局，其余输出未分配布局。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
Compose#
- class nvidia.dali.ops.Compose(op_list)#
返回一个元运算符，该运算符链接 op_list 中的操作。
返回值是一个可调用对象，当调用时，执行以下操作
op_list[n-1](op_list([n-2](... op_list[0](args))))
只有当列表中前一个运算符的所有输出都可以被下一个运算符直接处理时，运算符才能被组合。
下面的示例链式连接了一个图像解码器和一个具有随机正方形大小的 Resize 操作。
decode_and_resize对象可以像运算符一样被调用decode_and_resize = ops.Compose([ ops.decoders.Image(device="cpu"), ops.Resize(size=fn.random.uniform(range=400,500)), device="gpu") ]) files, labels = fn.readers.caffe(path=caffe_db_folder, seed=1) pipe.set_outputs(decode_and_resize(files), labels)
如果在 op_list 的中间存在从 CPU 到 GPU 的转换，如本例所示，
Compose会自动安排将数据复制到 GPU 内存。注意
这是一个实验性功能，如有更改，恕不另行通知。