操作符对象（旧版）#
在旧版本的 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)#
对音频信号进行重采样。
重采样是通过应用 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 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
ltrb¶ (bool，可选，默认值 = False) – 对于
ltrb为 True，对于xywh为 False。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.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，可选，默认值 = False) – 如果为 true，则输出可以包含重复和遗漏。
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
no_fixed_points¶ (bool，可选，默认值 = False) – 如果为 true，则输出排列不能包含不动点，即
out[i] != i。当批处理大小为 1 时，此参数将被忽略。preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
seed¶ (int，可选，默认值 = -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 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
horizontal¶ (int 或 int 的 TensorList，可选，默认值 = 1) – 翻转水平维度。
ltrb¶ (bool，可选，默认值 = False) – 对于
ltrb为 True，对于xywh为 False。preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
vertical¶ (int 或 int 的 TensorList，可选，默认值 = 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 中实现。输入必须作为以下张量提供
BBoxes包含表示为[l,t,r,b]的边界框。Labels包含每个边界框的相应标签。
结果是两个张量
EncodedBBoxes包含 M 编码的边界框，格式为[l,t,r,b]，其中 M 是锚框的数量。EncodedLabels包含每个编码框的相应标签。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
anchors¶ (float 或 float 列表) – 用于编码的锚框，浮点数列表采用
ltrb格式。bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
criteria¶ (float，可选，默认值 = 0.5) –
用于将边界框与锚框匹配的阈值 IoU。
该值需要在 0 和 1 之间。
means¶ (float 或 float 列表，可选，默认值 = [0.0, 0.0, 0.0, 0.0]) – 用于归一化的 [x y w h] 均值。
offset¶ (bool，可选，默认值 = False) – 返回归一化的偏移量
((encoded_bboxes*scale - anchors*scale) - mean) / stds在 EncodedBBoxes 中，它使用std和mean以及scale参数。preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
scale¶ (float，可选，默认值 = 1.0) – 在计算偏移量之前重新缩放框和锚框值（例如，返回到绝对值）。
stds¶ (float 或 float 列表，可选，默认值 = [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 或 float 的 TensorList，可选，默认值 = 1.0) –
亮度乘数。
支持
per-frame输入。brightness_shift¶ (float 或 float 的 TensorList，可选，默认值 = 0.0) –
亮度偏移。
对于有符号类型，1.0 表示该类型可以表示的最大正值。
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType，可选) –输出数据类型。
如果未设置，则使用输入类型。
preserve¶ (bool，可选，默认值 = 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 或 float 的 TensorList，可选，默认值 = 1.0) –
亮度乘数。
支持
per-frame输入。brightness_shift¶ (float 或 float 的 TensorList，可选，默认值 = 0.0) –
亮度偏移。
对于有符号类型，1.0 表示该类型可以表示的最大正值。
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
contrast¶ (float 或 float 的 TensorList，可选，默认值 = 1.0) –
对比度乘数，其中 0.0 产生均匀的灰色。
支持
per-frame输入。contrast_center¶ (float 或 float 的 TensorList，可选，默认值 = 0.5) –
不受对比度影响的强度级别。
这是当对比度为零时所有像素都采用的值。如果未设置，则使用输入类型正值范围的一半（或
float的 0.5）。支持
per-frame输入。dtype¶ (
nvidia.dali.types.DALIDataType，可选) –输出数据类型。
如果未设置，则使用输入类型。
preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
- class 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 中，所有 reader 都被移动到了专用的
readers子模块中，并被重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.coco()的旧版别名。
- class 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 中，所有 reader 都被移动到了专用的
readers子模块中，并被重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.caffe2()的旧版别名。
- class 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 中，所有 reader 都被移动到了专用的
readers子模块中，并被重命名以遵循通用模式。这是一个占位符运算符，具有相同的功能，以实现向后兼容性。用于
readers.caffe()的旧版别名。
- class nvidia.dali.ops.Cast(*, bytes_per_sample_hint=[0], dtype=None, preserve=False, device=None, name=None)#
将张量转换为不同的类型。
此运算符允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType) – 输出数据类型。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
- class 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()类。
- class 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 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
- __call__(__input_0, /, *__input_, axis=0, axis_name=None, bytes_per_sample_hint=[0], preserve=False, device=None, name=None)#
有关完整信息，请参见
nvidia.dali.ops.Cat()类。
- class 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 (true) 的概率由
probability参数确定。生成的数据的形状可以通过
shape参数显式指定，或者选择与输入形状匹配（如果提供输入）。如果两者都不存在，则每个样本生成一个值。- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行舍入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
probability¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) – 值 1 的概率。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 list of int 或 TensorList of int, 可选) – 输出数据的形状。
- 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, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
image_type¶ (
nvidia.dali.types.DALIImageType) – 输入图像的色彩空间。output_type¶ (
nvidia.dali.types.DALIImageType) – 输出图像的色彩空间。preserve¶ (bool, 可选, 默认值 = 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, 可选, 默认值 = 1.0) –
亮度变化因子。
值必须是非负数。
示例值
0 - 黑色图像。
1 - 无变化。
2 - 亮度增加两倍。
支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
contrast¶ (float 或 TensorList of float, 可选, 默认值 = 1.0) –
对比度变化因子。
值必须是非负数。
示例值
0 - 均匀灰色图像。
1 - 无变化。
2 - 亮度增加两倍。
支持
per-frame输入。dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
如果未设置，则使用输入类型。
hue¶ (float 或 TensorList of float, 可选, 默认值 = 0.0) –
色调变化，单位为度。
支持
per-frame输入。image_type¶ (
nvidia.dali.types.DALIImageType, 可选, 默认值 = DALIImageType.RGB) – 输入和输出图像的色彩空间。preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未被使用。
saturation¶ (float 或 TensorList of float, 可选, 默认值 = 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, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
contrast¶ (float 或 TensorList of float, 可选, 默认值 = 1.0) –
对比度乘数，其中 0.0 产生均匀的灰色。
支持
per-frame输入。contrast_center¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) –
不受对比度影响的强度级别。
这是当对比度为零时所有像素都采用的值。如果未设置，则使用输入类型正值范围的一半（或
float的 0.5）。支持
per-frame输入。dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
如果未设置，则使用输入类型。
preserve¶ (bool, 可选, 默认值 = 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, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
center_x¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) – 水平轴上的翻转中心。
center_y¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) – 垂直轴上的翻转中心。
center_z¶ (float 或 TensorList of float, 可选, 默认值 = 0.5) – 深度轴上的翻转中心。
flip_x¶ (int 或 TensorList of int, 可选, 默认值 = 1) – 翻转水平 (x) 坐标。
flip_y¶ (int 或 TensorList of int, 可选, 默认值 = 0) – 翻转垂直 (y) 坐标。
flip_z¶ (int 或 TensorList of int, 可选, 默认值 = 0) – 翻转深度 (z) 坐标。
layout¶ (layout str, 可选, 默认值 = ‘’) –
确定输入中坐标的顺序。
字符串应包含以下字符
“x”（水平坐标），
“y”（垂直坐标），
“z”（深度坐标），
注意
如果留空，则根据维度数量，假定值为“x”、“xy”或“xyz”。
preserve¶ (bool, 可选, 默认值 = 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, 可选) –
用于变换输入向量的矩阵。
如果未指定，则使用单位矩阵。
矩阵
M不需要是方阵 - 如果不是，则输出向量的分量数将等于M中的行数。如果提供标量值，则假定
M是对角线上具有该值的方阵。然后假定矩阵的大小与输入向量中的分量数匹配。支持
per-frame输入。MT¶ (float 或 list of float 或 TensorList of float, 可选) –
为此参数提供标量值等效于为 M 提供相同的标量值并保持 T 未指定。
列数必须比输入中的分量数多一个。此参数与
M和T互斥。支持
per-frame输入。T¶ (float 或 list of float 或 TensorList of float, 可选) –
平移向量。
如果未指定，则不应用平移，除非使用 MT 参数。
此向量的分量数必须与矩阵
M中的行数匹配。如果提供标量值，则该值将广播到T的所有分量，并且选择分量数以匹配M中的行数。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.FLOAT) –输出坐标的数据类型。
如果使用整数类型，则输出值四舍五入到最接近的整数并钳制到此类型的动态范围。
preserve¶ (bool, 可选, 默认值 = 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 或 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 或 float 的 TensorList，可选，默认值 = 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，可选，默认值 = 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，可选，默认值 = 0.0) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
支持的类型：
FLOAT、FLOAT16和UINT8。如果未设置，则使用输入类型。
fill_values¶ (float 或 float 列表，可选，默认值 = [0.0]) –
确定填充值，并且仅当
out_of_bounds_policy设置为 “pad” 时才相关。如果提供标量值，它将用于所有通道。如果提供多个值，则值的数量和通道的数量必须相同（输出切片中布局中维度
C的范围）。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 已不再使用，并将在未来的版本中移除。
out_of_bounds_policy¶ (str，可选，默认值 = ‘error’) –
确定当对输入进行越界区域切片时的策略。
以下是支持值的列表
"error"(默认值)：尝试在输入边界之外进行切片将产生错误。"pad"：将根据需要使用零或使用fill_values参数指定的任何其他值来填充输入。"trim_to_shape"：切片窗口将被裁剪到输入的边界。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool，可选，默认值 = False) – 即使操作符的输出未使用，也阻止其从图中移除。
rounding¶ (str，可选，默认值 = ‘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 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
crop¶ (float 或 float 列表 或 float 的 TensorList，可选) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 float 的 TensorList，可选，默认值 = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w、crop_h和crop_d必须一起指定。为crop_w、crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 float 的 TensorList，可选，默认值 = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 float 的 TensorList，可选，默认值 = 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，可选，默认值 = 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，可选，默认值 = 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，可选，默认值 = 0.0) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选，默认值 = DALIDataType.FLOAT) –输出数据类型。
支持的类型：
FLOAT、FLOAT16、INT8、UINT8。fill_values¶ (float 或 float 列表，可选，默认值 = [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’) – 输出的张量数据布局。
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()函数获得。在这种情况下，可以将 synchronize_stream 标志设置为 False。警告
此操作符与 TensorFlow 集成不兼容。
此运算符允许序列输入并支持体积数据。
此操作符将不会从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
batch_processing¶ (bool，可选，默认值 = False) –
确定函数是每个批次调用一次，还是为批次中的每个样本单独调用。
如果设置为 True，该函数将接收其参数作为 DLPack 张量列表。
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
function¶ (object) –
定义操作符功能的可调用对象。
警告
该函数不得持有对其使用的 pipeline 的引用。如果持有，将形成对 pipeline 的循环引用，并且 pipeline 将永远不会被释放。
num_outputs¶ (int，可选，默认值 = 1) – 输出数量。
output_layouts¶ (layout str 或 layout str 列表，可选) –
输出的张量数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 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’) –
用于锚点和形状参数的维度顺序，如布局中所述。
例如，axis_names=”HW” 表示 anchor 和 shape 中的坐标指的是维度 H（高度）和 W（宽度），顺序如此。
注意
axis_name*s 的优先级高于 *axes.
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
centered_anchor¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则锚点指的是区域的中心而不是左上角。
这会在指定的 anchor 处产生居中的擦除区域。
fill_value¶ (float 或 float 列表 或 float 的 TensorList, 可选, 默认值 = [0.0]) –
用于填充擦除区域的值。
可以指定为一个值（例如，0）或多通道值（例如，(200, 210, 220)）。如果提供了多通道填充值，则输入布局应包含通道维度
C。normalized¶ (bool, 可选, 默认值 = False) –
确定是否应将锚点和形状参数解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
分别为 normalized_shape 和 normalized_anchor 参数提供值是互斥的。
normalized_anchor¶ (bool, 可选, 默认值 = False) –
确定是否应将锚点参数解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
为 normalized 提供值是互斥的。
normalized_shape¶ (bool, 可选, 默认值 = False) –
确定是否应将形状参数解释为归一化坐标（范围 [0.0, 1.0]）或绝对坐标。
为 normalized 提供值是互斥的。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
shape¶ (float 或 float 列表 或 float 的 TensorList, 可选, 默认值 = []) –
擦除区域的形状或维度值。
仅应提供由 axis_names 或 axes 指定的相关维度的坐标。
- __call__(__input, /, *, 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)#
要在图形定义中使用的操作符调用。
- 参数:
__input¶ (TensorList) – 运算符的输入。
- class nvidia.dali.ops.ExpandDims(*, axes=None, bytes_per_sample_hint=[0], new_axis_names='', preserve=False, device=None, name=None)#
向数据形状插入 extent 为 1 的新维度。
新维度插入到
axes指定的位置。如果提供了
new_axis_names，则新的维度名称将插入到数据布局中，位置由axes指定。如果未提供new_axis_names，则输出数据布局将为空。”此运算符允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
axes¶ (int 或 int 列表 或 int 的 TensorList) – 插入新维度的索引。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
new_axis_names¶ (layout str, 可选, 默认值 = ‘’) –
数据布局中新维度的名称。
new_axis_names的长度必须与axes的长度匹配。如果未提供参数，则布局将被清除。preserve¶ (bool, 可选, 默认值 = 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 tensor (CPU 或 GPU)
CuPy array (GPU)
实现
__cuda_array_interface__的对象DALI Tensor 对象
批次数据源必须生成完整的数据批次。这可以通过向数组添加新的最外层维度或返回数组列表来实现（在这种情况下，它们的大小可以不同，但必须具有相同的秩和元素类型）。批次数据源还可以生成 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，但在后续调用时会重新启动迭代。
end of data is reached; this is the default behavior *
"quiet"orTrue- the data is repeated indefinitely, *"raise"- when the end of data is reached,StopIterationis raised, but the iteration is restarted on subsequent call.此标志要求
source是一个集合，例如，一个可迭代对象，其中iter(source)在每次调用时返回一个新的迭代器，或者是一个生成器函数。在后一种情况下，当请求的数据量超过函数生成的数据量时，将再次调用生成器函数。将
"raise"与 DALI 迭代器一起使用可以创建 epoch 的概念。name¶ (str, optional) –
数据节点的名称。
当使用调用
feed_input提供数据时使用，如果数据由source提供，则可以省略。layout¶ (layout str 或其列表/元组, optional) –
如果提供，则设置数据的布局。
当
num_outputs > 1时，布局可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs 个，则仅前几个输出设置了布局，其余输出未设置布局。dtype¶ (nvidia.dali.types.DALIDataType 或其列表/元组, optional) –
输入数据类型。
当
num_outputs > 1时，dtype可以是列表，其中包含每个输出的不同值。运算符将验证获取的数据是否为提供的类型。如果省略了参数或传递了
DALIDataType.NO_TYPE，则运算符将从提供的数据中推断类型。从 DALI 2.0 开始，此参数将是必需的。
ndim¶ (int 或 list/tuple thereof, optional) –
输入数据中的维度数。
当
num_outputs > 1时，ndim可以是列表，其中包含每个输出的不同值。将根据此值验证提供给运算符的数据的维度。如果提供了
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 会将用户内存直接传递给管道，而不是复制它。用户有责任保持缓冲区处于活动状态且未修改，直到管道使用它为止。
在相关迭代的输出被使用后，可以再次修改或释放缓冲区。实际上，这发生在 Pipeline 的
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（接受参数并返回批次）是应接收 class:~nvidia.dali.types.BatchInfo 实例还是仅接收表示迭代次数的整数。如果设置为 False（默认值），则仅传递整数。如果source不可调用，不接受参数或batch设置为 False，则设置此标志无效。parallel¶ (bool, optional, default = False) –
如果设置为 True，则相应的管道将启动 Python 工作进程池以并行运行回调。您可以通过将
py_num_workers传递到管道的构造函数中来指定工作进程的数量。当
parallel设置为 True 时，source返回的样本必须是 NumPy/MXNet/PyTorch CPU 数组或 TensorCPU 实例。可接受的数据源取决于为
batch参数指定的值。如果
batch设置为False，则source必须是- 可调用对象（函数或具有
__call__方法的对象），该对象接受 正好一个参数（
SampleInfo实例，表示请求样本的索引）。
- 可调用对象（函数或具有
如果
batch设置为True，则source可以是- 接受正好一个参数的可调用对象（
BatchInfo 实例或整数 - 有关详细信息，请参阅
batch_info）
- 接受正好一个参数的可调用对象（
可迭代对象，
生成器函数。
警告
无论
batch值如何，可调用对象都应该是无状态的 - 它们应该仅根据SampleInfo/BatchInfo实例或批次中的索引来生成请求的样本或批次，以便它们可以在多个工作进程中并行运行。source回调在到达数据末尾时必须引发StopIteration。请注意，由于预取，回调可能会在数据集末尾之后的几次迭代中被调用 - 请确保在这种情况下始终如一地引发StopIteration。警告
当管道启用条件执行时，必须采取其他步骤来防止
source被 AutoGraph 重写。有两种方法可以实现此目的在全局作用域（即
pipeline_def作用域之外）定义函数。
2. 如果函数是另一个“工厂”函数的结果，则工厂函数必须在管道定义函数外部定义，并使用
@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将检测到在前一个管道运行和当前管道运行之间没有馈入新数据，并将使用最近的数据自行重新馈送。仅在“推送”模式下，即当用户通过调用
feed_input主动提供数据时，将repeat_last设置为 True 才有意义。启用此选项与指定source不兼容，这会使external_source在“拉取”模式下运行。prefetch_queue_depth¶ (int, optional, default = 1) – 当在
parallel=True模式下运行时，指定要预先计算并存储在内部缓冲区中的批次数量，否则将忽略此参数。bytes_per_sample_hint¶ (int, optional, default = None) –
如果在
parallel=True模式下指定，则该值在计算工作进程用于将并行外部数据源输出传递到管道的共享内存槽的初始容量时用作提示。在非并行模式下，将忽略此参数。设置足够大的值以容纳传入数据可以防止 DALI 在管道运行时重新分配共享内存。此外，手动提供提示可以防止 DALI 高估必要的共享内存容量。
该值必须为正整数。请注意，共享内存中的样本附带一些内部元数据，因此，对共享内存的实际需求略高于外部数据源生成的二进制数据的大小。实际元数据大小取决于许多因素，例如，可能会在 Python 或 DALI 版本之间更改，恕不另行通知。
请参阅管道的
external_source_shm_statistics以检查为管道的并行外部数据源生成的数据分配了多少共享内存。
- __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 或 iterable) –
数据源。
当管道需要下一个迭代的输入时，将轮询数据源（通过调用
source()或next(source)）。根据 num_outputs 的值，数据源可以提供一个或多个数据项。数据项可以是整个批次（默认），也可以是单个批次条目（当batch==False时）。如果未设置 num_outputs，则期望source返回一个项目（批次或样本）。如果指定了此值（即使其值为 1），则期望数据为元组或列表，其中每个元素对应于 external_source 的相应返回值。数据样本必须是以下兼容的数组类型之一
NumPy ndarray (CPU)
MXNet ndarray (CPU)
PyTorch tensor (CPU 或 GPU)
CuPy array (GPU)
实现
__cuda_array_interface__的对象DALI Tensor 对象
批次数据源必须生成完整的数据批次。这可以通过向数组添加新的最外层维度或返回数组列表来实现（在这种情况下，它们的大小可以不同，但必须具有相同的秩和元素类型）。批次数据源还可以生成 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，但在后续调用时会重新启动迭代。
end of data is reached; this is the default behavior *
"quiet"orTrue- the data is repeated indefinitely, *"raise"- when the end of data is reached,StopIterationis raised, but the iteration is restarted on subsequent call.此标志要求
source是一个集合，例如，一个可迭代对象，其中iter(source)在每次调用时返回一个新的迭代器，或者是一个生成器函数。在后一种情况下，当请求的数据量超过函数生成的数据量时，将再次调用生成器函数。将
"raise"与 DALI 迭代器一起使用可以创建 epoch 的概念。name¶ (str, optional) –
数据节点的名称。
当使用调用
feed_input提供数据时使用，如果数据由source提供，则可以省略。layout¶ (layout str 或其列表/元组, optional) –
如果提供，则设置数据的布局。
当
num_outputs > 1时，布局可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs 个，则仅前几个输出设置了布局，其余输出未设置布局。dtype¶ (nvidia.dali.types.DALIDataType 或其列表/元组, optional) –
输入数据类型。
当
num_outputs > 1时，dtype可以是列表，其中包含每个输出的不同值。运算符将验证获取的数据是否为提供的类型。如果省略了参数或传递了
DALIDataType.NO_TYPE，则运算符将从提供的数据中推断类型。从 DALI 2.0 开始，此参数将是必需的。
ndim¶ (int 或 list/tuple thereof, optional) –
输入数据中的维度数。
当
num_outputs > 1时，ndim可以是列表，其中包含每个输出的不同值。将根据此值验证提供给运算符的数据的维度。如果提供了
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 会将用户内存直接传递给管道，而不是复制它。用户有责任保持缓冲区处于活动状态且未修改，直到管道使用它为止。
在相关迭代的输出被使用后，可以再次修改或释放缓冲区。实际上，这发生在 Pipeline 的
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（接受参数并返回批次）是应接收 class:~nvidia.dali.types.BatchInfo 实例还是仅接收表示迭代次数的整数。如果设置为 False（默认值），则仅传递整数。如果source不可调用，不接受参数或batch设置为 False，则设置此标志无效。parallel¶ (bool, optional, default = False) –
如果设置为 True，则相应的管道将启动 Python 工作进程池以并行运行回调。您可以通过将
py_num_workers传递到管道的构造函数中来指定工作进程的数量。当
parallel设置为 True 时，source返回的样本必须是 NumPy/MXNet/PyTorch CPU 数组或 TensorCPU 实例。可接受的数据源取决于为
batch参数指定的值。如果
batch设置为False，则source必须是- 可调用对象（函数或具有
__call__方法的对象），该对象接受 正好一个参数（
SampleInfo实例，表示请求样本的索引）。
- 可调用对象（函数或具有
如果
batch设置为True，则source可以是- 接受正好一个参数的可调用对象（
BatchInfo 实例或整数 - 有关详细信息，请参阅
batch_info）
- 接受正好一个参数的可调用对象（
可迭代对象，
生成器函数。
警告
无论
batch值如何，可调用对象都应该是无状态的 - 它们应该仅根据SampleInfo/BatchInfo实例或批次中的索引来生成请求的样本或批次，以便它们可以在多个工作进程中并行运行。source回调在到达数据末尾时必须引发StopIteration。请注意，由于预取，回调可能会在数据集末尾之后的几次迭代中被调用 - 请确保在这种情况下始终如一地引发StopIteration。警告
当管道启用条件执行时，必须采取其他步骤来防止
source被 AutoGraph 重写。有两种方法可以实现此目的在全局作用域（即
pipeline_def作用域之外）定义函数。
2. 如果函数是另一个“工厂”函数的结果，则工厂函数必须在管道定义函数外部定义，并使用
@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将检测到在前一个管道运行和当前管道运行之间没有馈入新数据，并将使用最近的数据自行重新馈送。仅在“推送”模式下，即当用户通过调用
feed_input主动提供数据时，将repeat_last设置为 True 才有意义。启用此选项与指定source不兼容，这会使external_source在“拉取”模式下运行。prefetch_queue_depth¶ (int, optional, default = 1) – 当在
parallel=True模式下运行时，指定要预先计算并存储在内部缓冲区中的批次数量，否则将忽略此参数。bytes_per_sample_hint¶ (int, optional, default = None) –
如果在
parallel=True模式下指定，则该值在计算工作进程用于将并行外部数据源输出传递到管道的共享内存槽的初始容量时用作提示。在非并行模式下，将忽略此参数。设置足够大的值以容纳传入数据可以防止 DALI 在管道运行时重新分配共享内存。此外，手动提供提示可以防止 DALI 高估必要的共享内存容量。
该值必须为正整数。请注意，共享内存中的样本附带一些内部元数据，因此，对共享内存的实际需求略高于外部数据源生成的二进制数据的大小。实际元数据大小取决于许多因素，例如，可能会在 Python 或 DALI 版本之间更改，恕不另行通知。
请参阅管道的
external_source_shm_statistics以检查为管道的并行外部数据源生成的数据分配了多少共享内存。
- 类 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, 可选, 默认值 = False) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
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) –
裁剪窗口宽度（以像素为单位）。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
必须与输入类型相同或为
float。如果未设置，则使用输入类型。interp_type¶ (
nvidia.dali.types.DALIInterpType或 TensorList ofnvidia.dali.types.DALIInterpType, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter为缩小和放大指定不同的滤波。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或 TensorList ofnvidia.dali.types.DALIInterpType, 可选, 默认值 = 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或 TensorList ofnvidia.dali.types.DALIInterpType, 可选, 默认值 = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, 可选, 默认值 = 32) – 内核调用中处理的最大图像数量。
mirror¶ (int 或 TensorList of int, 可选, 默认值 = 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 或 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 或 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 或 float 列表或 TensorList of float, 可选) –
输入感兴趣区域 (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 列表或 TensorList of float, 可选) –
期望的输出尺寸。
必须是列表/元组，每个空间维度一个条目，不包括视频帧和通道。 维度为 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 中，所有 reader 都被移动到了专用的
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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
depthwise¶ (int 或 TensorList of int, optional, default = 0) – 在深度方向翻转维度。
horizontal¶ (int 或 TensorList of int, optional, default = 1) – 在水平方向翻转维度。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
vertical¶ (int 或 TensorList of int, optional, default = 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 或 float 的 TensorList, optional, default = 1.0) –
饱和度乘数。
支持
per-frame输入。value¶ (float 或 float 的 TensorList, 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 或 float 的 TensorList, 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, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
fill_value¶ (float, optional, default = 0.0) – 用于填充的颜色值。
interp_type¶ (
nvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_NN) – 使用的插值类型。mask¶ (int 或 int 的 TensorList, optional, default = 1) –
确定是否将此增强应用于输入图像。
以下是这些值：
0：不应用此变换。
1：应用此变换。
nDegree¶ (int, optional, default = 2) – 每个像素在
[-nDegree/2, nDegree/2]范围内移动随机量preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
- class nvidia.dali.ops.JpegCompressionDistortion(*, bytes_per_sample_hint=[0], preserve=False, quality=50, device=None, name=None)#
向 RGB 图像引入 JPEG 压缩伪影。
JPEG 是一种有损压缩格式，它利用自然图像和人类视觉系统的特性来实现高压缩率。信息损失源于以低于亮度的空间分辨率对颜色信息进行采样，以及用较低的有效位深度表示图像的高频分量。转换为频域和量化独立应用于 8x8 像素块，这会在块边界引入额外的伪影。
此操作通过对输入进行转换来生成图像，该转换模拟具有给定
quality因子的 JPEG 压缩，然后进行解压缩。此运算符允许序列输入。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未被使用。
quality¶ (int 或 int 的 TensorList, optional, default = 50) –
JPEG 压缩质量，从 1（最低质量）到 100（最高质量）。
任何超出 1-100 范围的值都将被钳制。
- 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, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
支持的类型：FLOAT。如果未设置，则使用输入类型。
normalized_kernel¶ (bool, optional, default = False) – 如果设置为 True，则自动缩放偏导数核。如果指定了
scale，则必须为 False。preserve¶ (bool, optional, default = False) – 即使算子的输出未使用，也阻止从图中删除该算子。
scale¶ (float 或 list of float 或 TensorList of float, optional, default = [1.0]) –
手动缩放偏导数的因子。
支持
per-frame输入。smoothing_size¶ (int 或 list of int 或 TensorList of int, optional) –
卷积中使用的平滑窗口的大小。
平滑大小必须为奇数，且介于 1 到 23 之间。
支持
per-frame输入。window_size¶ (int 或 list of int 或 TensorList of int, optional, default = [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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
default_value¶ (float, optional, default = 0.0) – 表中不存在的键的默认输出值。
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) – 输出数据类型。keys¶ (int 或 list of int, optional, default = []) –
查找表中的输入值（键）列表。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool, optional, default = False) – 即使算子的输出未使用，也阻止从图中删除该算子。
values¶ (float 或 list of float, optional, default = []) –
- 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, optional, default = 0) –
将应用变换的轴。
如果未提供值，将使用最外层维度。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dct_type¶ (int, optional, default = 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, optional, default = 0.0) –
倒谱滤波系数，也称为提升系数。
如果提升系数大于 0，则 MFCC 将根据以下公式进行缩放
MFFC[i] = MFCC[i] * (1 + sin(pi * (i + 1) / lifter)) * (lifter / 2)
n_mfcc¶ (int, optional, default = 20) – MFCC 系数的数量。
normalize¶ (bool, optional, default = False) –
如果设置为 True，则 DCT 使用正交归一化基。
注意
当 dct_type=1 时，不支持归一化。
preserve¶ (bool, optional, default = 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 中，所有 reader 都被移动到了专用的
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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
freq_high¶ (float, optional, default = 0.0) –
最大频率。
如果未提供此值，则使用
sample_rate/2。freq_low¶ (float, optional, default = 0.0) – 最小频率。
mel_formula¶ (str, optional, default = ‘slaney’) –
确定用于将频率从赫兹转换为梅尔以及从梅尔转换为赫兹的公式。
梅尔尺度是音调的感知尺度，因此没有单一公式。
支持的值包括
slaney，它遵循 Slaney 的 MATLAB Auditory Modelling Work 行为。此公式在 1 KHz 以下是线性的，在此值以上是对数的。该实现与 Librosa 的默认实现一致。htk，它遵循 O'Shaughnessy 书中的公式m = 2595 * log10(1 + (f/700))。此值与 Hidden Markov Toolkit (HTK) 的实现一致。
nfilter¶ (int, optional, default = 128) – 梅尔滤波器的数量。
normalize¶ (bool, optional, default = True) –
确定是否通过其频带宽度来归一化三角形滤波器权重。
如果设置为 True，则滤波器函数的积分为 1。
如果设置为 False，则滤波器函数的峰值为 1。
preserve¶ (bool, optional, default = False) – 即使算子的输出未使用，也阻止从图中删除该算子。
sample_rate¶ (float, optional, default = 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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) – 输出数据类型。如果未设置，则使用输入类型。in_anchors¶ (int 或 TensorList of int, optional) –
源区域左上角的绝对坐标。
锚点表示为 2D 张量，其中第一维度等于粘贴区域的数量，第二维度为 2（表示高度和宽度范围）。
如果既未提供
in_anchors也未提供in_anchors_rel，则所有锚点均为零。支持
per-frame输入。in_anchors_rel¶ (float 或 TensorList of float, optional) –
源区域左上角的相对坐标。
该参数的工作方式与
in_anchors类似，但值应为 [0, 1] 范围内的浮点数，描述相对于输入样本形状的锚点位置。支持
per-frame输入。in_ids¶ (int 或 list of int 或 TensorList of int, optional) –
从中粘贴数据的输入的索引。
如果指定，则该算子接受正好一个批次作为输入。
out_anchors¶ (int 或 TensorList of int, optional) –
粘贴区域在输出画布中左上角的绝对坐标。
锚点表示为 2D 张量，其中第一维度等于粘贴区域的数量，第二维度为 2（表示高度和宽度范围）。
如果既未提供
out_anchors也未提供out_anchors_rel，则所有锚点均为零，这使得所有粘贴区域都从输出画布的左上角开始。支持
per-frame输入。out_anchors_rel¶ (float 或 TensorList of float, optional) –
粘贴区域在输出画布中左上角的相对坐标。
工作方式与
out_anchors参数类似，但值应为 [0, 1] 范围内的浮点数，描述相对于输出画布大小的粘贴区域左上角。支持
per-frame输入。output_size¶ (int 或 list of int 或 TensorList of int, optional) –
一个元组 (H, W)，描述输出形状（即输出粘贴的画布大小）。
如果算子使用统一形状的输入运行，则可以省略。在这种情况下，相同的形状将用作画布大小。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
shapes¶ (int 或 TensorList of int, optional) –
粘贴区域的形状。
形状表示为 2D 张量，其中第一维度等于粘贴区域的数量，第二维度为 2（表示高度和宽度范围）。
如果既未提供
shapes也未提供shapes_rel，则会计算形状，使区域从输入锚点跨越到输入图像的末尾。支持
per-frame输入。shapes_rel¶ (float 或 TensorList of float, optional) –
粘贴区域的相对形状。
工作方式与 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 中，所有 reader 都被移动到了专用的
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”实现本身不会增加任何性能优势，但为了使管道中前面的操作能够在 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参数都不存在，则通过比较输入形状与 mean/stddev 参数的形状来推断缩减轴的集合，但对于批次中的所有张量，缩减轴的集合必须相同。以下是一些有效参数组合的示例
维度 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 函数应该是一个可以在 Numba
nopython模式下编译的 Python 函数。 接受单个输入并产生单个输出的函数应遵循以下定义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作用域之外）定义函数。如果函数是另一个“工厂”函数的结果，则工厂函数必须在管道定义函数之外定义，并使用
@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 或 list of int, optional) –
- 3 项列表，指定每个网格的块数，用于
执行 CUDA 内核
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
in_types¶ (DALIDataType 或 list of DALIDataType) – 输入的类型。
ins_ndim¶ (int 或 list of int) – 输入形状应具有的维度数。
out_types¶ (DALIDataType 或 list of DALIDataType) – 输出的类型。
outs_ndim¶ (int 或 list of int) – 输出形状应具有的维度数。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
run_fn¶ (object) – 要调用的函数。 此函数必须在 Numba
nopython模式下工作。setup_fn¶ (object, optional) – 设置输出形状的 Setup 函数。 此函数每个批次调用一次。 此外，此函数必须在 Numba
nopython模式下工作。threads_per_block¶ (int 或 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 中，所有 reader 都被移动到了专用的
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 或 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.DALIImageType, optional, default = DALIImageType.RGB) – 输入颜色空间（RGB、BGR 或 GRAY）。output_format¶ (int) –
警告
参数 output_format 是
output_grid的已弃用的别名。 请改用output_grid。output_grid¶ (int, optional, default = 4) –
设置输出矢量场的网格大小。
此运算符生成比输入像素更粗糙分辨率的运动矢量场。 此参数指定与一个运动矢量相对应的像素网格单元的大小。 例如，值 4 将为每个 4x4 像素块生成一个运动矢量。 因此，要将光流与
output_grid为 4 的参数一起使用以重采样全分辨率图像，则在不缩放矢量量的情况下对流场进行上采样。注意
目前，Ampere 仅支持 1、2 和 4，Turing 仅支持 4。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
preset¶ (float, optional, default = 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 or list of int or TensorList of int, optional, default = []) –
如果指定，则此参数确定由
axes或axis_names指定的维度上的对齐方式。axis = axes[i]上的范围将调整为align[i]的倍数。如果提供整数值，则对齐限制将应用于所有填充轴。
要仅使用对齐，即没有任何默认或显式填充行为，请将指定轴的最小
shape设置为 1。axes¶ (int or list of int or TensorList of int, optional, default = []) –
批次样本将在其上填充的轴的索引。
负值被解释为从后面计数维度。 有效范围：
[-ndim, ndim-1]，其中 ndim 是输入数据中的维度数。axis_names和axes参数是互斥的。 如果axes和axis_names为空，或未提供，则输出将在所有轴上填充。axis_names¶ (layout str, optional, default = ‘’) –
批次样本将在其上填充的轴的名称。
axis_names和axes参数是互斥的。 如果axes和axis_names为空，或未提供，则输出将在所有轴上填充。bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
fill_value¶ (float or TensorList of float, optional, default = 0.0) – 用于填充批次的值。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
shape¶ (int or list of int or TensorList of int, optional, default = []) –
由
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)#
将输入图像粘贴到更大的画布上，其中画布大小等于
input size * ratio。- 支持的后端
‘gpu’
- 关键词参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
fill_value¶ (int or list of 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’
- 关键词参数:
- 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 或 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 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType，可选，默认值 = DALIDataType.FLOAT) – 输出的数据类型。preemph_coeff¶ (float 或 float 的 TensorList，可选，默认值 = 0.97) – 预加重系数
coeff。preserve¶ (bool，可选，默认值 = False) – 即使运算符的输出未使用，也防止从图中删除该运算符。
- class nvidia.dali.ops.PythonFunction(function, num_outputs=1, device='cpu', batch_processing=False, **kwargs)#
执行 Python 函数。
此运算符可用于在 DALI 管道中执行自定义 Python 代码。对于 CPU 运算符，该函数从 DALI 接收数据作为 NumPy 数组；对于 GPU 运算符，则接收 CuPy 数组。预期以相同格式返回结果。对于更通用的数据格式，请参阅
nvidia.dali.fn.dl_tensor_python_function()。该函数不应修改输入张量。警告
此操作符与 TensorFlow 集成不兼容。
警告
当管道启用条件执行时，必须采取其他步骤以防止 function 被 AutoGraph 重写。有两种方法可以实现这一点
在全局作用域（即
pipeline_def作用域之外）定义函数。如果函数是另一个“工厂”函数的结果，则工厂函数必须在管道定义函数外部定义，并使用
@do_not_convert装饰。
更多详细信息可以在
@do_not_convert文档中找到。此运算符允许序列输入并支持体积数据。
此操作符将不会从图中优化掉。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
batch_processing¶ (bool，可选，默认值 = False) –
确定函数是每个批次调用一次，还是为批次中的每个样本单独调用。
如果设置为 True，则该函数将接收其参数作为 NumPy 或 CuPy 数组的列表，分别用于 CPU 和 GPU 后端。
bytes_per_sample_hint¶ (int 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
function¶ (object) –
定义操作符功能的可调用对象。
警告
该函数不得持有对其使用的 pipeline 的引用。如果持有，将形成对 pipeline 的循环引用，并且 pipeline 将永远不会被释放。
num_outputs¶ (int，可选，默认值 = 1) – 输出数量。
output_layouts¶ (布局字符串 或 布局字符串 列表，可选) –
输出的张量数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 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, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
crop_shape¶ (int 或 list of int 或 TensorList of int) – 裁剪窗口尺寸。
in_shape¶ (int 或 list of int 或 TensorList of int, optional) –
输入数据的形状。
如果提供，裁剪窗口的起始位置将被选择为使裁剪窗口在输入的边界内。
注意
提供
in_shape与直接将输入数据作为位置输入传递不兼容。preserve¶ (bool, optional, default = False) – 即使其输出未使用，也防止从图中删除算子。
roi_end¶ (int 或 list of int 或 TensorList of int, optional) –
ROI 结束坐标。
roi_shape¶ (int 或 list of int 或 TensorList of int, optional) –
ROI 形状。
roi_start¶ (int 或 list of int 或 TensorList of int) – ROI 起始坐标。
seed¶ (int, optional, default = -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指定的最小重叠度量，例如裁剪窗口与边界框的交并比，或作为交集区域与边界框区域之比的相对重叠度。此外，如果
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 都作为
float返回，即使由于提供了crop_shape参数，它们表示绝对坐标也是如此。 为了使nvidia.dali.fn.slice()正确解释它们，应将 normalized_anchor 和 normalized_shape 设置为 False。第三个输出包含边界框，在通过质心或面积阈值进行过滤后（请参阅
bbox_prune_threshold参数），并且坐标已映射到新的坐标空间。下一个输出是可选的，它表示与已过滤的边界框关联的标签。 如果提供了标签输入，则将显示该输出。
最后一个输出也是可选的，对应于通过上述过滤过程并存在于输出中的边界框的原始索引。 如果选项
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，并且 min 应小于或等于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 or 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¶ (布局字符串, optional, default = ‘’) –
确定在
crop_shape和input_shape中提供的维度的含义。取值如下：
W(宽度)H(高度)D(深度)
注意
如果留空，将根据维度数量假定为 “WH” 或 “WHD”。
threshold_type¶ (str, optional, default = ‘iou’) –
确定
thresholds的含义。默认情况下，thresholds 指的是边界框相对于裁剪窗口的交并比 (IoU)。或者，阈值可以设置为 “overlap” 以指定边界框将落在裁剪窗口内的面积比例。例如，阈值 1.0 表示整个边界框必须包含在结果裁剪窗口中。
thresholds¶ (float or 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 表示）。
生成两个输出，分别表示裁剪窗口的锚点和形状。
此算子的输出（锚点和形状）可以馈送到 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
num_attempts¶ (int, optional, default = 10) – 用于选择随机面积和宽高比的最大尝试次数。
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) – 随机种子；如果未设置，将自动分配一个种子。
- 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
必须与输入类型相同或为
float。如果未设置，则使用输入类型。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.DALIInterpTypeor TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 放大时使用的滤波器。min_filter¶ (
nvidia.dali.types.DALIInterpTypeor TensorList ofnvidia.dali.types.DALIInterpType, optional, default = DALIInterpType.INTERP_LINEAR) – 缩小时使用的滤波器。minibatch_size¶ (int, optional, default = 32) – 在内核调用中处理的最大图像数量。
num_attempts¶ (int, optional, default = 10) – 用于选择随机面积和宽高比的最大尝试次数。
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) – 随机种子；如果未设置，将自动分配一个种子。
size¶ (int 或 int 列表) – 调整大小后的图像尺寸。
temp_buffer_hint¶ (int, optional, default = 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
输出的总大小（以字节为单位）必须与输入匹配。如果未提供形状，则最内层维度将相应调整。如果最内层维度的字节大小不能被目标类型的大小整除，则会发生错误。
layout¶ (布局字符串, optional, default = ‘’) –
数据的新布局。
如果未指定值，则如果维度数量与现有布局匹配，则保留输出布局。如果维度数量不匹配，则参数将重置为空。如果设置了值并且不为空，则布局必须与输出的维度匹配。
preserve¶ (bool, optional, default = False) – 即使算子的输出未被使用，也防止其从图中移除。
rel_shape¶ (float or list of float or TensorList of float, optional, default = []) –
输出的相对形状。
输出形状通过将输入形状乘以
rel_shape来计算。out_shape[i] = in_shape[i] * rel_shape[i]
可以使用附加参数
src_dims来更改用于计算输出形状的源维度。out_shape[i] = in_shape[src_dims[i]] * rel_shape[i]
可以有一个负维度，用于接收与输入 volume 匹配所需的大小。例如，形状为
[480, 640, 3]的输入和rel_shape = [0.5, -1]将产生形状为[240, 3840]的输出。维度的数量受以下限制：
shape¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = []) –
期望的输出形状。
可以有一个负维度，用于接收与输入 volume 匹配所需的大小。例如，形状为
[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]。一个 extent 为 1 的前导维度被插入到开头，然后是原始的第一个维度，但顺序相反。最后一个维度被移除。src_dims参数可以与rel_shape一起使用，在这种情况下，rel_shape中的相对 extent 描述目标维度。在上面的示例中，指定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¶ (layout str, 可选, 默认值 = ‘’) –
数据的新布局。
如果未指定值，则如果维度数量与现有布局匹配，则保留输出布局。如果维度数量不匹配，则参数将重置为空。如果设置了值并且不为空，则布局必须与输出的维度匹配。
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]
可以有一个负维度，用于接收与输入 volume 匹配所需的大小。例如，形状为
[480, 640, 3]的输入和rel_shape = [0.5, -1]将产生形状为[240, 3840]的输出。维度的数量受以下限制：
shape¶ (int 或 int 列表或 int 的 TensorList, 可选, 默认值 = []) –
期望的输出形状。
可以有一个负维度，用于接收与输入 volume 匹配所需的大小。例如，形状为
[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]。一个 extent 为 1 的前导维度被插入到开头，然后是原始的第一个维度，但顺序相反。最后一个维度被移除。src_dims参数可以与rel_shape一起使用，在这种情况下，rel_shape中的相对 extent 描述目标维度。在上面的示例中，指定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 或 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 或 float 列表, 可选) –
输出尺寸的限制。
当操作符配置为保持纵横比且仅指定较小维度时，另一个维度可能会变得非常大。当使用
resize_shorter参数或 “not_smaller” 模式，或者当某些 extent 未指定时，可能会发生这种情况。此参数限制了输出可以变得多大。此值可以按轴指定，也可以为所有轴统一指定。
注意
当与 “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，则操作将保持原始 volume 的纵横比。负值会翻转 volume。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) – 保存用于测试的 reshape 属性。
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.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、mirror 操作。
此操作的结果等同于先应用
resize，然后应用crop和flip。 在内部，算子计算相关的感兴趣区域，并对该区域执行单个调整大小操作。 .此运算符允许序列输入并支持体积数据。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
antialias¶ (bool, 可选, 默认 = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
crop¶ (float 或 float 列表 或 float 的 TensorList, 可选) –
裁剪图像的形状，指定为值列表（例如，对于 2D 裁剪为
(crop_H, crop_W)，对于体积裁剪为(crop_D, crop_H, crop_W)）。crop_d¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
仅适用于体积输入；裁剪窗口深度（以体素为单位）。
crop_w、crop_h和crop_d必须一起指定。 为crop_w、crop_h和crop_d提供值与提供固定裁剪窗口尺寸（参数crop）不兼容。crop_h¶ (float 或 float 的 TensorList, 可选, 默认 = 0.0) –
裁剪窗口高度（以像素为单位）。
crop_pos_x¶ (float 或 float 的 TensorList, 可选, 默认 = 0.5) –
裁剪窗口（左上角）的归一化 (0.0 - 1.0) 水平位置。
实际位置计算公式为
crop_x = crop_x_norm * (W - crop_W)，其中 crop_x_norm 是归一化位置，W是图像的宽度，而crop_W是裁剪窗口的宽度。有关
rounding参数关于crop_x如何转换为整数值的更多详细信息，请参阅该参数。crop_pos_y¶ (float 或 float 的 TensorList, 可选, 默认 = 0.5) –
裁剪窗口起始位置的归一化 (0.0 - 1.0) 垂直位置（通常为左上角）。
实际位置计算公式为
crop_y = crop_y_norm * (H - crop_H)，其中crop_y_norm是归一化位置，H 是图像的高度，而crop_H是裁剪窗口的高度。有关
rounding参数关于crop_y如何转换为整数值的更多详细信息，请参阅该参数。crop_pos_z¶ (float 或 float 的 TensorList, 可选, 默认 = 0.5) –
仅适用于体数据输入。
裁剪窗口（前平面）的归一化 (0.0 - 1.0) 法线位置。实际位置计算公式为
crop_z = crop_z_norm * (D - crop_D)，其中crop_z_norm是归一化位置，D是图像的深度，而crop_D是裁剪窗口的深度。有关
rounding参数关于crop_z如何转换为整数值的更多详细信息，请参阅该参数。crop_w¶ (float 或 float 的 TensorList, 可选, 默认 = 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 列表, 可选) –
输出尺寸的限制。
当算子配置为保持宽高比且仅指定较小尺寸时，其他尺寸可能会变得非常大。 当使用
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和显式 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，则 op 将保持原始 volume 的宽高比。 负值会翻转 volume。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=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 列表 或 float 的 TensorList, 可选, 默认 = []) –
**仅**适用于三维数据，是图像旋转所绕的轴。
该向量不需要归一化，但必须具有非零长度。反转向量等效于更改
angle的符号。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [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 列表 或 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 中，所有 reader 都被移动到了专用的
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与提供位置输入 anchor 和 shape 不兼容。fill_values¶ (float 或 float 列表，可选，默认值 = [0.0]) –
确定填充值，仅当
out_of_bounds_policy设置为 “pad” 时才相关。如果提供标量值，它将用于所有通道。如果提供多个值，则值的数量和通道的数量必须相同（输出切片中布局中维度
C的范围）。image_type¶ (
nvidia.dali.types.DALIImageType) –警告
参数 image_type 已不再使用，并将在未来的版本中移除。
normalized_anchor¶ (bool，可选，默认值 = True) –
确定锚点位置输入应解释为归一化坐标（范围 [0.0, 1.0]）还是绝对坐标。
注意
此参数仅在锚点数据类型为
float时才相关。 对于整数类型，坐标始终是绝对坐标。normalized_shape¶ (bool，可选，默认值 = True) –
确定形状位置输入应解释为归一化坐标（范围 [0.0, 1.0]）还是绝对坐标。
注意
此参数仅在锚点数据类型为
float时才相关。 对于整数类型，坐标始终是绝对坐标。out_of_bounds_policy¶ (str，可选，默认值 = ‘error’) –
确定当对输入进行越界区域切片时的策略。
以下是支持值的列表
"error"(默认值)：尝试在输入边界之外进行切片将产生错误。"pad"：将根据需要使用零或使用fill_values参数指定的任何其他值填充输入。"trim_to_shape"：切片窗口将被裁剪到输入的边界。
output_dtype¶ (
nvidia.dali.types.DALIDataType) –preserve¶ (bool，可选，默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
rel_end¶ (float 或 float 列表或 float 的 TensorList，可选) –
切片的结束相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start、end、shape、rel_start、rel_end、rel_shape与提供位置输入 anchor 和 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与提供位置输入 anchor 和 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¶ (float 或 int 的 1D TensorList，可选) –
（可选）包含切片起点的归一化或绝对坐标（x0、x1、x2、…）的输入。
整数坐标被解释为绝对坐标，而浮点坐标可以解释为绝对坐标或相对坐标，具体取决于
normalized_anchor的值。__shape¶ (float 或 int 的 1D TensorList，可选) –
（可选）包含切片维度（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，可选，默认值 = True) –
指示是否应填充提取的窗口，以便窗口函数在
window_step的倍数处居中。如果设置为 False，则信号将不被填充，即，仅提取输入范围内的窗口。
layout¶ (布局字符串，可选，默认值 = ‘ft’) – 输出布局：“ft”（频率优先）或 “tf”（时间优先）。
nfft¶ (int，可选) –
FFT 的大小。
输出中创建的 bin 的数量为
nfft // 2 + 1。注意
输出仅表示频谱的正半部分。
power¶ (int，可选，默认值 = 2) –
频谱幅度的指数。
支持的值
1- 幅度，2- 功率（计算速度更快）。
preserve¶ (bool，可选，默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
reflect_padding¶ (bool，可选，默认值 = True) –
指示在信号边界外采样时的填充策略。
如果设置为 True，则信号相对于边界镜像，否则信号用零填充。
注意
当
center_windows设置为 False 时，将忽略此选项。window_fn¶ (float 或 float 列表，可选，默认值 = []) –
窗口函数的样本，将在计算 STFT 时乘以每个提取的窗口。
如果提供了值，它应该是一个浮点数列表，大小为
window_length。 如果未提供值，将使用 Hann 窗口。window_length¶ (int，可选，默认值 = 512) – 窗口大小，以样本数为单位。
window_step¶ (int，可选，默认值 = 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，可选，默认值 = 0.0) – 用于填充的颜色值。
interp_type¶ (
nvidia.dali.types.DALIInterpType, 可选, 默认 = DALIInterpType.INTERP_NN) – 使用的插值类型。mask¶ (int 或 int 的 TensorList, 可选, 默认 = 1) –
确定是否将此增强应用于输入图像。
以下是这些值：
0：不应用此变换。
1：应用此变换。
preserve¶ (bool, 可选, 默认 = 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, 可选, 默认 = ‘’) –
应该移除的布局列。
所有被挤压的维度的大小都应为 1，除非张量的总体积在挤压前后均为 0。所有布局名称都应存在于数据布局中。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, 可选, 默认 = 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, 可选, 默认 = 0) –
输出张量中输入被堆叠的轴。
轴在输入中相应的轴之前插入。值 0 表示整个张量被堆叠。指定
axis等于输入中的维度数会导致来自输入的值被交错）。接受范围为 [-ndim, ndim]。负索引从后往前计数。
axis_name¶ (str, 可选) –
要插入的新轴的名称。
一个单字符字符串，它将表示输出布局中的新轴。输出布局将通过将该字符插入到输入布局中由
axis指示的位置来构建。例如，指定axis = 0和axis_name = "C"，输入布局为 “HW” 将产生输出布局 “CHW”bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, 可选, 默认 = 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 中，所有 reader 都被移动到了专用的
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) –
分贝为单位的最小或截止比率。
任何低于此值的值都将饱和。例如，
cutoff_db=-80的值对应于1e-8的最小比率。multiplier¶ (float, 可选, 默认 = 10.0) – 对数乘以的因子。该值通常为 10.0 或 20.0，具体取决于幅度是否平方。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未被使用。
reference¶ (float, 可选, 默认 = 0.0) –
参考幅度。
如果未提供值，则输入的最大值将用作参考。
注意
输入的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) –
定义操作符功能的可调用对象。
警告
该函数不得持有对其使用的 pipeline 的引用。如果持有，将形成对 pipeline 的循环引用，并且 pipeline 将永远不会被释放。
num_outputs¶ (int, 可选, 默认 = 1) – 输出数量。
output_layouts¶ (layout str 或 layout str 列表, 可选) –
输出的张量数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 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 中，所有 reader 都被移动到了专用的
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 中，所有 reader 都被移动到了专用的
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 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
如果未设置，则使用输入类型。
fill_value¶ (float, 可选) –
用于填充源图像外部区域的值。
如果未指定值，则源坐标将被钳制，并且边界像素将被重复。
interp_type¶ (
nvidia.dali.types.DALIInterpType, 可选，默认值 = DALIInterpType.INTERP_LINEAR) – 使用的插值类型。inverse_map¶ (bool, 可选，默认值 = True) – 如果给定的变换是从目标到源的映射，则设置为
False，否则设置为True。matrix¶ (float 或 float 列表或 float 的 TensorList，可选，默认值 = []) –
变换矩阵。
当
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, 可选，默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
size¶ (float 或 float 列表或 float 的 TensorList，可选，默认值 = []) –
输出大小，以像素/点为单位。
非整数大小将四舍五入到最接近的整数。通道维度应排除在外（例如，对于 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) – 阻止运算符从图中移除，即使其输出未被使用。
- __call__(__input, /, *, 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)#
要在图形定义中使用的操作符调用。
- 参数:
__input¶ (TensorList ('HWC')) – 运算符的输入。
- 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，则运算符为每个线程预分配两个（由于双缓冲）请求大小的主机 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) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 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后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 和更新架构中的
mixed后端类型。该提示用于为硬件 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 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 或 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，则运算符会为每个线程预先分配两个（由于双缓冲）请求大小的主机固定缓冲区。如果选择正确，则在管道执行期间不会发生额外的分配。 查找理想值的一种方法是使用设置为 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) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 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后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 和更新架构中的
mixed后端类型。该提示用于为硬件 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，则算子会为每个线程预分配一个请求大小的设备缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 的设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 的主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会为每个线程预分配两个（由于双缓冲）请求大小的主机 pinned 缓冲区。如果选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 的主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。hw_decoder_load¶ (float, optional, default = 0.65) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 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后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 和更新架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
random_area¶ (float 或 float 列表, optional, default = [0.08, 1.0]) –
从中选择随机面积比例
A的范围。裁剪图像的面积将等于
A* 原始图像的面积。random_aspect_ratio¶ (float 或 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来指定所提供参数的性质。将位置输入用于 anchor 和 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 或 int 列表 或 int 的 TensorList, optional, default = [1, 0]) –
用作维度索引的锚点和形状切片输入的维度顺序。
负值被解释为从后面计数维度。 有效范围：
[-ndim, ndim-1]，其中 ndim 是输入数据中的维度数。axis_names¶ (布局字符串, optional, default = ‘WH’) –
用于锚点和形状切片输入的维度顺序，如布局中所述。
如果提供了值，则
axis_names的优先级高于axes。bytes_per_sample_hint¶ (int 或 int 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
device_memory_padding¶ (int, optional, default = 16777216) –
仅适用于
mixed后端类型。nvJPEG 的设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会为每个线程预分配一个请求大小的设备缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。device_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 的设备内存分配的填充大小，以字节为单位。此参数有助于避免在遇到更大的图像时 nvJPEG2k 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。end¶ (int 或 int 列表 或 int 的 TensorList, optional) –
切片的结束坐标。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入 anchor 和 shape 不兼容。host_memory_padding¶ (int, optional, default = 8388608) –
仅适用于
mixed后端类型。nvJPEG 的主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会为每个线程预分配两个（由于双缓冲）请求大小的主机 pinned 缓冲区。如果选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。host_memory_padding_jpeg2k¶ (int, optional, default = 0) –
仅适用于
mixed后端类型。nvJPEG2k 的主机内存分配的填充大小，以字节为单位。此参数有助于防止在遇到更大的图像时 nvJPEG2k 中的重新分配，并且需要重新分配内部缓冲区以解码图像。
如果提供的值大于 0，则算子会根据提供的提示预分配必要数量的缓冲区。如果值选择正确，则在 pipeline 执行期间不会发生额外的分配。 找到理想值的一种方法是使用设置为 True 的
memory_stats参数对数据集进行完整运行，然后复制统计信息中打印的最大分配值。hw_decoder_load¶ (float, optional, default = 0.65) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 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后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
preallocate_width_hint¶ (int, optional, default = 0) –
图像宽度提示。
仅适用于 NVIDIA Ampere GPU 和更新架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
preserve¶ (bool, optional, default = False) – 防止算子从图中移除，即使其输出未被使用。
rel_end¶ (float 或 float 列表或 float 的 TensorList，可选) –
切片的结束相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入 anchor 和 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与提供位置输入 anchor 和 shape 不兼容。shape¶ (int 或 int 列表或 int 的 TensorList，可选) –
切片的形状。
提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入 anchor 和 shape 不兼容。split_stages¶ (bool) –
警告
参数 split_stages 不再使用，将在未来版本中移除。
start¶ (int 或 int 列表或 int 的 TensorList，可选) –
切片的起始坐标。
注意：提供命名参数
start/end或start/shape与提供位置输入 anchor 和 shape 不兼容。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¶ (float 或 int 的 1D TensorList，可选) –
包含切片起始点的归一化或绝对坐标（x0, x1, x2, …）的输入。
整数坐标被解释为绝对坐标，而浮点坐标可以被解释为绝对坐标或相对坐标，具体取决于
normalized_anchor的值。__shape¶ (float 或 int 的 1D TensorList，可选) –
包含切片尺寸的归一化或绝对坐标（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 或 int 列表或 int 的 TensorList) –
颜色滤镜阵列/拜耳瓦片的布局。
蓝色值在 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 或 int 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, optional, default = 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 或 int 列表或 int 的 TensorList, optional, default = [-1, -1]) –
设置结构元素的锚点。默认值 (-1, -1) 使用元素的中心作为锚点。
支持
per-frame输入。border_mode¶ (str, optional, default = ‘constant’) – 访问输入图像外部元素时要使用的边界模式。
bytes_per_sample_hint¶ (int 或 int 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
iterations¶ (int, optional, default = 1) – 执行操作的次数，通常设置为 1。设置为大于 1 的值相当于每次额外迭代将掩码尺寸增加 (mask_width - 1, mask_height -1)。
mask_size¶ (int 或 int 列表或 int 的 TensorList, optional, default = [3, 3]) –
结构元素的大小。
支持
per-frame输入。preserve¶ (bool, optional, default = 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 或 int 列表或 int 的 TensorList, optional, default = [-1, -1]) –
设置结构元素的锚点。默认值 (-1, -1) 使用元素的中心作为锚点。
支持
per-frame输入。border_mode¶ (str, optional, default = ‘constant’) – 访问输入图像外部元素时要使用的边界模式。
bytes_per_sample_hint¶ (int 或 int 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
iterations¶ (int, optional, default = 1) – 执行操作的次数，通常设置为 1。设置为大于 1 的值相当于每次额外迭代将掩码尺寸增加 (mask_width - 1, mask_height -1)。
mask_size¶ (int 或 int 列表或 int 的 TensorList, optional, default = [3, 3]) –
结构元素的大小。
支持
per-frame输入。preserve¶ (bool, optional, default = 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 或 int 列表或 int 的 TensorList, 可选, 默认 = [-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, 可选, 默认 = ‘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 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。输出类型可以是浮点型，或者必须与输入类型相同。如果未设置，则使用输入类型。
注意
用于实际计算的中间类型为 float32。如果输出为整数类型，则值将被限制在输出类型范围内。
mode¶ (str, 可选, 默认 = ‘same’) –
支持的值为：
"same"和"valid"。"same"(默认): 输入和输出大小相同，并且使用border来处理超出边界的滤波器位置。"valid": 输出样本被裁剪（裁剪量为filter_extent - 1），以便所有滤波器位置都完全位于输入样本内。
preserve¶ (bool, 可选, 默认 = 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 数组（或要
逐帧应用于视频输入的 2D 数组序列）。对于体输入，滤波器必须是 3D 数组。滤波器值必须具有 float32 类型。__fill_value¶ (TensorList, optional) –
用于填充的标量批次。
如果
"border"设置为"constant"，则当输入样本与滤波器卷积时，将使用相应的标量进行填充。标量必须与输入样本的类型相同。对于视频/序列输入，可以指定一个标量数组以逐帧应用。
- 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, 可选, 默认 = ‘LZ4’) –
用于解码数据的算法。
目前仅支持
LZ4。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
chunk_offsets¶ (int 或 int 列表或 int 的 TensorList, optional) –
输入样本中描述连续块开始位置的偏移量列表。
如果未指定
chunk_sizes，则假定块在输入张量中密集打包，并且最后一个块以样本的结尾结束。chunk_sizes¶ (int 或 int 列表或 int 的 TensorList, optional) –
相应输入块的大小列表。
如果未指定
chunk_offsets，则假定块在输入张量中密集打包，并且第一个块从样本的开头开始。dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认 = DALIDataType.UINT8) – 输出（膨胀）数据类型。layout¶ (layout str, 可选, 默认 = ‘’) –
输出（膨胀）块的布局。
如果样本由多个块组成，则还会将
sequence_axis_name范围添加到指定布局的开头。preserve¶ (bool, 可选, 默认 = False) – 阻止算子从图中移除，即使其输出未被使用。
sequence_axis_name¶ (layout str, 可选, 默认 = ‘F’) –
序列轴的名称。
如果样本由多个块组成，则会在输出张量中添加一个额外的外部维度。默认情况下，假定它是视频帧，因此默认标签为 'F'
如果未指定
layout或者输入不是序列（既未指定chunk_offsets也未指定chunk_sizes），则忽略该值。shape¶ (int 或 int 列表或 int 的 TensorList) – 输出（膨胀）块的形状。
- class nvidia.dali.ops.experimental.MedianBlur(*, bytes_per_sample_hint=[0], preserve=False, window_size=[3, 3], device=None, name=None)#
中值模糊通过用周围矩形区域的中值颜色替换每个像素来平滑图像或图像序列。
- 支持的后端
‘gpu’
- 关键词参数:
- 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, 可选, 默认 = True) – 计算形状时使用 EXIF 方向元数据。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认 = DALIDataType.INT64) – 尺寸转换到的数据类型。image_type¶ (
nvidia.dali.types.DALIImageType, 可选, 默认 = DALIImageType.RGB) – 图像的颜色格式。preserve¶ (bool, 可选, 默认 = 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 或 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 或 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.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互斥。
preserve¶ (bool, optional, default = False) – 阻止算子从图中移除，即使其输出未使用。
resize_longer¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像的较长边的长度。
此选项与
resize_shorter和显式尺寸参数互斥，并且算子保持原始图像的宽高比。此选项等效于为所有维度指定相同大小和mode="not_larger"。resize_shorter¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像的较短边的长度。
此选项与
resize_longer和显式尺寸参数互斥，并且算子保持原始图像的宽高比。此选项等效于为所有维度指定相同大小和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 or list of float or TensorList of float, optional) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标 (0..1)，具体取决于relative_roi参数的值。如果任何维度中的 ROI 原点大于 ROI 终点，则该区域在该维度中翻转。roi_relative¶ (bool, optional, default = False) – 如果为 true，则 ROI 坐标相对于输入大小，其中 0 表示顶部/左侧，1 表示底部/右侧
roi_start¶ (float or list of float or TensorList of float, optional) –
输入感兴趣区域 (ROI) 的起始坐标。
必须与
roi_end一起指定。坐标遵循张量形状顺序，这与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标 (0..1)，具体取决于relative_roi参数的值。如果任何维度中的 ROI 原点大于 ROI 终点，则该区域在该维度中翻转。save_attrs¶ (bool, optional, default = False) – 保存 reshape 属性以进行测试。
size¶ (float or list of float or TensorList of float, optional) –
期望的输出尺寸。
必须是列表/元组，每个空间维度一个条目，不包括视频帧和通道。维度为 0 范围的将被视作不存在，并且输出大小将根据其他范围和
mode参数计算。subpixel_scale¶ (bool, optional, default = True) –
如果为 True，则直接指定或计算出的分数尺寸将导致调整输入 ROI 以保持缩放比例。
否则，将调整缩放比例，以使源图像映射到舍入后的输出尺寸。
temp_buffer_hint¶ (int, optional, default = 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 张量列表, 可选, 默认 = [0.5]) –
当使用缩放比例（已提供或已计算）时，确定 ROI 的位置。
实际输出大小必须是整数，并且可能与通过输入（或 ROI）大小乘以缩放因子计算出的“理想”输出大小不同。在这种情况下，输出大小将四舍五入（根据
size_rounding策略），并且需要调整输入 ROI 以保持缩放因子。此参数定义了 ROI 的哪个相对点应保持其在输出中的位置。此点计算为
center = (1 - alignment) * roi_start + alignment * roi_end。Alignment 0.0 表示与 ROI 的起始位置对齐，0.5 表示与区域的中心对齐，1.0 表示与末尾对齐。请注意，当未指定 ROI 时，将假定 roi_start=0 和 roi_end=input_size。当使用 0.5（默认值）时，调整大小操作具有翻转不变性（翻转后再调整大小在数学上等同于调整大小后再翻转）。
此参数的值包含与为 sizes/scales 提供的维度一样多的元素。如果仅提供一个值，则将其应用于所有维度。
antialias¶ (bool, 可选, 默认 = True) –
如果启用，则在缩小比例时应用抗锯齿滤波器。
注意
最近邻插值不支持抗锯齿。
axes¶ (int 或 list of 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的张量列表, 可选, 默认 = DALIInterpType.INTERP_LINEAR) –要使用的插值类型。
使用
min_filter和mag_filter来为缩小和放大指定不同的滤波。注意
现在不建议使用 INTERP_TRIANGULAR，应将其替换为
启用
antialias的 INTERP_LINEAR。mag_filter¶ (
nvidia.dali.types.DALIInterpType或nvidia.dali.types.DALIInterpType的张量列表, 可选, 默认 = 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的张量列表, 可选, 默认 = 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) – 即使操作符的输出未使用，也阻止从图中删除该操作符。
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 终点，则该区域在该维度中被翻转。scales¶ (float 或 list of float 或 TensorList of float, 可选) –
缩放因子。
结果输出大小计算为
out_size = size_rounding(scale_factor * original_size)。有关支持的舍入策略列表，请参阅size_rounding。size_rounding¶ (str, 可选, 默认 = ‘round’) –
确定使用缩放比例时的舍入策略。
可能的值为：* |
"round"- 将结果大小四舍五入到最接近的整数值，中间值远离零舍入。 * |"truncate"- 丢弃结果大小的小数部分。 * |"ceil"- 将结果大小向上舍入到下一个整数值。sizes¶ (float 或 list of float 或 TensorList of float, 可选) –
输出大小。
subpixel_scale¶ (bool, 可选, 默认 = True) –
如果为 True，则直接指定或计算出的分数尺寸将导致调整输入 ROI 以保持缩放比例。
否则，将调整缩放比例，以使源图像映射到舍入后的输出尺寸。
temp_buffer_hint¶ (int, 可选, 默认 = 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, 可选, 默认 = ‘constant’) – 访问输入图像外部的元素时要使用的边界模式。支持的值为：“constant”、“replicate”、“reflect”、“reflect_101”、“wrap”。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
fill_value¶ (float 或 float 列表, 可选, 默认 = []) – 当选择 “constant” border_mode 时，用于填充源图像外部区域的值。
interp_type¶ (
nvidia.dali.types.DALIInterpType, 可选, 默认 = DALIInterpType.INTERP_LINEAR) – 使用的插值类型。inverse_map¶ (bool, 可选, 默认 = True) – 如果设置为 true（默认值），则矩阵被解释为目标到源坐标的映射。否则，它被解释为源到目标坐标的映射。
matrix¶ (float 或 float 列表或 float 张量列表, 可选, 默认 = []) –
- 目标到源坐标的透视变换映射。
如果
inverse_map参数设置为 false，则矩阵被解释为源到目标坐标的映射。
它等效于 OpenCV 的
warpPerspective操作，其中inverse_map参数类似于WARP_INVERSE_MAP标志。注意
除了此参数之外，运算符还可以接受第二个位置输入，在这种情况下，矩阵可以放置在 GPU 上。
支持
per-frame输入。pixel_origin¶ (str, 可选, 默认 = ‘corner’) –
像素原点。可能的值：“corner”、“center”。
确定 (0, 0) 坐标的含义 - “corner” 将原点放置在左上角像素的左上角（如 OpenGL 中）；“center” 将 (0, 0) 放置在左上角像素的中心（如 OpenCV 中）。
preserve¶ (bool, 可选, 默认 = False) – 即使操作符的输出未使用，也阻止从图中删除该操作符。
size¶ (float 或 float 列表或 float 张量列表, 可选, 默认 = []) –
输出大小，以像素/点为单位。
应排除通道维度（例如，对于 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, 可选, 默认 = True) – 使用 EXIF 方向元数据来校正图像
affine¶ (bool, 可选, 默认 = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 list of int, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
cache_batch_copy¶ (bool, 可选, 默认 = True) –
仅适用于
mixed后端类型。如果设置为 True，则使用批处理复制内核调用复制缓存中的多个图像。否则，除非批次中的顺序与缓存中的顺序相同，否则每个图像都使用
cudaMemcpy复制。cache_debug¶ (bool, 可选, 默认 = False) –
仅适用于
mixed后端类型。打印有关解码器缓存的调试信息。
cache_size¶ (int, 可选, 默认 = 0) –
仅适用于
mixed后端类型。解码器缓存的总大小，以兆字节为单位。如果提供，则解码后大于
cache_threshold的图像将被缓存在 GPU 内存中。cache_threshold¶ (int, 可选, 默认 = 0) –
仅适用于
mixed后端类型。要缓存的解码图像的大小阈值，以字节为单位。当图像被缓存时，当在运算符输入端遇到它时，不再需要解码，从而节省了处理时间。
cache_type¶ (str, 可选, 默认 = ‘’) –
仅适用于
mixed后端类型。以下是可用缓存类型的列表
threshold: 缓存每个大小大于cache_threshold的图像，直到缓存已满。阈值策略的预热时间为 1 个 epoch。
largest：存储可以放入缓存的最大图像。最大策略的预热时间为 2 个 epoch注意
为了利用缓存，建议将读取器配置为 stick_to_shard=True，以限制多节点环境中每个解码器实例看到的唯一图像数量。
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) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, 可选, 默认 = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ –
- output_type
nvidia.dali.types.DALIImageType, 可选, 默认 = DALIImageType.RGB 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将先解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preallocate_width_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preservebool, 可选, 默认 = 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 或 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) –
裁剪窗口宽度（以像素为单位）。
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) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, 可选, 默认 = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ –
- output_type
nvidia.dali.types.DALIImageType, 可选, 默认 = DALIImageType.RGB 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将先解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preallocate_width_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preservebool, 可选, 默认 = 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, optional, default = True) – 使用 EXIF 方向元数据来校正图像
affine¶ (bool, optional, default = True) –
仅适用于
mixed后端类型。如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。否则，线程可以由操作系统重新分配到任何 CPU 核心。
bytes_per_sample_hint¶ (int or 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) –图像的输出数据类型。
值将被转换为请求类型的动态范围。
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) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 CPU。
jpeg_fancy_upsampling¶ (bool, optional, default = False) –
使
mixed后端使用与cpu后端相同的色度上采样方法。此选项对应于 libjpegturbo 或 ImageMagick 中提供的 JPEG 精细上采样。
memory_stats¶ –
- num_attemptsint, optional, default = 10
最大尝试次数，用于选择随机区域和宽高比。
- output_type
nvidia.dali.types.DALIImageType, 可选, 默认 = DALIImageType.RGB 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将先解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preallocate_width_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preservebool, 可选, 默认 = False
防止运算符从图中移除，即使其输出未使用。
- random_areafloat or list of float, optional, default = [0.08, 1.0]
从中选择随机面积比例
A的范围。裁剪图像的面积将等于
A* 原始图像的面积。- random_aspect_ratiofloat or list of float, optional, default = [0.75, 1.333333]
从中选择随机宽高比（宽度/高度）的范围。
- seedint, optional, default = -1
随机种子；如果未设置，将自动分配一个。
split_stages : bool, 可选, 默认 = False
警告
参数 split_stages 现在已弃用，不建议使用。
use_chunk_allocator : bool, 可选, 默认 = False
警告
参数 use_chunk_allocator 现在已弃用，不建议使用。
- use_fast_idctbool, 可选, 默认 = False
Enables fast IDCT in the libjpeg-turbo based CPU decoder, used when
deviceis set to “cpu” or when the it is set to “mixed” but the particular image can not be handled by the GPU implementation.根据 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 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 的值，则运算符为每个线程预分配一个请求大小的设备缓冲区。如果正确选择该值，则在 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 or list of int or TensorList of int, optional) –
切片的结束坐标。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入 anchor 和 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) –
由硬件 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 混合霍夫曼解码器。像素较少的图像将使用 nvJPEG 主机端霍夫曼解码器。注意
混合霍夫曼解码器仍然主要使用 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, 可选, 默认 = DALIImageType.RGB 输出图像的色彩空间。
注意：当解码为 YCbCr 时，图像将先解码为 RGB，然后转换为 YCbCr，遵循 ITU-R BT.601 中的 YCbCr 定义。
- preallocate_height_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preallocate_width_hintint, 可选, 默认 = 0
图像宽度提示。
仅 适用于 NVIDIA Ampere GPU 架构中的
mixed后端类型。该提示用于为硬件 JPEG 解码器预分配内存。
- preservebool, 可选, 默认 = False
防止运算符从图中移除，即使其输出未使用。
- rel_endfloat or list of float or TensorList of float, optional
切片的结束相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入 anchor 和 shape 不兼容。- rel_shapefloat or list of float or TensorList of float, optional
切片的相对形状（范围 [0.0 - 1.0]）。
Providing named arguments
start,end,shape,rel_start,rel_end,rel_shapeis incompatible with providing positional inputs anchor and shape.- rel_startfloat or list of float or TensorList of float, optional
切片的起始相对坐标（范围 [0.0 - 1.0]）。
注意：提供命名参数
start,end,shape,rel_start,rel_end,rel_shape与提供位置输入 anchor 和 shape 不兼容。- shapeint 或 int 列表或 int 的 TensorList，可选
切片的形状。
Providing named arguments
start,end,shape,rel_start,rel_end,rel_shapeis incompatible with providing positional inputs anchor and shape.
split_stages : bool, 可选, 默认 = False
警告
参数 split_stages 现在已弃用，不建议使用。
- startint 或 int 列表或 int 的 TensorList，可选
切片的起始坐标。
注意：提供命名参数
start/end或start/shape与提供位置输入 anchor 和 shape 不兼容。
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 或 int 列表，可选，默认值 = [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 或 int 列表，可选，默认值 = [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 或 int 列表，可选，默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 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 or list of str, optional) –
要从中读取数据的文件路径列表。
如果提供了
file_root，则路径被视为相对于它。此参数与
file_list互斥。hdu_indices¶ (int 或 int 列表，可选，默认值 = [2]) – 要读取的 HDU 索引。如果未提供，则将产生主 HDU 之后的第一个 HDU。由于 HDU 的索引从 1 开始，因此默认值如下：hdu_indices = [2]。提供的列表 hdu_indices 的大小定义了每个样本的输出数。
initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
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) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
使用大小等于
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 后混洗整个数据集。
当此参数设置为 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 用于解析视频容器，并返回一批形状为
(N, F, H, W, C)的sequence_length帧序列（其中N是批大小，F是帧数）。注意
不支持索引的容器（如 MPEG）需要 DALI 构建索引。
DALI 将遍历视频并标记关键帧，以便即使在可变帧率的情况下也能有效地查找。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
bytes_per_sample_hint¶ (int 或 int 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
enable_frame_num¶ (bool, optional, default = False) – 如果设置，则返回解码序列中第一帧的索引作为额外的输出。
filenames¶ (str 或 str 列表, optional, default = []) – 要加载的视频文件的绝对路径。
initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。labels¶ (int 或 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) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
使用大小等于
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, 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, 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#
此模块中的运算符是数据读取运算符，用于从运算符输入在运行时指定的源读取数据。对于能够在 pipeline 构建时构建数据集的无输入数据读取器，请参阅 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 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，它将使用普通文件 I/O，而不是尝试将文件映射到内存中。
当访问本地文件系统时，映射提供小的性能优势，但对于大多数网络文件系统，它不提供优势
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
use_o_direct¶ (bool, optional, default = 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 列表, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
mean¶ (float 或 float TensorList, optional, default = 0.0) – 分布的均值。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中删除，即使其输出未使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
stddev¶ (float 或 float TensorList, optional, default = 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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
pepper_val¶ (float 或 TensorList of float, optional) –
“pepper” 的值。
如果未提供，对于浮点类型，pepper 值将为 -1.0，否则为输入数据类型的最小值，并转换为输入的数据类型。
per_channel¶ (bool, optional, default = False) –
确定是否应独立地为每个通道生成噪声。
如果设置为 True，则为每个通道独立生成噪声，导致某些通道损坏而其他通道保持完整。如果设置为 False，则噪声生成一次并应用于所有通道，因此像素中的所有通道都应保持完整、取 “pepper” 值或 “salt” 值。
注意：每个通道的噪声生成要求输入布局包含通道（'C'）维度，或者为空。如果布局为空，则假定为通道优先布局。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
prob¶ (float 或 TensorList of float, optional, default = 0.05) – 输出值取 salt 或 pepper 值的概率。
salt_val¶ (float 或 TensorList of float, optional) –
“salt” 的值。
如果未提供，对于浮点类型，salt 值将为 1.0，否则为输入数据类型的最大值，并转换为输入的数据类型。
salt_vs_pepper¶ (float 或 TensorList of float, optional, default = 0.5) – 损坏的输出值取 salt 值的概率。
seed¶ (int, optional, default = -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’
- 关键词参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
factor¶ (float 或 TensorList of float, optional, default = 20.0) – 因子参数。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
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, optional, default = True) –
仅适用于混合后端类型。
- 如果设置为 True，则内部线程池中的每个线程将绑定到特定的 CPU 核心。
否则，线程可以由操作系统重新分配给任何 CPU 核心。
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
end_frame¶ (int, optional, default = 0) – 要解码的结束帧的索引。
preserve¶ (bool, optional, default = 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 或 TensorList of float, optional, default = 1.0) – alpha 参数，一个正
float32标量。beta¶ (float 或 TensorList of float, optional, default = 1.0) – beta 参数，一个正
float32标量。bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, optional) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行舍入和钳位。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 list of int 或 TensorList of int, optional) – 输出数据的形状。
- 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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
p¶ (float 或 list of float 或 TensorList of float, optional) – 概率分布。如果未指定，则假定为均匀分布。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 list of int 或 TensorList of int, optional) – 输出数据的形状。
- __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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行舍入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也防止其从图中移除。
probability¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.5) – 值为 1 的概率。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 的 list 或 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 的 list, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行舍入和钳位。
mean¶ (float 或 float 的 TensorList, 可选, 默认值 = 0.0) – 分布的均值。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也防止其从图中移除。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 的 list 或 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 的 list, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选) –输出数据类型。
注意
生成的数字将转换为输出数据类型，并在必要时进行舍入和钳位。
preserve¶ (bool, 可选, 默认值 = False) – 即使算子的输出未被使用，也防止其从图中移除。
range¶ (float 或 float 的 list 或 float 的 TensorList, 可选, 默认值 = [-1.0, 1.0]) –
连续均匀分布的范围
[min, max)。此参数与
values互斥。警告
当指定整数类型作为
dtype时，由于舍入，生成的数字可能会超出指定的范围。seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
shape¶ (int 或 int 的 list 或 int 的 TensorList, 可选) – 输出数据的形状。
values¶ (float 或 float 的 list 或 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 （可选，如果参数
image_ids设置为 True 则存在）每个样本一个元素，表示图像标识符。
- 支持的后端
‘cpu’
- 关键词参数:
annotations_file¶ (str, 可选, 默认值 = ‘’) – JSON 注释文件路径列表。
avoid_class_remapping¶ (bool, 可选, 默认值 = False) –
如果设置为 True，类 ID 值将直接按照它们在清单文件中定义的方式返回。
否则，类 ID 值将被映射到范围 1-类别数量的连续值，而忽略清单中的确切值（0 保留给特殊的背景类）。
bytes_per_sample_hint¶ (int 或 int 的 list, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则加载器将使用普通文件 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¶ (bool, 可选, 默认值 = False) – 如果设置为 True，图像 ID 将在额外的输出中生成。
images¶ (str 或 str 的 list, 可选) –
图像路径列表。
如果提供，它指定将要读取的图像。 图像将按照它们在列表中出现的顺序读取，如果存在重复项，将生成相关样本的多个副本。
如果未指定或设置为 None，则注释文件中列出的所有图像将精确读取一次，并按其图像 ID 排序。
要保留的路径应与注释文件中的路径完全匹配。
注意：此参数与
preprocessed_annotations互斥。include_iscrowd¶ (bool, 可选, 默认值 = True) – 如果设置为 True，则标记为
iscrowd=1的注释也将包含在内。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, 可选, 默认值 = False) – 仅在第一次运行时解析和准备数据集元数据，而不是在构造函数中。
ltrb¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则边界框将作为 [left, top, right, bottom] 返回。
如果设置为 False，则边界框将作为 [x, y, width, height] 返回。
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, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数不同，则此选项可能会导致将整个重复样本批次添加到数据集。
pixelwise_masks¶ (bool, optional, default = False) – 如果为 true，则分割掩码将作为逐像素掩码读取和返回。此参数与
polygon_masks互斥。polygon_masks¶ (bool, optional, default = False) – 如果设置为 True，则分割掩码多边形将以两个输出的形式读取：
polygons和vertices。此参数与pixelwise_masks互斥。prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preprocessed_annotations¶ (str, optional, default = ‘’) – 包含预处理 COCO 注释的元文件的目录路径。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。ratio¶ (bool, optional, default = False) – 如果设置为 True，则返回的边界框和掩码多边形坐标相对于图像尺寸。
read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于大型文件，例如 LMDB、RecordIO 或 TFRecord，此参数会减慢首次访问速度，但会缩短所有后续访问的时间。
save_img_ids¶ (bool) –
save_preprocessed_annotations¶ (bool, optional, default = False) – 如果设置为 True，则运算符会保存一组文件，其中包含预处理 COCO 注释的二进制表示。
save_preprocessed_annotations_dir¶ (str, optional, default = ‘’) – 用于保存预处理 COCO 注释文件的目录路径。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, optional, default = 0) – 要读取的分片索引。
shuffle_after_epoch¶ (bool, optional, default = False) – 如果设置为 True，则读取器在每个 epoch 后对整个数据集进行洗牌。
size_threshold¶ (float, optional, default = 0.1) – 如果表示对象实例的边界框的宽度或高度（以像素为单位）低于此值，则将忽略该对象。
skip_cached_images¶ (bool, optional, default = False) –
如果设置为 True，则当样本在解码器缓存中时，将跳过加载数据。
在这种情况下，加载器的输出将为空。
skip_empty¶ (bool, optional, default = False) – 如果为 true，读取器将跳过其中没有对象实例的样本
stick_to_shard¶ (bool, optional, default = False) –
确定读取器是否应坚持数据分片，而不是遍历整个数据集。
如果使用解码器缓存，它可以显著减少要缓存的数据量，但可能会影响训练的准确性。
tensor_init_bytes¶ (int, optional, default = 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
image_available¶ (bool, optional, default = True) – 确定此 LMDB 中是否有图像可用。
initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。label_available¶ (bool, optional, default = True) – 确定标签是否可用。
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) – Caffe LMDB 目录的路径列表。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
大小等于
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) – 每个图像要分配多少内存的提示。
- __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 Memory-Mapped Database (LMDB) 读取样本数据。
- 支持的后端
‘cpu’
- 关键词参数:
additional_inputs¶ (int, optional, default = 0) – 为每个样本提供的其他辅助数据张量。
bbox¶ (bool, optional, default = False) – 表示是否存在边界框信息。
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
image_available¶ (bool, optional, default = True) – 确定此 LMDB 中是否有图像可用。
initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。label_type¶ (int, optional, default = 0) –
数据集中存储的标签类型。
以下是可用值列表
0 = SINGLE_LABEL：这是多类分类的整数标签。
1 = MULTI_LABEL_SPARSE：这是多标签分类的稀疏活动标签索引。
2 = MULTI_LABEL_DENSE：这是用于标签嵌入回归的密集标签嵌入向量。
3 = MULTI_LABEL_WEIGHTED_SPARSE：这是具有每个标签权重的多标签分类的稀疏活动标签索引。
4 = NO_LABEL：没有可用的标签。
lazy_init¶ (bool, optional, default = False) – 仅在首次运行时（而不是在构造函数中）解析和准备数据集元数据。
num_labels¶ (int, optional, default = 1) –
数据集中的类数。
当使用稀疏标签时是必需的。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数不同，则此选项可能会导致将整个重复样本批次添加到数据集。
path¶ (str or list of str) – Caffe2 LMDB 目录的路径列表。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止从图中删除该运算符。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
大小等于
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) – 每个图像要分配多少内存的提示。
- __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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
case_sensitive_filter¶ (bool, optional, default = False) – 如果设置为 True，则过滤器将区分大小写匹配，否则不区分大小写。
dir_filters¶ (str 或 list of str, optional) –
用于过滤
file_root下子目录列表的 glob 字符串列表。dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
file_filters¶ (str or list of str, optional, default = [‘*.jpg’, ‘*.jpeg’, ‘*.png’, ‘*.bmp’, ‘*.tif’, ‘*.tiff’, ‘*.pnm’, ‘*.ppm’, ‘*.pgm’, ‘*.pbm’, ‘*.jp2’, ‘*.webp’, ‘*.flac’, ‘*.ogg’, ‘*.wav’]) –
用于过滤
file_root子目录中文件列表的 glob 字符串列表。file_list¶ (str, optional) –
指向文本文件的路径，该文件每行包含一个空格分隔的
filename label对。文件名相对于该文件的位置或file_root（如果指定）的位置。此参数与
files互斥。file_root¶ (str, optional) –
包含数据文件的目录的路径。
如果不使用
file_list或files，则会遍历此目录以发现文件。在此操作模式下，file_root是必需的。files¶ (str 或 list of str, optional) –
要从中读取数据的文件路径列表。
如果提供了
file_root，则路径被视为相对于它。当使用files时，标签取自labels参数，或者，如果未提供，则包含给定文件在files列表中出现的索引。此参数与
file_list互斥。initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。labels¶ (int 或 list of int, optional) –
伴随
files参数中列出的文件内容的标签。如果未使用，则顺序的从 0 开始的索引将用作标签
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) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也阻止将其从图中删除。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
使用大小等于
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 后混洗整个数据集。
当此参数设置为 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], 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
index_path¶ (str 或 list of str) –
包含索引 (.idx) 文件路径的列表（长度为 1）。
该文件由带有 RecordIO 文件的 MXNet 的
im2rec.py脚本生成。该列表也可以使用与 DALI 一起分发的rec2idx脚本生成。initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
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 或 list of str) – RecordIO 文件路径列表。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使其输出未被使用，也防止运算符从图中移除。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
使用大小等于
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) – 每个图像要分配多少内存的提示。
- __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 兼容的清单文件中读取自动语音识别 (ASR) 数据（音频、文本）。
清单文件示例
{ "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）清单条目的索引：int64，shape=(1,)
- 支持的后端
‘cpu’
- 关键词参数:
bytes_per_sample_hint¶ (int or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
downmix¶ (bool, optional, default = True) – 如果为 True，则将所有输入通道下混为单声道。 如果下混音已开启，解码器将始终产生 1-D 输出
dtype¶ (
nvidia.dali.types.DALIDataType, optional, default = DALIDataType.FLOAT) –输出数据类型。
支持的类型：
INT16、INT32和FLOAT。initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, optional, default = False) – 仅在第一次运行时解析和准备数据集元数据，而不是在构造函数中。
manifest_filepaths¶ (str 或 list of str) – NeMo 兼容清单文件路径的列表。
max_duration¶ (float, optional, default = 0.0) –
如果提供大于 0 的值，则指定音频样本的最大允许持续时间（秒）。
持续时间超过此值的样本将被忽略。
min_duration¶ (float, optional, default = 0.0) –
- 如果提供大于 0 的值，则指定最小允许持续时间，
以秒为单位，音频样本的持续时间。
持续时间短于此值的样本将被忽略。
normalize_text¶ (bool) –
警告
normalize_text 参数不再使用，将在未来的版本中移除。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数不同，则此选项可能会导致将整个重复样本批次添加到数据集。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使其输出未被使用，也防止运算符从图中移除。
quality¶ (float, optional, default = 50.0) –
重采样质量，0 为最低，100 为最高。
0 对应于 sinc 滤波器的 3 个波瓣；50 给出 16 个波瓣，100 给出 64 个波瓣。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
使用大小等于
initial_fill的预取缓冲区按顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于大型文件，例如 LMDB、RecordIO 或 TFRecord，此参数会减慢首次访问速度，但会缩短所有后续访问的时间。
read_idxs¶ (bool, optional, default = False) –
- 是否将样本的索引作为单独的输出输出，因为它们出现在清单文件中
作为单独的输出
read_sample_rate¶ (bool, optional, default = True) – 是否将每个样本的采样率作为单独的输出输出
read_text¶ (bool, optional, default = True) – 是否将每个样本的转录文本作为单独的输出输出
sample_rate¶ (float, optional, default = -1.0) – 如果指定，则为目标采样率，单位为 Hz，音频将重采样到该采样率。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, optional, default = 0) – 要读取的分片索引。
shuffle_after_epoch¶ (bool, optional, default = False) – 如果为 true，则读取器在每个 epoch 后打乱整个数据集
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, 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
cache_header_information¶ (bool, optional, default = False) – 如果设置为 True，则缓存每个文件的标头信息，从而提高访问速度。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
file_filter¶ (str, optional, default = ‘*.npy’) –
如果指定了值，则该字符串被解释为 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互斥。fill_value¶ (float, optional, default = 0.0) – 当
out_of_bounds_policy设置为 “pad” 时，确定填充值。initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。lazy_init¶ (bool, optional, default = False) – 仅在首次运行时（而不是在构造函数中）解析和准备数据集元数据。
num_shards¶ (int, optional, default = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
out_of_bounds_policy¶ (str, optional, default = ‘error’) –
确定读取超出 numpy 数组边界时的策略。
以下是支持值的列表
"error"(默认): 尝试读取超出图像边界的内容将产生错误。"pad": 将根据需要使用零或使用fill_value参数指定的任何其他值来填充数组。"trim_to_shape": ROI 将被裁剪到数组的边界。
pad_last_batch¶ (bool, optional, default = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数不同，则此选项可能会导致将整个重复样本批次添加到数据集。
prefetch_queue_depth¶ (int, optional, default = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也防止从图中删除该运算符。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, optional, default = False) –
确定是否应预读访问的数据。
对于大型文件，例如 LMDB、RecordIO 或 TFRecord，此参数会减慢首次访问速度，但会缩短所有后续访问的时间。
register_buffers¶ (bool, optional, default = True) –
仅适用于
gpu后端类型。警告
此参数暂时禁用，并保留以实现向后兼容性。它将在未来的版本中重新启用。
如果为 true，设备 I/O 缓冲区将使用 cuFile 注册。如果样本大小变化很大，则不建议使用。
rel_roi_end¶ (float 或 list of float 或 TensorList of float, optional) –
感兴趣区域的结束位置，以相对坐标表示（范围 [0.0 - 1.0]）。
此参数与 “roi_end”、“roi_shape” 和 “rel_roi_shape” 不兼容。
rel_roi_shape¶ (float 或 list of float 或 TensorList of float, optional) –
感兴趣区域的形状，以相对坐标表示（范围 [0.0 - 1.0]）。
此参数与 “roi_shape”、“roi_end” 和 “rel_roi_end” 不兼容。
rel_roi_start¶ (float 或 list of float 或 TensorList of float, optional) –
感兴趣区域的起始位置，以相对坐标表示（范围 [0.0 - 1.0]）。
此参数与 “roi_start” 不兼容。
roi_axes¶ (int or list of int, optional, default = []) –
用于 ROI 锚点和形状参数的维度顺序，以维度索引表示。
如果未提供，则应在 ROI 参数中指定所有维度。
roi_end¶ (int 或 list of int 或 TensorList of int, optional) –
感兴趣区域的结束位置，以绝对坐标表示。
此参数与 “rel_roi_end”、“roi_shape” 和 “rel_roi_shape” 不兼容。
roi_shape¶ (int 或 list of int 或 TensorList of int, optional) –
感兴趣区域的形状，以绝对坐标表示。
此参数与 “rel_roi_shape”、“roi_end” 和 “rel_roi_end” 不兼容。
roi_start¶ (int 或 list of int 或 TensorList of int, optional) –
感兴趣区域的起始位置，以绝对坐标表示。
此参数与 “rel_roi_start” 不兼容。
seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
shard_id¶ (int, optional, default = 0) – 要读取的分片的索引。
shuffle_after_epoch¶ (bool, optional, default = False) –
如果设置为 True，则读取器会在每个 epoch 后混洗整个数据集。
当此参数设置为 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) – 每个图像要分配多少内存的提示。
use_o_direct¶ (bool, optional, default = 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
dont_use_mmap¶ (bool, optional, default = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
file_root¶ (str) – 包含流的目录的路径，其中目录表示流。
image_type¶ (
nvidia.dali.types.DALIImageType, optional, default = DALIImageType.RGB) – 输入和输出图像的色彩空间。initial_fill¶ (int, optional, default = 1024) –
用于洗牌的缓冲区大小。
如果
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) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 即使运算符的输出未使用，也防止从图中删除该运算符。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
大小等于
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, 可选, 默认值 = False) –
如果设置为 True，则加载器将使用普通文件 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 或 str 列表) –
索引文件路径的列表。每个 TFRecord 文件应该有一个索引文件。
索引文件可以通过使用 DALI 发布的
tfrecord2idx脚本从 TFRecord 文件中获得。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于洗牌的缓冲区大小。
如果 random_shuffle 为 False，则忽略此参数。
lazy_init¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数不同，则此选项可能会导致将整个重复样本批次添加到数据集。
path¶ (str 或 str 列表) – TFRecord 文件路径的列表。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机打乱数据。
大小等于 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) – 每个图像要分配多少内存的提示。
use_o_direct¶ (bool, 可选, 默认值 = 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 用于解析视频容器，并返回一批
sequence_length帧的序列，形状为(N, F, H, W, C)，其中N是批次大小，F是帧数）。此类仅支持恒定帧率视频。注意
不支持索引的容器（如 mpeg）需要 DALI 在每次需要解码新序列时搜索到该序列。
- 支持的后端
‘gpu’
- 关键词参数:
additional_decode_surfaces¶ (int, 可选, 默认值 = 2) –
超出最低要求之外要使用的额外解码表面。
当解码器无法确定最少解码表面数量时，将忽略此参数。
注意
当驱动程序版本较旧时，可能会发生这种情况。
此参数可用于权衡内存使用量和性能。
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
channels¶ (int, 可选, 默认值 = 3) – 通道数。
dont_use_mmap¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则加载器将使用普通文件 I/O，而不是尝试在内存中映射文件。
当访问本地文件系统时，映射提供了一定的性能优势，但大多数网络文件系统都无法提供最佳性能。
dtype¶ (
nvidia.dali.types.DALIDataType, 可选, 默认值 = DALIDataType.UINT8) –输出数据类型。
支持的类型：
UINT8或FLOAT。enable_frame_num¶ (bool, 可选, 默认值 = False) – 如果传递了
file_list或filenames参数，则返回帧号输出。enable_timestamps¶ (bool, 可选, 默认值 = False) – 如果传递了
file_list或filenames参数，则返回时间戳输出。file_list¶ (str, 可选, 默认值 = ‘’) –
包含
文件 标签 [起始帧 [结束帧]]值列表的文件的路径。正值表示确切的帧，负值表示从末尾开始的第 N 帧（遵循 python 数组索引模式），起始帧和结束帧的相等值将产生一个空序列和一个警告。此选项与
filenames和file_root互斥。file_list_frame_num¶ (bool, 可选, 默认值 = False) –
如果在 file_list 中提供了起始/结束时间戳，您可以将它们解释为帧号而不是时间戳。
如果提供了浮点值，起始帧号将向上取整，结束帧号将向下取整。
帧号从 0 开始计数。
file_list_include_preceding_frame¶ (bool, 可选, 默认值 = 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, 可选, 默认值 = ‘’) –
包含数据文件的目录的路径。
filenames¶ (str 或 str 列表, 可选, 默认值 = []) –
要加载的视频文件的文件名。
image_type¶ (
nvidia.dali.types.DALIImageType, 可选, 默认值 = DALIImageType.RGB) – 输出帧的色彩空间（RGB 或 YCbCr）。initial_fill¶ (int, 可选, 默认值 = 1024) –
用于洗牌的缓冲区大小。
如果
random_shuffle为 False，则忽略此参数。labels¶ (int 或 int 列表, 可选) –
与
filenames参数中列出的文件关联的标签。如果提供空列表，则顺序的从 0 开始的索引将用作标签。 如果未提供，则不会生成标签。
lazy_init¶ (bool, 可选, 默认值 = False) – 仅在首次运行时解析和准备数据集元数据，而不是在构造函数中。
normalized¶ (bool, 可选, 默认值 = False) – 获取归一化数据作为输出。
num_shards¶ (int, 可选, 默认值 = 1) –
将数据划分为指定数量的部分（分片）。
这通常用于多 GPU 或多节点训练。
pad_last_batch¶ (bool, 可选, 默认值 = False) –
如果设置为 True，则通过重复最后一个样本来填充分片。
注意
如果各个分片之间的批次数不同，则此选项可能会导致将整个重复样本批次添加到数据集。
pad_sequences¶ (bool, 可选, 默认值 = False) –
如果视频末尾的帧数不足，则允许创建不完整的序列。
冗余帧将被置零。 相应的时间戳和帧号将设置为 -1。
prefetch_queue_depth¶ (int, 可选, 默认值 = 1) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, 可选, 默认值 = False) – 阻止运算符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, 可选, 默认值 = False) –
确定是否随机打乱数据。
大小等于
initial_fill的预取缓冲区用于顺序读取数据，然后随机选择样本以形成批次。read_ahead¶ (bool, 可选, 默认值 = False) –
确定是否应预读访问的数据。
对于大型文件，例如 LMDB、RecordIO 或 TFRecord，此参数会减慢首次访问速度，但会缩短所有后续访问的时间。
seed¶ (int, 可选, 默认值 = -1) – 随机种子；如果未设置，将自动分配一个。
sequence_length¶ (int) – 每个序列要加载的帧数。
shard_id¶ (int, 可选, 默认值 = 0) – 要读取的分片索引。
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) – 序列中连续帧之间的距离。
tensor_init_bytes¶ (int, 可选, 默认值 = 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，则加载器将使用普通文件 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 = ‘’) –
包含
文件 标签 [起始帧 [结束帧]]值列表的文件的路径。正值表示确切的帧，负值表示从结尾开始的第 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) –
用于洗牌的缓冲区大小。
如果
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，应将其替换为
启用
antialias的 INTERP_LINEAR。labels¶ (int 或 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 或 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) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, optional, default = False) – 阻止操作符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, optional, default = False) –
确定是否随机打乱数据。
大小等于
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互斥。如果未指定或为 0，则操作符保持原始图像的宽高比。resize_y负值会翻转图像。resize_y¶ (float or TensorList of float, optional, default = 0.0) –
调整大小后图像的 Y 维度长度。
此选项与
resize_shorter、resize_longer和size互斥。如果未指定或为 0，则操作符保持原始图像的宽高比。resize_x负值会翻转图像。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 或 list of float 或 TensorList of float, optional) –
输入感兴趣区域 (ROI) 的结束坐标。
必须与
roi_start一起指定。坐标遵循张量形状顺序，与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标 (0..1)，具体取决于relative_roi参数的值。如果任何维度中的 ROI 起点大于 ROI 终点，则该区域在该维度中翻转。roi_relative¶ (bool, optional, default = False) – 如果为 true，则 ROI 坐标相对于输入大小，其中 0 表示顶部/左侧，1 表示底部/右侧
roi_start¶ (float 或 list of float 或 TensorList of float, optional) –
输入感兴趣区域 (ROI) 的起始坐标。
必须与
roi_end一起指定。坐标遵循张量形状顺序，与size相同。坐标可以是绝对坐标（以像素为单位，这是默认值）或相对坐标 (0..1)，具体取决于relative_roi参数的值。如果任何维度中的 ROI 起点大于 ROI 终点，则该区域在该维度中翻转。seed¶ (int, optional, default = -1) – 随机种子；如果未设置，将自动分配一个。
sequence_length¶ (int) – 每个序列加载的帧数。
shard_id¶ (int, optional, default = 0) – 要读取的分片索引。
size¶ (float 或 list of float 或 TensorList of float, optional) –
期望的输出尺寸。
必须是每个空间维度（不包括视频帧和通道）一个条目的列表/元组。维度为 0 的范围被视作不存在，输出大小将基于其他范围和
mode参数计算。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) – 序列中连续帧之间的距离。
subpixel_scale¶ (bool, optional, default = True) –
如果为 True，则直接指定或计算出的分数尺寸将导致调整输入 ROI 以保持缩放比例。
否则，将调整缩放比例，以使源图像映射到舍入后的输出尺寸。
temp_buffer_hint¶ (int, optional, default = 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，则加载器将使用普通文件 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) –
用于洗牌的缓冲区大小。
如果
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) –
指定内部加载器要预取的批次数。
当 pipeline 受 CPU 阶段限制时，应增加此值，以内存消耗换取与加载器线程的更好交错。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未使用。
random_shuffle¶ (bool, 可选, 默认 = False) –
确定是否随机打乱数据。
使用大小等于
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 或 int列表, 可选) –
执行归约的轴或轴。
接受范围为 [-ndim, ndim-1]。负索引从后往前计数。
不提供任何轴将导致所有元素的归约。
执行归约的轴或轴的名称。
输入布局用于将轴名称转换为轴索引，例如，对于输入布局 “FHWC”，
axis_names="HW"等效于指定axes=[1,2]。此参数不能与axes一起使用。bytes_per_sample_hint¶ (int 或 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 or 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 or 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.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 or 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 or 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.Min(*, axes=None, axis_names=None, bytes_per_sample_hint=[0], keep_dims=False, preserve=False, device=None, name=None)#
获取沿指定轴的元素的最小值。
- 支持的后端
‘cpu’
‘gpu’
- 关键词参数:
axes¶ (int or 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
keep_dims¶ (bool, optional, default = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, optional, default = 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 or 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 or 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.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 or 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
ddof¶ (int, optional, default = 0) – 自由度增量。调整计算中使用的除数，即 N - ddof。
keep_dims¶ (bool, optional, default = False) – 如果为 True，则保持原始输入维度。
preserve¶ (bool, optional, default = 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 or 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 or 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 or 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 or list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
ddof¶ (int, optional, default = 0) – 自由度增量。调整计算中使用的除数，即 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”（默认）- 有两个输出：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’
- 关键词参数:
bytes_per_sample_hint¶ (int 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
reindex_masks¶ (bool, optional, default = False) – 如果设置为 True，则输出掩码 ID 将替换为它们在
mask_ids输入中出现的索引。
- __call__(__mask_ids, __polygons, __vertices, /, *, bytes_per_sample_hint=[0], preserve=False, reindex_masks=False, device=None, name=None)#
要在图形定义中使用的操作符调用。
- 参数:
__mask_ids¶ (1D TensorList of int) – 要选择的掩码的标识符列表。 该列表不应包含重复项。
__polygons¶ (2D TensorList of int) –
由 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 documentation section。
- 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 或 list of int, optional, default = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
preserve¶ (bool, optional, default = False) – 阻止运算符从图中移除，即使其输出未使用。
reverse_order¶ (bool, optional, default = 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 列表或 TensorList of float, 可选, 默认 = [1.0]) –
原始坐标空间的上限。
注意
如果留空，则将假定为单位向量。如果提供单个值，则会重复该值以匹配维度数
支持
per-frame输入。from_start¶ (float 或 float 列表或 TensorList of float, 可选, 默认 = [0.0]) –
原始坐标空间的下限。
注意
如果留空，则将假定为零向量。如果提供单个值，则会重复该值以匹配维度数
支持
per-frame输入。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认值），则运算符的仿射变换将应用于输入变换。 如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
to_end¶ (float 或 float 列表或 TensorList of float, 可选, 默认 = [1.0]) –
目标坐标空间的上限。
注意
如果留空，则将假定为单位向量。如果提供单个值，则会重复该值以匹配维度数
支持
per-frame输入。to_start¶ (float 或 float 列表或 TensorList of float, 可选, 默认 = [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 或 TensorList of float) –
角度，以度为单位。
支持
per-frame输入。axis¶ (float 或 list of float 或 TensorList of float, optional) –
旋转轴（仅适用于 3D 变换）。
该向量不需要归一化，但必须具有非零长度。
反转向量等效于更改
angle的符号。支持
per-frame输入。bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
center¶ (float 或 list of float 或 TensorList of float, optional) –
旋转中心。
如果提供，则元素的数量应与变换的维度相匹配。
支持
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 或 list of float 或 TensorList of float, optional) –
缩放操作的中心。
如果提供，则元素的数量应与
scale参数的数量相匹配。支持
per-frame输入。ndim¶ (int, optional) –
维度数。
当无法推断维度数时，应提供此参数。例如，当
scale是标量值且没有输入变换时。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认值），则运算符的仿射变换将应用于输入变换。 如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
scale¶ (float 或 list of float 或 TensorList of float) –
每个维度的缩放因子。
变换的维度数从此参数推断。
支持
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 或 list of float 或 TensorList of float, optional) –
剪切角，以度为单位。
此参数与
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 或 list of float 或 TensorList of float, optional) –
剪切操作的中心。
如果提供，则元素的数量应与变换的维度相匹配。
支持
per-frame输入。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未使用。
reverse_order¶ (bool, 可选, 默认 = False) –
确定组合仿射变换时的顺序。
如果设置为 False（默认值），则运算符的仿射变换将应用于输入变换。 如果设置为 True，则输入变换将应用于运算符的变换。
如果没有输入，则忽略此参数。
shear¶ (float 或 list of float 或 TensorList of float, optional) –
剪切因子。
对于 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 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
offset¶ (float 或 list of float 或 TensorList of float) –
平移向量。
变换的维度数从此参数推断。
支持
per-frame输入。preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未使用。
reverse_order¶ (bool, 可选, 默认 = 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 函数应该是一个可以在 Numba
nopython模式下编译的 Python 函数。 接受单个输入并产生单个输出的函数应遵循以下定义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作用域之外）定义函数。如果函数是另一个“工厂”函数的结果，则工厂函数必须在管道定义函数之外定义，并使用
@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, 可选, 默认 = False) –
确定函数是为每个批次调用一次，还是为批次中的每个样本单独调用。
当
batch_processing设置为True时，该函数处理整个批次。 如果函数必须执行跨样本操作，并且可以重用大部分工作，则这是必要的。 对于其他用例，指定 False 并使用每样本处理函数允许运算符并行处理样本。blocks¶ (int 或 list of int, optional) –
- 3 项列表，指定每个网格的块数，用于
执行 CUDA 内核
bytes_per_sample_hint¶ (int 或 int 列表, 可选, 默认 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
in_types¶ (DALIDataType 或 list of DALIDataType) – 输入的类型。
ins_ndim¶ (int 或 list of int) – 输入形状应具有的维度数。
out_types¶ (DALIDataType 或 list of DALIDataType) – 输出的类型。
outs_ndim¶ (int 或 list of int) – 输出形状应具有的维度数。
preserve¶ (bool, 可选, 默认 = False) – 阻止运算符从图中移除，即使其输出未使用。
run_fn¶ (object) – 要调用的函数。 此函数必须在 Numba
nopython模式下工作。setup_fn¶ (object, optional) – 用于设置输出形状的设置函数。此函数在每个批次调用一次。此外，此函数必须在 Numba
nopython模式下工作。threads_per_block¶ (int 或 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, 默认值 = True) – 确定函数是否将整个批次作为输入。
bytes_per_sample_hint¶ (int 或 int 列表, optional, 默认值 = [0]) –
输出大小提示，以每样本字节数为单位。
如果指定，则将预先分配驻留在 GPU 或页锁定主机内存中的操作符输出，以容纳此大小的一批样本。
function¶ (object) –
定义操作符功能的可调用对象。
警告
该函数不得持有对其使用的 pipeline 的引用。如果持有，将形成对 pipeline 的循环引用，并且 pipeline 将永远不会被释放。
num_outputs¶ (int, optional, 默认值 = 1) – 输出数量。
output_layouts¶ (layout str 或 layout str 列表, optional) –
输出的张量数据布局。
此参数可以是列表，其中包含每个输出的不同布局。如果列表的元素少于 num_outputs，则仅设置前几个输出的布局，其余输出不分配布局。
preserve¶ (bool, optional, 默认值 = 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 内存。注意
这是一个实验性功能，如有更改，恕不另行通知。