NVIDIA DALI

https://docs.nvidia.com/deeplearning/dali/user-guide/
Admin
NVIDIA DALI is a library designed to accelerate data loading and preprocessing pipelines for deep...
Tokens:197,188
Snippets:1,724
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install DALI Python Bindings

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/compilation.html

Install the Python bindings for DALI after building the library. This step is necessary to use DALI's Python API.

```bash
cd build
pip install dali/python
```

--------------------------------

### Install dali-dynamic-mode Skill

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html#

Installs the dali-dynamic-mode skill for AI agents, providing guidance on the Dynamic Mode API and best practices. This command is executed using npx.

```bash
npx skills add nvidia/skills --skill dali-dynamic-mode
```

--------------------------------

### TFRecord Reader Initialization Example

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.TFRecord.html

Demonstrates how to initialize the TFRecord reader with various options for shuffling and caching.

```python
dali.fn.readers.tfrecord(
    filename=dali.fn.external_source(source_fn, num_outputs=1, dtype=types.STRING),
    index_filename=dali.fn.external_source(index_fn, num_outputs=1, dtype=types.STRING),
    random_shuffle=True,
    shuffle_after_epoch=True,
    shuffle_after_epoch_seed=42,
    skip_cached_images=True,
    stick_to_shard=False,
    tensor_init_bytes=1048576,
    use_o_direct=True,
    data_layout=types.NHWC,
    features={'image': (3, 256, 256, types.DALIDataType.FLOAT),
              'label': ()}
)
```

--------------------------------

### NemoAsr Reader Configuration

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.NemoAsr.html

Example of how to instantiate the NemoAsr reader with manifest file paths. This reader processes audio and text data from a NeMo-compatible manifest.

```python
pipeline.load(nvidia.dali.experimental.dynamic.readers.NemoAsr(manifest_filepaths=['manifest.json'], read_text=True, read_sample_rate=True))
```

--------------------------------

### Samplewise Slicing with Batch Parameters

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/api_reference.html

Illustrates how to perform sample-wise slicing on a batch where slicing parameters (start, stop, step) are themselves batches. This allows for flexible and varied slicing across samples.

```python
start = Batch([1, 2, 3])
stop = Batch([4, 5, 6])
step = Batch([1, 1, 2])
sliced = input.slice[start, stop, step]
# the result is equivalent to
sliced = Batch([
    sample[start[i]:stop[i]:step[i]]
    for i, sample in enumerate(input)
])
```

--------------------------------

### Initialize DALI Dynamic Mode

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html#

Imports necessary libraries for DALI's dynamic mode and sets up the environment. This is a starting point for using dynamic data loading.

```python
import os
import nvidia.dali.types as types
import nvidia.dali.experimental.dynamic as ndd
import torch

# To run with different data, see documentation of ndd.readers.File

```

--------------------------------

### Running with Sanitizers

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/compilation.html

This example shows how to run DALI with AddressSanitizer (ASAN) enabled. It requires setting the LD_LIBRARY_PATH, ASAN_OPTIONS, and LD_PRELOAD environment variables, and specifying the path to the LLVM symbolizer and the libasan and libstdc++ libraries.

```bash
LD_LIBRARY_PATH=. ASAN_OPTIONS=symbolize=1:protect_shadow_gap=0 ASAN_SYMBOLIZER_PATH=$(shell which llvm-symbolizer)
LD_PRELOAD=PATH_TO_LIB_ASAN/libasan.so.X PATH_TO_LIB_STDC/libstdc++.so.STDC_VERSION*PATH_TO_BINARY*

Where X depends on used compiler version, for example GCC 10.x uses 6. Tested with GCC 10.2.1, CUDA 12.0
and libasan.6. Any earlier version may not work.

STDC_VERSION used by the system. Usually 6.
```

--------------------------------

### Rotate Bounding Boxes and Image

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.bbox_rotate.html

Example demonstrating how to rotate bounding boxes and the corresponding image using DALI operators. Ensure bounding boxes are rotated before the image.

```python
boxes, labels = fn.bbox_rotate(
  boxes, labels, angle=angle, input_shape=image.shape(), keep_size=keep_size
)
image = fn.rotate(image, angle=angle, keep_size=keep_size)
```

--------------------------------

### Example of Ragged Batching with DALI Backend

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/FAQ.html

This Python script demonstrates how to use the ragged batching feature with the DALI Backend for Triton Inference Server. It shows how to send non-uniform batches.

```python
import os
import sys
import time
import json
import numpy as np

import tritonclient.http as httpclient
from tritonclient.utils import InferenceServerException

# Example of a client that sends a batch of samples of different shapes
# (files with different lengths)

#------------------------------------------------------------------------------
#------------------------------------------------------------------------------

def main():
    FLAGS = {
        "url": "localhost:8000",
        "protocol": "http",
        "model_name": "dali_ragged_batching",
        "model_version": None,
        "batch_size": 1,
        "concurrency": 1,
        "input_name": "input",
        "input_type": "FP32",
        "output_name": "output",
        "output_type": "FP32",
        "shape": None,
        "save_path": None,
        "verbose": 0
    }

    if FLAGS["model_name"] is None:
        raise Exception("model-name must be specified.")

    # Create client
    try:
        triton_client = httpclient.InferenceServerClient(url=FLAGS["url"])
    except Exception as e:
        print("client creation failed: " + str(e))
        sys.exit(1)

    # Health check
    if not triton_client.is_server_live():
        print("FAILED: server is not live")
        sys.exit(1)

    if not triton_client.is_model_ready(FLAGS["model_name"]):
        print("FAILED: model is not ready")
        sys.exit(1)

    # Prepare inputs
    inputs = []
    input_name = FLAGS["input_name"]
    input_type = FLAGS["input_type"]
    output_name = FLAGS["output_name"]
    output_type = FLAGS["output_type"]

    # DALI backend expects the input shape to be a list of shapes
    # For ragged batching, we need to specify the shape of each sample in the batch
    # Here we create a batch of 3 samples with different shapes
    shapes = [[1, 2], [2, 3], [3, 4]]
    input_batch = []
    for shape in shapes:
        input_batch.append(np.random.rand(*shape).astype(np.float32))

    # DALI backend expects the input to be a list of tensors, each tensor representing a sample
    # The shape of each tensor is specified in the 'shapes' argument
    # The 'shape' argument is a list of shapes, where each shape is a list of integers
    # For example, if we have a batch of 3 samples with shapes [1, 2], [2, 3], [3, 4],
    # the 'shapes' argument would be [[1, 2], [2, 3], [3, 4]]
    # The 'input_batch' argument is a list of numpy arrays, where each array is a sample
    # The shape of each numpy array must match the corresponding shape in the 'shapes' argument
    inputs.append(httpclient.InferInput(input_name, [1, 1], input_type))
    inputs[0].set_data_from_numpy(np.array(input_batch, dtype=np.float32), binary_data=True)

    # DALI backend expects the output to be a list of tensors, each tensor representing a sample
    # The shape of each tensor is specified in the 'shapes' argument
    # The 'shapes' argument is a list of shapes, where each shape is a list of integers
    # For example, if we have a batch of 3 samples with shapes [1, 2], [2, 3], [3, 4],
    # the 'shapes' argument would be [[1, 2], [2, 3], [3, 4]]
    # The 'output_name' argument is the name of the output tensor
    # The 'output_type' argument is the data type of the output tensor
    outputs = [
        httpclient.InferRequestedOutput(output_name, binary_data=True)
    ]

    # Send inference request
    try:
        start_time = time.time()
        results = triton_client.infer(FLAGS["model_name"], inputs, request_id=str(1), outputs=outputs)
        end_time = time.time()

        # Process results
        output_data = results.as_numpy(output_name)
        print(f"Received output of shape: {output_data.shape}")
        print(f"Output data:\n{output_data}")
        print(f"Inference time: {end_time - start_time:.2f} sec")

    except InferenceServerException as e:
        print(str(e))
        sys.exit(1)

    print("\nCompleted inference.")

if __name__ == '__main__':
    main()

```

--------------------------------

### Pad Sequence with Last Frame using DALI Video Decoder

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.decoders.video.html

When the requested sequence exceeds video bounds, use `pad_mode='edge'` to pad with the last available frame. This example requests 100 frames starting from frame 0 with a stride of 2.

```python
video_decoder = dali.experimental.decoders.Video(
    encoded=encoded_video,
    start_frame=0, sequence_length=100, stride=2, pad_mode="edge"
    ...,
)
```

--------------------------------

### Import necessary libraries and set up constants

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/checkpointing_tutorial.html

Imports DALI experimental dynamic module, NumPy, Matplotlib, and OS. Sets the image directory and batch size for the pipeline.

```python
import os
import numpy as np
import matplotlib.pyplot as plt

import nvidia.dali.experimental.dynamic as ndd

IMAGE_DIR = os.path.join(os.environ["DALI_EXTRA_PATH"], "db", "single", "mixed")
BATCH_SIZE = 8
```

--------------------------------

### nvidia.dali.experimental.dynamic.decoders.image_slice

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.decoders.image_slice.html

Decodes images and extracts regions of interest. The slice can be specified by providing the start and end coordinates, or start coordinates and shape of the slice. Both coordinates and shapes can be provided in absolute or relative terms.

```APIDOC
## nvidia.dali.experimental.dynamic.decoders.image_slice

### Description
Decodes images and extracts regions of interest. The slice can be specified by providing the start and end coordinates, or start coordinates and shape of the slice. Both coordinates and shapes can be provided in absolute or relative terms.

### Parameters
#### Slice Definition
- **start** (coordinates) - Slice start coordinates (absolute).
- **rel_start** (coordinates) - Slice start coordinates (relative).
- **end** (coordinates) - Slice end coordinates (absolute).
- **rel_end** (coordinates) - Slice end coordinates (relative).
- **shape** (shape) - Slice shape (absolute).
- **rel_shape** (shape) - Slice shape (relative).

### Notes
The slice arguments can be mixed (e.g., `rel_start` can be used with `shape`) as long as start and shape or end are uniquely defined.
```

--------------------------------

### Listing Files from Directory with Subdirectory Labels

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.File.html

This example demonstrates how to use the File reader to list files from a directory, where labels are derived from the subdirectory names. It shows the default behavior and how file filters can be applied to select specific file types.

```python
# Example directory structure:
# <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

# Default behavior (all files listed):
# <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

# With 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
```

--------------------------------

### reductions.variance

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets variance of elements along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.variance

### Description
Gets variance of elements along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### reductions.sum

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets sum of elements along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.sum

### Description
Gets sum of elements along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### reductions.mean

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets mean of elements along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.mean

### Description
Gets mean of elements along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### nvidia.dali.experimental.dynamic.experimental.decoders.image_slice

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.experimental.decoders.image_slice.html

Decodes images and extracts regions of interest. Supported formats include JPEG, JPEG 2000, TIFF, PNG, BMP, PNM, PPM, PGM, PBM, and WebP. The output is in HWC layout. The slice can be defined using start and end coordinates, or start coordinates and shape, with options for absolute or relative values.

```APIDOC
## nvidia.dali.experimental.dynamic.experimental.decoders.image_slice

### Description
Decodes images and extracts regions of interest. Supported formats include JPEG, JPEG 2000, TIFF, PNG, BMP, PNM, PPM, PGM, PBM, and WebP. The output is in HWC layout.

### Parameters

*   **data** - Input image data.
*   **anchor** (optional) - Anchor point for the slice.
*   **shape_input** (optional) - Shape of the input.
*   **batch_size** (optional) - Batch size.
*   **device** (optional) - Device to perform the operation on.
*   **adjust_orientation** (optional) - Whether to adjust orientation.
*   **affine** (optional) - Affine transformation matrix.
*   **axes** (optional) - Axes to consider for slicing.
*   **axis_names** (optional) - Names of the axes.
*   **device_memory_padding** (optional) - Padding for device memory.
*   **device_memory_padding_jpeg2k** (optional) - Padding for device memory for JPEG 2000.
*   **dtype** (optional) - Data type of the output.
*   **end** (optional) - Slice end coordinates (absolute).
*   **host_memory_padding** (optional) - Padding for host memory.
*   **host_memory_padding_jpeg2k** (optional) - Padding for host memory for JPEG 2000.
*   **hw_decoder_load** (optional) - Hardware decoder load.
*   **hybrid_huffman_threshold** (optional) - Hybrid Huffman threshold.
*   **jpeg_fancy_upsampling** (optional) - Whether to use fancy upsampling for JPEG.
*   **memory_stats** (optional) - Whether to collect memory statistics.
*   **normalized_anchor** (optional) - Normalized anchor point.
*   **normalized_shape** (optional) - Normalized shape.
*   **output_type** (optional) - Output type.
*   **preallocate_height_hint** (optional) - Hint for preallocating height.
*   **preallocate_width_hint** (optional) - Hint for preallocating width.
*   **rel_end** (optional) - Slice end coordinates (relative).
*   **rel_shape** (optional) - Slice shape (relative).
*   **rel_start** (optional) - Slice start coordinates (relative).
*   **shape** (optional) - Slice shape (absolute).
*   **split_stages** (optional) - Whether to split stages.
*   **start** (optional) - Slice start coordinates (absolute).
*   **use_chunk_allocator** (optional) - Whether to use chunk allocator.
*   **use_fast_idct** (optional) - Whether to use fast IDCT.

### Slice Definition
The slice can be configured by providing start and end coordinates or start and shape. Relative and absolute arguments can be mixed as long as start and shape or end are uniquely defined.

*   **start**: Slice start coordinates (absolute).
*   **rel_start**: Slice start coordinates (relative).
*   **end**: Slice end coordinates (absolute).
*   **rel_end**: Slice end coordinates (relative).
*   **shape**: Slice shape (absolute).
*   **rel_shape**: Slice shape (relative).

```

--------------------------------

### reductions.std_dev

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets standard deviation of elements along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.std_dev

### Description
Gets standard deviation of elements along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### Configure DALI Build with CMake

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/compilation.html

Run CMake to configure the build. Use CMAKE_BUILD_TYPE=Release for optimized builds. Refer to optional CMake parameters for more configuration options.

```bash
cmake -D CMAKE_BUILD_TYPE=Release ..
```

--------------------------------

### reductions.min

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets minimal input element along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.min

### Description
Gets minimal input element along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### Audio Resample Data Type Conversion Example

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.audio_resample.html

Demonstrates how input audio data is normalized and converted to different data types, including floating-point to integer and between signed/unsigned integers. Pay attention to the mapping of values for each conversion.

```python
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
```

--------------------------------

### reductions.mean_square

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets mean square of elements along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.mean_square

### Description
Gets mean square of elements along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### reductions.max

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets maximal input element along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.max

### Description
Gets maximal input element along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### Random Crop Generation and Slicing

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.random_crop_generator.html

This example demonstrates how to use `random_crop_generator` to obtain random crop parameters (anchor and shape) and then apply them using `fn.slice` to crop an image. Ensure that `image_shapes` is a tensor representing the input image dimensions.

```python
crop_anchor, crop_shape = fn.random_crop_generator(image_shapes)
images_crop = fn.slice(images, start=crop_anchor, shape=crop_shape, axes=[0, 1])
```

--------------------------------

### nvidia.dali.experimental.dynamic.get_default_stream

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/api_reference.html

Gets the default stream. This stream is used when not overridden by the thread's current stream.

```APIDOC
## nvidia.dali.experimental.dynamic.get_default_stream

### Description
Gets the default stream. This stream is used when not overridden by thread’s current stream.

### Method Signature
nvidia.dali.experimental.dynamic.get_default_stream(device_id=None)

### Parameters
#### Keyword Arguments
- **device_id** (int or None, optional) - Specifies the device for which to retrieve the default stream.
```

--------------------------------

### nvidia.dali.experimental.dynamic.readers.VideoResize

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.VideoResize.html

Configuration options for the VideoResize reader.

```APIDOC
## nvidia.dali.experimental.dynamic.readers.VideoResize

### Description
Resizes video frames to a specified output size. This operation can handle region of interest (ROI) selection and sequence-based processing.

### Parameters

#### Optional Parameters
- **roi_relative** (bool, optional, default = False) – If true, ROI coordinates are relative to the input size, where 0 denotes top/left and 1 denotes bottom/right.
- **roi_start** (_float_ or _list_ of _float_ or _Tensor/Batch_ of _float_, optional) – Origin of the input region of interest (ROI). Must be specified together with `roi_end`. The coordinates follow the tensor shape order. The coordinates can be either absolute (in pixels, which is the default) or relative (0..1), depending on the value of `relative_roi` argument. If the ROI origin is greater than the ROI end in any dimension, the region is flipped in that dimension.
- **seed** (int, optional, default = -1) – Random seed; if not set, one will be assigned automatically.
- **sequence_length** (_int_) – Frames to load per sequence.
- **shard_id** (int, optional, default = 0) – Index of the shard to read.
- **size** (_float_ or _list_ of _float_ or _Tensor/Batch_ of _float_, optional) – The desired output size. Must be a list/tuple with one entry per spatial dimension, excluding video frames and channels. Dimensions with a 0 extent are treated as absent, and the output size will be calculated based on other extents and `mode` argument.
- **skip_cached_images** (bool, optional, default = False) – If set to True, the loading data will be skipped when the sample is in the decoder cache. In this case, the output of the loader will be empty.
- **skip_vfr_check** (bool, optional, default = False) – Skips the check for the variable frame rate (VFR) videos. Use this flag to suppress false positive detection of VFR videos. Warning: When the dataset indeed contains VFR files, setting this flag may cause the decoder to malfunction.
- **step** (int, optional, default = -1) – Frame interval between each sequence.
```

--------------------------------

### min

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.min.html

Gets minimal input element along provided axes. Supported backends: 'cpu', 'gpu'.

```APIDOC
## nvidia.dali.experimental.dynamic.reductions.min

### Description
Gets minimal input element along provided axes. Supported backends: 'cpu', 'gpu'.

### Method Signature
```python
min(
    _input_,
    _/_,
    _*_,
    batch_size=None,
    device=None,
    axes=None,
    axis_names=None,
    keep_dims=None,
)
```

### Parameters
* **input** (_Tensor/Batch_) – Input to the operator.

#### Keyword Arguments
* **axes** (_int_ or _list_ _of_ _int_, _optional_) – Axis or axes along which reduction is performed. Accepted range is [-ndim, ndim-1]. Negative indices are counted from the back. Not providing any axis results in reduction of all elements.
* **axis_names** (_layout str, optional_) – Name(s) of the axis or axes along which the reduction is performed. The input layout is used to translate the axis names to axis indices, for example `axis_names="HW"` with input layout “FHWC” is equivalent to specifying `axes=[1,2]`. This argument cannot be used together with `axes`.
* **keep_dims** (_bool, optional, default = False_) – If True, maintains original input dimensions.
* **batch_size** (_int, _optional_) – The batch size to broadcast input tensors to. Ignored for batch inputs.
* **device** (_device-like, _optional_) – The device to use for the operation. Must not conflict with the device of the inputs.
```

--------------------------------

### Debayering a Batch of Image Sequences

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.debayer.html

This snippet demonstrates how to debayer a batch of image sequences using the `fn.experimental.debayer` operator. It shows how to retrieve video data and blue positions from an external source and apply the debayering operation on the GPU.

```python
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, algorithm='default_npp')
  return debayered_sequences
```

--------------------------------

### reductions.rms

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.html

Gets root mean square of elements along provided axes. Supports CPU and GPU.

```APIDOC
## reductions.rms

### Description
Gets root mean square of elements along provided axes.

### Device Support
CPU, GPU
```

--------------------------------

### max

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.reductions.max.html

Gets maximal input element along provided axes. Supported backends: 'cpu', 'gpu'.

```APIDOC
## max

### Description
Gets maximal input element along provided axes.

### Parameters
* `_input_` (Tensor/Batch): Input to the operator.

### Keyword Arguments
* `axes` (int or list of int, optional): Axis or axes along which reduction is performed. Accepted range is [-ndim, ndim-1]. Negative indices are counted from the back. Not providing any axis results in reduction of all elements.
* `axis_names` (layout str, optional): Name(s) of the axis or axes along which the reduction is performed. The input layout is used to translate the axis names to axis indices, for example `axis_names="HW"` with input layout “FHWC” is equivalent to specifying `axes=[1,2]`. This argument cannot be used together with `axes`.
* `keep_dims` (bool, optional, default = False): If True, maintains original input dimensions.
* `batch_size` (int, optional): The batch size to broadcast input tensors to. Ignored for batch inputs.
* `device` (device-like, optional): The device to use for the operation. Must not conflict with the device of the inputs.
```

--------------------------------

### Build DALI with Make

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/compilation.html

Compile the DALI library using Make. The -j option allows parallel compilation for faster build times.

```bash
make -j"$(nproc)"
```

--------------------------------

### Build DALI Python Wheel

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/compilation.html

Navigate to the docker directory and execute the build script. Environment variables can be set to customize the build process, including CUDA version and whether to create a TensorFlow plugin.

```bash
CUDA_VERSION=Z ./build.sh
```

```bash
CUDA_VERSION=12.1 ./build.sh
```

--------------------------------

### Reading File List from a Text File

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.File.html

This example shows how to use the File reader when file names and their corresponding labels are stored in a text file, with one entry per line. File names can contain spaces, but not trailing whitespace.

```python
# Example file_list content:
dog.jpg 0
cute kitten.jpg 1
doge.png 0
```

--------------------------------

### Tensor.torch

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/api_reference.html

Converts the DALI tensor into a PyTorch tensor. This operation requires PyTorch to be installed. A copy can be optionally performed.

```APIDOC
## Tensor.torch

### Description
Returns `self` as a PyTorch tensor. Requires PyTorch to be installed.

### Method
N/A (Method of Tensor object)

### Parameters
#### Query Parameters
- **copy** (bool) - Optional - Boolean indicating whether to perform a copy. Defaults to False.

### Response
#### Success Response
- **torch.Tensor**: The tensor represented as a PyTorch tensor.
```

--------------------------------

### Webdataset Reader Initialization

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.Webdataset.html

Initializes the Webdataset reader with various configuration options for loading data from tar archives.

```APIDOC
## nvidia.dali.experimental.dynamic.readers.Webdataset

### Description
A reader for the webdataset format. The webdataset format is a way of providing efficient access to datasets stored in tar archives. Storing data in POSIX tar archives greatly speeds up I/O operations on mechanical storage devices and on network file systems because it allows the operating system to reduce the number of I/O operations and to read the data ahead.

### Parameters
* **_max_batch_size** (int, optional): Maximum batch size for the reader.
* **_name** (str, optional): Name for the reader.
* **_device** (str, optional): Device to use for reading ('cpu'). Defaults to 'cpu'.
* **_num_inputs** (int, optional): Number of inputs for the reader.
* **case_sensitive_extensions** (bool, optional): Whether to treat file extensions case-sensitively.
* **dont_use_mmap** (bool, optional): Whether to disable memory mapping.
* **dtypes** (list of DALI types, optional): List of data types for the components.
* **_ext** (list of str, optional): List of expected file extensions for components.
* **index_paths** (list of str, optional): Paths to the index files for the archives.
* **initial_fill** (int, optional): Initial number of samples to fill.
* **lazy_init** (bool, optional): Whether to initialize the reader lazily.
* **missing_component_behavior** (str, optional): Behavior when a component is missing.
* **num_shards** (int, optional): Number of shards for distributed reading.
* **pad_last_batch** (bool, optional): Whether to pad the last batch.
* **_paths_** (list of str): Paths to the tar archives.
* **prefetch_queue_depth** (int, optional): Depth of the prefetch queue.
* **random_shuffle** (bool, optional): Whether to shuffle the data randomly.
* **read_ahead** (int, optional): Number of samples to read ahead.
* **_seed** (int, optional): Seed for random number generation.
* **shard_id** (int, optional): ID of the current shard.
* **shuffle_after_epoch** (bool, optional): Whether to shuffle the data after each epoch.
* **shuffle_after_epoch_seed** (int, optional): Seed for shuffling after each epoch.
* **skip_cached_images** (bool, optional): Whether to skip cached images.
* **stick_to_shard** (bool, optional): Whether to stick to the current shard.
* **tensor_init_bytes** (int, optional): Number of bytes to initialize tensors with.
* **enable_checkpointing** (bool, optional): Whether to enable checkpointing. Defaults to False.
* **__backend** (str, optional): Backend to use for the reader.
```

--------------------------------

### Image Slice Parameters

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.decoders.image_slice.html

Details on parameters for the image slicing operation, including relative start coordinates and shape.

```APIDOC
## nvidia.dali.experimental.dynamic.decoders.image_slice

### Description
Extracts a slice from an image based on specified coordinates and shape.

### Parameters
#### Optional Parameters
- **rel_start** (float or list of float or Tensor/Batch of float) - Optional - Start relative coordinates of the slice (range [0.0 - 1.0]).
- **shape** (int or list of int or Tensor/Batch of int) - Optional - Shape of the slice.
- **split_stages** (bool) - Optional - This argument is no longer used and will be removed in a future release.

### Notes
Providing named arguments [`start`](#nvidia.dali.experimental.dynamic.decoders.image_slice.params.start), [`end`](#nvidia.dali.experimental.dynamic.decoders.image_slice.params.end), [`shape`](#nvidia.dali.experimental.dynamic.decoders.image_slice.params.shape), [`rel_start`](#nvidia.dali.experimental.dynamic.decoders.image_slice.params.rel_start), [`rel_end`](#nvidia.dali.experimental.dynamic.decoders.image_slice.params.rel_end), [`rel_shape`](#nvidia.dali.experimental.dynamic.decoders.image_slice.params.rel_shape) is incompatible with providing positional inputs anchor and shape.
```

--------------------------------

### nvidia.dali.experimental.dynamic.erase

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.erase.html

Erases one or more regions from the input tensors. The region is specified by an anchor (starting point) and a shape (dimensions).

```APIDOC
## nvidia.dali.experimental.dynamic.erase

### Description
Erases one or more regions from the input tensors. The region is specified by an anchor (starting point) and a shape (dimensions).

### Parameters
*   **_input_**: The input tensor.
*   **_** (variadic arguments): Placeholder for other arguments.
*   **batch_size** (int, optional): The batch size.
*   **device** (string, optional): The device to use.
*   **anchor** (tuple of ints, optional): The starting point of the region to erase.
*   **axes** (tuple of ints, optional): The axes to consider for the anchor and shape.
*   **axis_names** (string, optional): The names of the axes to consider for the anchor and shape.
*   **centered_anchor** (bool, optional): Whether the anchor is centered.
*   **fill_value** (float, optional): The value to fill the erased region with.
*   **normalized** (bool, optional): Whether the anchor and shape are normalized.
*   **normalized_anchor** (tuple of floats, optional): The normalized anchor point.
*   **normalized_shape** (tuple of floats, optional): The normalized shape of the region.
*   **shape** (tuple of ints, optional): The dimensions of the region to erase.
```

--------------------------------

### Video Reader Parameters

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.Video.html

This section details the parameters available for configuring the Video reader.

```APIDOC
## Video Reader Parameters

### skip_vfr_check
- **Type**: bool
- **Optional**: True
- **Default**: False
- **Description**: Skips the check for variable frame rate (VFR) videos. Use this flag to suppress false positive detection of VFR videos. Warning: When the dataset indeed contains VFR files, setting this flag may cause the decoder to malfunction.

### step
- **Type**: int
- **Optional**: True
- **Default**: -1
- **Description**: Frame interval between each sequence. When the value is less than 0, `step` is set to `sequence_length`.

### stick_to_shard
- **Type**: bool
- **Optional**: True
- **Default**: False
- **Description**: Determines whether the reader should stick to a data shard instead of going through the entire dataset. If decoder caching is used, it significantly reduces the amount of data to be cached, but might affect accuracy of the training.

### stride
- **Type**: int
- **Optional**: True
- **Default**: 1
- **Description**: Distance between consecutive frames in the sequence.

### tensor_init_bytes
- **Type**: int
- **Optional**: True
- **Default**: 1048576
- **Description**: Hint for how much memory to allocate per image.
```

--------------------------------

### nvidia.dali.experimental.dynamic.set_default_stream

Source: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/dali_dynamic/api_reference.html

Sets the default stream for a CUDA device. This function is intended for initial setup and affects all default contexts in all threads.

```APIDOC
## nvidia.dali.experimental.dynamic.set_default_stream

### Description
Sets the default stream for a CUDA device. If the device id is not specified, the device associated with the stream will be used. If there’s no device associated with the stream, current CUDA device is used. Passing `None` clears the default stream.

### Warning
This function is intended to be used once, at the beginning of the program, to set the default stream for DALI operations. Calling it affects all default contexts in all threads that haven’t set their current streams with a call to `set_current_stream()`.

### Method Signature
nvidia.dali.experimental.dynamic.set_default_stream(cuda_stream, /, device_id=None)

### Parameters
#### Arguments
- **cuda_stream** (CUDA stream object or None) - The CUDA stream to set as default. Passing `None` clears the default stream.
- **device_id** (int or None, optional) - The ID of the CUDA device for which to set the default stream. If not specified, the device associated with the `cuda_stream` is used, or the current CUDA device if no stream is associated.
```
Tokens:
Raw