From f76b5230f9cdd032b46ff11be2059a5de6dc09d9 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 9 Mar 2026 15:50:52 +0000 Subject: [PATCH 01/23] Support constructing readers with tensor args Signed-off-by: Rostan Tabet --- .../dali/experimental/dynamic/_op_builder.py | 20 +++++++++++++++- .../nvidia/dali/experimental/dynamic/_ops.py | 24 ++++++++++++++----- .../experimental/dynamic/pytorch/nodes.py | 4 ++-- .../use_cases/pytorch/resnet50/main.py | 2 +- 4 files changed, 40 insertions(+), 10 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 27998104688..7cc2a5d9ba7 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -161,20 +161,25 @@ def build_constructor(schema, op_class): Operator._get() can be used instead of the constructor to utilize the instance caching. """ stateful = op_class._is_stateful + is_reader = op_class._is_reader function_name = "__init__" init_args = [] used_kwargs = set() + tensor_arg_names = set() for arg in schema.GetArgumentNames(): if arg in _unsupported_args: continue - if schema.IsTensorArgument(arg): + is_tensor = schema.IsTensorArgument(arg) + if is_tensor and not is_reader: continue if schema.IsArgumentOptional(arg): init_args.append(f"{arg}=None") else: init_args.append(arg) used_kwargs.add(arg) + if is_tensor: + tensor_arg_names.add(arg) if init_args: init_args = ["*"] + init_args @@ -193,8 +198,11 @@ def build_constructor(schema, op_class): # Note: Base __init__ will keep the **kwargs def init(self, max_batch_size, name, **kwargs): + tensor_kwargs = {k: kwargs.pop(k) for k in tensor_arg_names if k in kwargs} kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) + if is_reader: + self._tensor_args = {k: v for k, v in tensor_kwargs.items() if v is not None} if stateful: self._call_id = 0 @@ -272,6 +280,16 @@ def build_call_function(schema, op_class): @NVTXRange(f"__call__: {op_class._op_name}", category="op_builder") def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): self._pre_call(*raw_args, **raw_kwargs) + + if op_class._is_reader and self._tensor_args: + overlap = set(raw_kwargs) & set(self._tensor_args) + if overlap: + raise ValueError( + f"Tensor argument(s) {sorted(overlap)} were already provided " + f"in the reader constructor and cannot be passed again in __call__." + ) + raw_kwargs = {**self._tensor_args, **raw_kwargs} + batch_size = _ops._infer_batch_size(batch_size, *raw_args, **raw_kwargs) is_batch = batch_size is not None diff --git a/dali/python/nvidia/dali/experimental/dynamic/_ops.py b/dali/python/nvidia/dali/experimental/dynamic/_ops.py index a17198caa69..91b8a90a08f 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_ops.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_ops.py @@ -588,6 +588,7 @@ def __init__( stick_to_shard=_READER_SHARD_DEFAULTS["stick_to_shard"], **kwargs, ): + self._tensor_args = {} if name is None: name = f"Reader_{id(self)}" self._actual_batch_size = batch_size @@ -667,10 +668,19 @@ def next_epoch(self, batch_size=None, ctx: _eval_context.EvalContext | None = No else: return self._samples(ctx) - def get_metadata(self) -> ReaderMeta: + def _process_tensor_args(self, batch_size): + """Converts stored tensor args to Batch/Tensor form for the given batch_size.""" + if not self._tensor_args: + return {} + _, kwargs = self._process_params( + self._backend, self._device, batch_size, **self._tensor_args + ) + return kwargs + + def get_metadata(self, batch_size: int) -> ReaderMeta: """Returns the metadata of the underlying reader operator""" - self._init_backend(None, (), {}) + self._init_backend(None, (), self._process_tensor_args(batch_size)) return self._op_backend.GetReaderMeta() def _samples(self, ctx: _eval_context.EvalContext | None = None): @@ -689,14 +699,15 @@ def _samples(self, ctx: _eval_context.EvalContext | None = None): self._actual_batch_size = 1 if self._max_batch_size is None: self._max_batch_size = self._actual_batch_size - self._init_backend(ctx, (), {}) + self._init_backend(ctx, (), self._process_tensor_args(self._actual_batch_size)) + tensor_args = self._process_tensor_args(self._actual_batch_size) meta = self._op_backend.GetReaderMeta() idx = 0 padded_size = meta["epoch_size_padded"] shards_beg = math.floor(self._shard_id * padded_size / self._num_shards) shards_end = math.floor((self._shard_id + 1) * padded_size / self._num_shards) while idx < shards_end - shards_beg: - outputs = super()._run(ctx, batch_size=self._actual_batch_size) + outputs = super()._run(ctx, batch_size=self._actual_batch_size, **tensor_args) batch_size = len( outputs[0] if isinstance(outputs, tuple) else next(iter(outputs.values())) ) @@ -734,7 +745,7 @@ def _batches(self, batch_size=None, ctx: _eval_context.EvalContext | None = None f"{self._max_batch_size} specified when the operator was created" ) self._max_batch_size = batch_size - self._init_backend(ctx, (), {}) + self._init_backend(ctx, (), self._process_tensor_args(batch_size)) else: if self._max_batch_size and self._max_batch_size != batch_size: raise ValueError( @@ -747,7 +758,8 @@ def _batches(self, batch_size=None, ctx: _eval_context.EvalContext | None = None shards_beg = math.floor(self._shard_id * padded_size / self._num_shards) shards_end = math.floor((self._shard_id + 1) * padded_size / self._num_shards) while idx < shards_end - shards_beg: - outputs = super()._run(ctx, batch_size=batch_size) + tensor_args = self._process_tensor_args(batch_size) + outputs = super()._run(ctx, batch_size=batch_size, **tensor_args) batch_size_returned = batch_size = len( outputs[0] if isinstance(outputs, tuple) else next(iter(outputs.values())) ) diff --git a/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py b/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py index 28cd866a44b..8d6a14b4826 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py +++ b/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py @@ -134,9 +134,9 @@ def reset(self, initial_state: dict | None = None): def get_state(self): return {} - def get_metadata(self) -> _ops.ReaderMeta: + def get_metadata(self, batch_size: int) -> _ops.ReaderMeta: """Returns the metadata of the underlying reader operator""" - return self._reader.get_metadata() + return self._reader.get_metadata(batch_size) class DictMapper(tn.BaseNode[dict[str, T]], metaclass=_CUDANodeMeta): diff --git a/docs/examples/use_cases/pytorch/resnet50/main.py b/docs/examples/use_cases/pytorch/resnet50/main.py index 170f0f68716..4268cc2986f 100644 --- a/docs/examples/use_cases/pytorch/resnet50/main.py +++ b/docs/examples/use_cases/pytorch/resnet50/main.py @@ -225,7 +225,7 @@ def build_ndd_loader( loader = tn.Loader(prefetch_node) # WAR to get the length of the loader - epoch_size = reader_node.get_metadata()["epoch_size_padded"] + epoch_size = reader_node.get_metadata(batch_size)["epoch_size_padded"] loader._size = epoch_size // num_shards return loader From 0878b6c86ee98c0d181bbf76d4790aad121ec078 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 9 Mar 2026 17:45:34 +0000 Subject: [PATCH 02/23] Detect when default values are passed when invoking a reader Signed-off-by: Rostan Tabet --- .../nvidia/dali/experimental/dynamic/_op_builder.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 7cc2a5d9ba7..5f6f6bb5f0b 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -282,13 +282,14 @@ def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): self._pre_call(*raw_args, **raw_kwargs) if op_class._is_reader and self._tensor_args: - overlap = set(raw_kwargs) & set(self._tensor_args) + actual_kwargs = {name for name, value in raw_kwargs.items() if value is not None} + overlap = actual_kwargs & set(self._tensor_args) if overlap: raise ValueError( - f"Tensor argument(s) {sorted(overlap)} were already provided " - f"in the reader constructor and cannot be passed again in __call__." + f"Keyword argument{'s'[:len(overlap)^1]} {sorted(overlap)}" + f" cannot be passed both in the constructor and __call__." ) - raw_kwargs = {**self._tensor_args, **raw_kwargs} + raw_kwargs = {**raw_kwargs, **self._tensor_args} batch_size = _ops._infer_batch_size(batch_size, *raw_args, **raw_kwargs) is_batch = batch_size is not None From 553d01c2dc6e6be034cd4b61d39d0b571467c797 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 9 Mar 2026 17:46:08 +0000 Subject: [PATCH 03/23] Fix call stack depth for reader invocations when reconstructing stack traces Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_invocation.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py index a57a458c63d..aa4a64f7701 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py @@ -50,7 +50,7 @@ def __init__( is_batch: bool = False, batch_size: Optional[int] = None, previous_invocation: Optional["Invocation"] = None, - caller_depth: int = 4, + caller_depth: int | None = None, ): """ Parameters @@ -90,6 +90,8 @@ def __init__( self._eval_mode: _EvalMode | None = None self._future: Optional[_Future] = None self._run_lock = threading.Lock() + if caller_depth is None: + caller_depth = 2 if getattr(self._operator, "_is_reader", False) else 4 self._call_stack = ( capture_stack(caller_depth + 1) if _EvalMode.current().value <= _EvalMode.eager.value From 17bb0b55d6cb17ef61a741eab21343f64855b8a0 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 9 Mar 2026 17:46:27 +0000 Subject: [PATCH 04/23] Add tests passing tensor arguments Signed-off-by: Rostan Tabet --- .../experimental_mode/test_reader_decoder.py | 60 ++++++++++++++++++- 1 file changed, 58 insertions(+), 2 deletions(-) diff --git a/dali/test/python/experimental_mode/test_reader_decoder.py b/dali/test/python/experimental_mode/test_reader_decoder.py index cca87a50ee7..d043a888ecf 100644 --- a/dali/test/python/experimental_mode/test_reader_decoder.py +++ b/dali/test/python/experimental_mode/test_reader_decoder.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ import tempfile import math +import numpy as np import nvidia.dali.experimental.dynamic as ndd from nose2.tools import cartesian_params, params from nose_utils import SkipTest, assert_raises @@ -184,6 +185,61 @@ def test_reader_shards_error(): num_shards=99999, ) with assert_raises( - RuntimeError, glob='Assert on "num_shards_ <= Size()" failed: The number of input samples:' + RuntimeError, glob='Assert on "num_shards_ <= Size()" failed: The number of input samples:*' ): tuple(reader.next_epoch()) + + +@params(None, 4) +def test_video_resize_tensor_args(batch_size): + sequence_length = 60 + width, height = 108, 192 + video_root = os.path.join(dali_extra_path, "db", "video", "sintel", "video_files") + reader = ndd.readers.VideoResize( + filenames=[os.path.join(video_root, "sintel_trailer-720p_3.mp4")], + sequence_length=sequence_length, + device="gpu", + resize_x=width, + resize_y=height, + ) + for (tensor,) in reader.next_epoch(batch_size=batch_size): + assert isinstance(tensor, ndd.Tensor if batch_size is None else ndd.Batch) + assert tensor.layout == "FHWC" + assert tensor.dtype == ndd.uint8 + assert tensor.device == ndd.Device("gpu") + expected_shape = (sequence_length, height, width, 3) + if batch_size is None: + assert tensor.shape == expected_shape + else: + assert tensor.shape == [expected_shape] * batch_size + + +def test_video_resize_tensor_args_partial(): + sequence_length = 60 + width, height = 108, 192 + video_root = os.path.join(dali_extra_path, "db", "video", "sintel", "video_files") + reader = ndd.readers.VideoResize( + filenames=[os.path.join(video_root, "sintel_trailer-720p_3.mp4")], + sequence_length=sequence_length, + device="gpu", + resize_x=width, + ) + tensor = reader() + assert isinstance(tensor, ndd.Tensor) + assert tensor.layout == "FHWC" + assert tensor.dtype == ndd.uint8 + assert tensor.device == ndd.Device("gpu") + assert tensor.shape == (sequence_length, height, width, 3) + + +def test_video_resize_tensor_repeated_args(): + video_root = os.path.join(dali_extra_path, "db", "video", "sintel", "video_files") + reader = ndd.readers.VideoResize( + filenames=[os.path.join(video_root, "sintel_trailer-720p_3.mp4")], + sequence_length=60, + device="gpu", + resize_x=108, + resize_y=192, + ) + with assert_raises(ValueError, glob="*resize_x*"): + reader(resize_x=144) From a3172ff2533adf3cb09c0accb1fce53d5d7839ca Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Tue, 10 Mar 2026 10:06:05 +0000 Subject: [PATCH 05/23] Disallow constructing a reader with batch kwargs Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_op_builder.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 5f6f6bb5f0b..645d61ee799 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -289,6 +289,9 @@ def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): f"Keyword argument{'s'[:len(overlap)^1]} {sorted(overlap)}" f" cannot be passed both in the constructor and __call__." ) + for arg in self._tensor_args.values(): + if isinstance(arg, Batch): + raise ValueError("Readers cannot be constructed with batch keyword arguments") raw_kwargs = {**raw_kwargs, **self._tensor_args} batch_size = _ops._infer_batch_size(batch_size, *raw_args, **raw_kwargs) From a8aa74a74d7b8be595b1600aa89e90660ab1169d Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Tue, 10 Mar 2026 10:06:47 +0000 Subject: [PATCH 06/23] Update signature of reader constructors to allow tensor arguments Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/ops/_signatures.py | 3 +-- .../experimental_mode/test_reader_decoder.py | 1 - .../python/type_annotations/test_typing_dynamic.py | 14 +++++++++++++- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/dali/python/nvidia/dali/ops/_signatures.py b/dali/python/nvidia/dali/ops/_signatures.py index e0fb2b5a2cf..07d9c39160c 100644 --- a/dali/python/nvidia/dali/ops/_signatures.py +++ b/dali/python/nvidia/dali/ops/_signatures.py @@ -785,6 +785,7 @@ def __call__$signature: schema, include_self=True, include_only_inputs=True, + input_annotation_gen=lambda _: _TensorLike, ) ) @@ -796,8 +797,6 @@ class {op_name}: def __init__{_call_signature( schema, "dynamic", - include_inputs=False, - include_kwarg_inputs=False, include_self=True, return_annotation=False, include_kwargs=True, diff --git a/dali/test/python/experimental_mode/test_reader_decoder.py b/dali/test/python/experimental_mode/test_reader_decoder.py index d043a888ecf..290af0edaaa 100644 --- a/dali/test/python/experimental_mode/test_reader_decoder.py +++ b/dali/test/python/experimental_mode/test_reader_decoder.py @@ -17,7 +17,6 @@ import tempfile import math -import numpy as np import nvidia.dali.experimental.dynamic as ndd from nose2.tools import cartesian_params, params from nose_utils import SkipTest, assert_raises diff --git a/dali/test/python/type_annotations/test_typing_dynamic.py b/dali/test/python/type_annotations/test_typing_dynamic.py index 6167f609df3..86b3a10f89f 100644 --- a/dali/test/python/type_annotations/test_typing_dynamic.py +++ b/dali/test/python/type_annotations/test_typing_dynamic.py @@ -16,7 +16,7 @@ import numpy as np import nvidia.dali.experimental.dynamic as ndd -from nose_utils import attr # type: ignore +from nose_utils import attr from nvidia.dali import types from test_utils import get_dali_extra_path @@ -102,3 +102,15 @@ def test_copy_tensor_constant(): assert np.array_equal(const_tuple, [4, 5]) assert np.array_equal(const_torch, np.full((2, 2), 6)) assert np.array_equal(const_np, np.full((2, 2), 7)) + + +def test_numpy_reader_roi(): + reader = ndd.readers.Numpy( + file_root=str(_test_root / "db" / "3D" / "MRI" / "Knee" / "npy_2d_slices" / "STU00001"), + roi_start=(30, 30), + roi_end=(230, 230), + ) + for (data,) in reader.next_epoch(): + expect_tensor(data) + assert data.shape == (200, 200) + break From a1fccb3ef5d5012e6983e700b0f99f19e4de39d4 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Wed, 11 Mar 2026 10:55:13 +0000 Subject: [PATCH 07/23] Update NumpyReader example to pass ROI in the reader constructor Signed-off-by: Rostan Tabet --- .../numpy_reader/dynamic_mode.ipynb | 79 +++++++++++++++---- 1 file changed, 65 insertions(+), 14 deletions(-) diff --git a/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb b/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb index ff92b053dc4..28065005135 100644 --- a/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb +++ b/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb @@ -307,7 +307,8 @@ ], "source": [ "reader = ndd.readers.Numpy(file_root=data_dir_3d, file_filter=\"*.npy\")\n", - "tensor_3d = reader()\n", + "for (tensor_3d,) in reader.next_epoch():\n", + " break\n", "\n", "print(f\"Sample shape: {tensor_3d.shape}\")\n", "plot_tensors(\n", @@ -321,7 +322,23 @@ { "cell_type": "markdown", "metadata": {}, - "source": "## Region-of-interest (ROI) API\n\nIn the example shown above, we see that the relevant data is concentrated in the upper left quadrant of the image and the rest does not contain useful information. This is not true for all the images in the dataset, but it will serve us as a good example to demonstrate ROI reading.\n\nNumPy reader allows the user to specify a region of interest, equivalent to the arguments specified to ``slice`` operation. The benefit is that the reader will only read the relevant part of the file, saving I/O bandwidth and memory utilization. Note that setting the ``dont_use_mmap`` argument to False will negate that performance benefit, with the entire file being read first and then sliced.\n\nThe ROI can be specified in absolute or relative terms, and can be specified on a subset of the array's axes. For dimensions not specified in the ROI, the whole extent of the array shall be used. For full documentation on ROI decoding, refer to [readers.Numpy documentation](../../../../dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.Numpy.html) (see arguments ``roi_start``, ``rel_roi_start``, ``roi_end``, ``rel_roi_end``, ``roi_shape``, ``rel_roi_shape``, ``axes``).\n\n
\nNote
\n\nTo specify the ROI, it is necessary to call the reader directly instead of using the `next_epoch` iterator: `reader(roi_start=..., roi_end=...)`\n
\n\nLet us see a few practical examples:" + "source": [ + "## Region-of-interest (ROI) API\n", + "\n", + "In the example shown above, we see that the relevant data is concentrated in the upper left quadrant of the image and the rest does not contain useful information. This is not true for all the images in the dataset, but it will serve us as a good example to demonstrate ROI reading.\n", + "\n", + "NumPy reader allows the user to specify a region of interest, equivalent to the arguments specified to ``slice`` operation. The benefit is that the reader will only read the relevant part of the file, saving I/O bandwidth and memory utilization. Note that setting the ``dont_use_mmap`` argument to False will negate that performance benefit, with the entire file being read first and then sliced.\n", + "\n", + "The ROI can be specified in absolute or relative terms, and can be specified on a subset of the array's axes. For dimensions not specified in the ROI, the whole extent of the array shall be used. For full documentation on ROI decoding, refer to [readers.Numpy documentation](../../../../dali_dynamic/operations/nvidia.dali.experimental.dynamic.readers.Numpy.html) (see arguments ``roi_start``, ``rel_roi_start``, ``roi_end``, ``rel_roi_end``, ``roi_shape``, ``rel_roi_shape``, ``axes``).\n", + "\n", + "
\n", + "Note
\n", + "\n", + "It also also possible to specify the ROI by calling the reader directly: `reader(roi_start=..., roi_end=...)`.\n", + "
\n", + "\n", + "Let us see a few practical examples:" + ] }, { "cell_type": "markdown", @@ -350,8 +367,15 @@ "# One file is enough for this example\n", "files = [\"0.npy\"]\n", "\n", - "reader = ndd.readers.Numpy(file_root=data_dir, files=files)\n", - "plot_tensors(reader(roi_start=[30, 30], roi_end=[230, 230]))" + "reader = ndd.readers.Numpy(\n", + " file_root=data_dir,\n", + " files=files,\n", + " roi_start=[30, 30],\n", + " roi_end=[230, 230],\n", + ")\n", + "for (tensor_roi1,) in reader.next_epoch():\n", + " break\n", + "plot_tensors(tensor_roi1)" ] }, { @@ -378,8 +402,15 @@ } ], "source": [ - "reader = ndd.readers.Numpy(file_root=data_dir, files=files)\n", - "plot_tensors(reader(rel_roi_start=[0.1, 0.01], rel_roi_end=[0.4, 0.5]))" + "reader = ndd.readers.Numpy(\n", + " file_root=data_dir,\n", + " files=files,\n", + " rel_roi_start=[0.1, 0.01],\n", + " rel_roi_end=[0.4, 0.5],\n", + ")\n", + "for (tensor_roi2,) in reader.next_epoch():\n", + " break\n", + "plot_tensors(tensor_roi2)" ] }, { @@ -406,7 +437,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -416,11 +447,27 @@ } ], "source": [ - "reader1 = ndd.readers.Numpy(file_root=data_dir, files=files, roi_axes=(0,))\n", - "plot_tensors(reader1(rel_roi_start=[0.1], rel_roi_end=[0.4]))\n", + "reader1 = ndd.readers.Numpy(\n", + " file_root=data_dir,\n", + " files=files,\n", + " roi_axes=(0,),\n", + " rel_roi_start=0.1,\n", + " rel_roi_end=0.4,\n", + ")\n", + "for (tensor_roi3,) in reader1.next_epoch():\n", + " break\n", + "plot_tensors(tensor_roi3)\n", "\n", - "reader2 = ndd.readers.Numpy(file_root=data_dir, files=files, roi_axes=(1,))\n", - "plot_tensors(reader2(rel_roi_start=[0.1], rel_roi_end=[0.4]))" + "reader2 = ndd.readers.Numpy(\n", + " file_root=data_dir,\n", + " files=files,\n", + " roi_axes=(1,),\n", + " rel_roi_start=0.1,\n", + " rel_roi_end=0.4,\n", + ")\n", + "for (tensor_roi4,) in reader.next_epoch():\n", + " break\n", + "plot_tensors(tensor_roi4)" ] }, { @@ -456,8 +503,12 @@ " files=files,\n", " out_of_bounds_policy=\"pad\",\n", " fill_value=0,\n", + " roi_start=(-150, -150),\n", + " roi_end=(400, 400),\n", ")\n", - "plot_tensors(reader(roi_start=(-150, -150), roi_end=(400, 400)))" + "for (tensor_roi5,) in reader.next_epoch():\n", + " break\n", + "plot_tensors(tensor_roi5)" ] }, { @@ -514,9 +565,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.19" + "version": "3.10.20" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} From cdaefafcc8de672f86c625640c4f62634dfd2646 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Wed, 11 Mar 2026 15:47:08 +0000 Subject: [PATCH 08/23] Apply suggestions from review Signed-off-by: Rostan Tabet --- .../nvidia/dali/experimental/dynamic/_invocation.py | 2 +- .../nvidia/dali/experimental/dynamic/_op_builder.py | 7 +++---- dali/python/nvidia/dali/experimental/dynamic/_ops.py | 8 +++++--- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py index aa4a64f7701..bb9837036a6 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py @@ -91,7 +91,7 @@ def __init__( self._future: Optional[_Future] = None self._run_lock = threading.Lock() if caller_depth is None: - caller_depth = 2 if getattr(self._operator, "_is_reader", False) else 4 + caller_depth = 3 if getattr(self._operator, "_is_reader", False) else 4 self._call_stack = ( capture_stack(caller_depth + 1) if _EvalMode.current().value <= _EvalMode.eager.value diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 645d61ee799..f3e364af01a 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -203,6 +203,8 @@ def init(self, max_batch_size, name, **kwargs): op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: self._tensor_args = {k: v for k, v in tensor_kwargs.items() if v is not None} + if any(isinstance(v, Batch) for v in self._tensor_args.values()): + raise ValueError("Readers cannot be constructed with batch keyword arguments") if stateful: self._call_id = 0 @@ -287,11 +289,8 @@ def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): if overlap: raise ValueError( f"Keyword argument{'s'[:len(overlap)^1]} {sorted(overlap)}" - f" cannot be passed both in the constructor and __call__." + f" cannot be passed in both in the constructor and __call__." ) - for arg in self._tensor_args.values(): - if isinstance(arg, Batch): - raise ValueError("Readers cannot be constructed with batch keyword arguments") raw_kwargs = {**raw_kwargs, **self._tensor_args} batch_size = _ops._infer_batch_size(batch_size, *raw_args, **raw_kwargs) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_ops.py b/dali/python/nvidia/dali/experimental/dynamic/_ops.py index 91b8a90a08f..0ae2f85fa48 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_ops.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_ops.py @@ -668,7 +668,7 @@ def next_epoch(self, batch_size=None, ctx: _eval_context.EvalContext | None = No else: return self._samples(ctx) - def _process_tensor_args(self, batch_size): + def _process_tensor_args(self, batch_size: int | None): """Converts stored tensor args to Batch/Tensor form for the given batch_size.""" if not self._tensor_args: return {} @@ -699,8 +699,10 @@ def _samples(self, ctx: _eval_context.EvalContext | None = None): self._actual_batch_size = 1 if self._max_batch_size is None: self._max_batch_size = self._actual_batch_size - self._init_backend(ctx, (), self._process_tensor_args(self._actual_batch_size)) - tensor_args = self._process_tensor_args(self._actual_batch_size) + tensor_args = self._process_tensor_args(self._actual_batch_size) + self._init_backend(ctx, (), tensor_args) + else: + tensor_args = self._process_tensor_args(self._actual_batch_size) meta = self._op_backend.GetReaderMeta() idx = 0 padded_size = meta["epoch_size_padded"] From a3a59ea4d7ad544f3b4751b8f37bfc465e5f3e02 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Wed, 11 Mar 2026 17:34:54 +0000 Subject: [PATCH 09/23] Prevent processing again tensor args when not necessary in batch processing Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_ops.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_ops.py b/dali/python/nvidia/dali/experimental/dynamic/_ops.py index 0ae2f85fa48..3df950dd054 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_ops.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_ops.py @@ -747,20 +747,25 @@ def _batches(self, batch_size=None, ctx: _eval_context.EvalContext | None = None f"{self._max_batch_size} specified when the operator was created" ) self._max_batch_size = batch_size - self._init_backend(ctx, (), self._process_tensor_args(batch_size)) + previous_batch_size = batch_size + tensor_args = self._process_tensor_args(batch_size) + self._init_backend(ctx, (), tensor_args) else: if self._max_batch_size and self._max_batch_size != batch_size: raise ValueError( f"`batch_size` {batch_size} is different than the `max_batch_size` " f"{self._max_batch_size} used in the previous call" ) + tensor_args = None meta = self._op_backend.GetReaderMeta() idx = 0 padded_size = meta["epoch_size_padded"] shards_beg = math.floor(self._shard_id * padded_size / self._num_shards) shards_end = math.floor((self._shard_id + 1) * padded_size / self._num_shards) while idx < shards_end - shards_beg: - tensor_args = self._process_tensor_args(batch_size) + if tensor_args is None or previous_batch_size != batch_size: + tensor_args = self._process_tensor_args(batch_size) + previous_batch_size = batch_size outputs = super()._run(ctx, batch_size=batch_size, **tensor_args) batch_size_returned = batch_size = len( outputs[0] if isinstance(outputs, tuple) else next(iter(outputs.values())) From ab75701fe43efa8b29c1c6834888493a7c81c584 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Wed, 11 Mar 2026 17:37:43 +0000 Subject: [PATCH 10/23] Fix test_video_resize_tensor_args_partial Signed-off-by: Rostan Tabet --- dali/test/python/experimental_mode/test_reader_decoder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dali/test/python/experimental_mode/test_reader_decoder.py b/dali/test/python/experimental_mode/test_reader_decoder.py index 290af0edaaa..20c19288714 100644 --- a/dali/test/python/experimental_mode/test_reader_decoder.py +++ b/dali/test/python/experimental_mode/test_reader_decoder.py @@ -215,7 +215,7 @@ def test_video_resize_tensor_args(batch_size): def test_video_resize_tensor_args_partial(): sequence_length = 60 - width, height = 108, 192 + width, height = 144, 192 video_root = os.path.join(dali_extra_path, "db", "video", "sintel", "video_files") reader = ndd.readers.VideoResize( filenames=[os.path.join(video_root, "sintel_trailer-720p_3.mp4")], @@ -223,7 +223,7 @@ def test_video_resize_tensor_args_partial(): device="gpu", resize_x=width, ) - tensor = reader() + tensor = reader(resize_y=height) assert isinstance(tensor, ndd.Tensor) assert tensor.layout == "FHWC" assert tensor.dtype == ndd.uint8 From 4ba75c3393dcdc2d01914490661643ace5cb0879 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Fri, 13 Mar 2026 10:56:50 +0000 Subject: [PATCH 11/23] Cache processed tensor args passed in the constructor Signed-off-by: Rostan Tabet --- .../dali/experimental/dynamic/_op_builder.py | 10 +++--- .../nvidia/dali/experimental/dynamic/_ops.py | 33 +++++++++++-------- 2 files changed, 25 insertions(+), 18 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index f3e364af01a..8b02db4e4d5 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -202,8 +202,8 @@ def init(self, max_batch_size, name, **kwargs): kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: - self._tensor_args = {k: v for k, v in tensor_kwargs.items() if v is not None} - if any(isinstance(v, Batch) for v in self._tensor_args.values()): + self._raw_tensor_args = {k: v for k, v in tensor_kwargs.items() if v is not None} + if any(isinstance(v, Batch) for v in self._raw_tensor_args.values()): raise ValueError("Readers cannot be constructed with batch keyword arguments") if stateful: self._call_id = 0 @@ -283,15 +283,15 @@ def build_call_function(schema, op_class): def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): self._pre_call(*raw_args, **raw_kwargs) - if op_class._is_reader and self._tensor_args: + if op_class._is_reader and self._raw_tensor_args: actual_kwargs = {name for name, value in raw_kwargs.items() if value is not None} - overlap = actual_kwargs & set(self._tensor_args) + overlap = actual_kwargs & set(self._raw_tensor_args) if overlap: raise ValueError( f"Keyword argument{'s'[:len(overlap)^1]} {sorted(overlap)}" f" cannot be passed in both in the constructor and __call__." ) - raw_kwargs = {**raw_kwargs, **self._tensor_args} + raw_kwargs = {**raw_kwargs, **self._raw_tensor_args} batch_size = _ops._infer_batch_size(batch_size, *raw_args, **raw_kwargs) is_batch = batch_size is not None diff --git a/dali/python/nvidia/dali/experimental/dynamic/_ops.py b/dali/python/nvidia/dali/experimental/dynamic/_ops.py index 3df950dd054..86af40f7f30 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_ops.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_ops.py @@ -588,7 +588,6 @@ def __init__( stick_to_shard=_READER_SHARD_DEFAULTS["stick_to_shard"], **kwargs, ): - self._tensor_args = {} if name is None: name = f"Reader_{id(self)}" self._actual_batch_size = batch_size @@ -604,6 +603,12 @@ def __init__( if stick_to_shard is not None else _READER_SHARD_DEFAULTS["stick_to_shard"] ) + + self._raw_tensor_args = {} + self._tensor_args = {} + # Used to know when to recompute _tensor_args for _raw_tensor_args + self._previous_batch_size: int | None = None + if self._num_shards < 1: raise ValueError( f"The number of shards must be a positive integer. Got {self._num_shards}." @@ -670,12 +675,18 @@ def next_epoch(self, batch_size=None, ctx: _eval_context.EvalContext | None = No def _process_tensor_args(self, batch_size: int | None): """Converts stored tensor args to Batch/Tensor form for the given batch_size.""" - if not self._tensor_args: + if not self._raw_tensor_args: return {} - _, kwargs = self._process_params( - self._backend, self._device, batch_size, **self._tensor_args + if self._previous_batch_size == batch_size: + return self._tensor_args + _, self._tensor_args = self._process_params( + self._backend, + self._device, + batch_size, + **self._raw_tensor_args, ) - return kwargs + self._previous_batch_size = batch_size + return self._tensor_args def get_metadata(self, batch_size: int) -> ReaderMeta: """Returns the metadata of the underlying reader operator""" @@ -699,10 +710,9 @@ def _samples(self, ctx: _eval_context.EvalContext | None = None): self._actual_batch_size = 1 if self._max_batch_size is None: self._max_batch_size = self._actual_batch_size - tensor_args = self._process_tensor_args(self._actual_batch_size) - self._init_backend(ctx, (), tensor_args) - else: - tensor_args = self._process_tensor_args(self._actual_batch_size) + self._init_backend(ctx, (), self._process_tensor_args(self._actual_batch_size)) + + tensor_args = self._process_tensor_args(self._actual_batch_size) meta = self._op_backend.GetReaderMeta() idx = 0 padded_size = meta["epoch_size_padded"] @@ -747,7 +757,6 @@ def _batches(self, batch_size=None, ctx: _eval_context.EvalContext | None = None f"{self._max_batch_size} specified when the operator was created" ) self._max_batch_size = batch_size - previous_batch_size = batch_size tensor_args = self._process_tensor_args(batch_size) self._init_backend(ctx, (), tensor_args) else: @@ -763,9 +772,7 @@ def _batches(self, batch_size=None, ctx: _eval_context.EvalContext | None = None shards_beg = math.floor(self._shard_id * padded_size / self._num_shards) shards_end = math.floor((self._shard_id + 1) * padded_size / self._num_shards) while idx < shards_end - shards_beg: - if tensor_args is None or previous_batch_size != batch_size: - tensor_args = self._process_tensor_args(batch_size) - previous_batch_size = batch_size + tensor_args = self._process_tensor_args(batch_size) outputs = super()._run(ctx, batch_size=batch_size, **tensor_args) batch_size_returned = batch_size = len( outputs[0] if isinstance(outputs, tuple) else next(iter(outputs.values())) From aee5ab550e2648b6fa81f399dc5b7b7fb36c7b8d Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Fri, 13 Mar 2026 11:14:00 +0000 Subject: [PATCH 12/23] Fix caller_depth handling. Remove special case for readers Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py | 1 - dali/python/nvidia/dali/experimental/dynamic/_invocation.py | 4 +--- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py b/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py index 315a0579d06..c38ac9527b9 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py @@ -64,7 +64,6 @@ def __call__( is_batch=False, batch_size=None, previous_invocation=None, - caller_depth=3, ) invocation.apply_eval_policy(_op_builder.is_external(batch)) return Tensor(invocation_result=invocation[0]) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py index bb9837036a6..539ba77eab4 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py @@ -50,7 +50,7 @@ def __init__( is_batch: bool = False, batch_size: Optional[int] = None, previous_invocation: Optional["Invocation"] = None, - caller_depth: int | None = None, + caller_depth: int = 3, ): """ Parameters @@ -90,8 +90,6 @@ def __init__( self._eval_mode: _EvalMode | None = None self._future: Optional[_Future] = None self._run_lock = threading.Lock() - if caller_depth is None: - caller_depth = 3 if getattr(self._operator, "_is_reader", False) else 4 self._call_stack = ( capture_stack(caller_depth + 1) if _EvalMode.current().value <= _EvalMode.eager.value From 4785f39e5071144a67435844c88219754b72d4a7 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Fri, 13 Mar 2026 16:59:38 +0000 Subject: [PATCH 13/23] Pass scalar arguments directly to reader constructors and copy external tensors Signed-off-by: Rostan Tabet --- .../dali/experimental/dynamic/_op_builder.py | 26 +++++++++++++------ .../nvidia/dali/experimental/dynamic/_ops.py | 2 ++ 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 8b02db4e4d5..86d65131c0c 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -25,7 +25,7 @@ from . import _device, _invocation, _op_filter, _ops, _type from ._batch import Batch -from ._tensor import Tensor +from ._tensor import Tensor, tensor as to_tensor def is_external(x): @@ -198,13 +198,23 @@ def build_constructor(schema, op_class): # Note: Base __init__ will keep the **kwargs def init(self, max_batch_size, name, **kwargs): - tensor_kwargs = {k: kwargs.pop(k) for k in tensor_arg_names if k in kwargs} + if is_reader: + tensor_args = {} + for k in tensor_arg_names: + arg = kwargs.get(k) + if arg is None or isinstance(arg, (int, float, bool, str, tuple, list)): + continue + del kwargs[k] + if isinstance(arg, Batch): + raise ValueError("Readers cannot be constructed with batch keyword arguments") + if not isinstance(arg, Tensor): # perform a copy if not an ndd tensor + arg = to_tensor(arg) + tensor_args[k] = arg kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) - if is_reader: - self._raw_tensor_args = {k: v for k, v in tensor_kwargs.items() if v is not None} - if any(isinstance(v, Batch) for v in self._raw_tensor_args.values()): - raise ValueError("Readers cannot be constructed with batch keyword arguments") + if is_reader: # Need to be done here not to be overridden by the constructor + self._tensor_arg_names = {name for name in tensor_arg_names if kwargs.get(name)} + self._tensor_args = tensor_args if stateful: self._call_id = 0 @@ -283,9 +293,9 @@ def build_call_function(schema, op_class): def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): self._pre_call(*raw_args, **raw_kwargs) - if op_class._is_reader and self._raw_tensor_args: + if op_class._is_reader and self._tensor_arg_names: actual_kwargs = {name for name, value in raw_kwargs.items() if value is not None} - overlap = actual_kwargs & set(self._raw_tensor_args) + overlap = actual_kwargs & self._tensor_arg_names if overlap: raise ValueError( f"Keyword argument{'s'[:len(overlap)^1]} {sorted(overlap)}" diff --git a/dali/python/nvidia/dali/experimental/dynamic/_ops.py b/dali/python/nvidia/dali/experimental/dynamic/_ops.py index 86af40f7f30..59666e17ee8 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_ops.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_ops.py @@ -608,6 +608,8 @@ def __init__( self._tensor_args = {} # Used to know when to recompute _tensor_args for _raw_tensor_args self._previous_batch_size: int | None = None + # Used to make sure that args passed to the constructor are not repeated in __call__ + self._tensor_arg_names: set[str] = set() if self._num_shards < 1: raise ValueError( From a5e6c5e0931218d075e0c28bd0bff246a59855ca Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Fri, 13 Mar 2026 17:37:27 +0000 Subject: [PATCH 14/23] Set _raw_tensor_args instead of _tensor_args in reader constructor Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_op_builder.py | 2 +- dali/test/python/experimental_mode/test_reader_decoder.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 86d65131c0c..2cae5cfd91c 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -214,7 +214,7 @@ def init(self, max_batch_size, name, **kwargs): op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: # Need to be done here not to be overridden by the constructor self._tensor_arg_names = {name for name in tensor_arg_names if kwargs.get(name)} - self._tensor_args = tensor_args + self._raw_tensor_args = tensor_args if stateful: self._call_id = 0 diff --git a/dali/test/python/experimental_mode/test_reader_decoder.py b/dali/test/python/experimental_mode/test_reader_decoder.py index 20c19288714..9c64e66ffc8 100644 --- a/dali/test/python/experimental_mode/test_reader_decoder.py +++ b/dali/test/python/experimental_mode/test_reader_decoder.py @@ -198,7 +198,7 @@ def test_video_resize_tensor_args(batch_size): filenames=[os.path.join(video_root, "sintel_trailer-720p_3.mp4")], sequence_length=sequence_length, device="gpu", - resize_x=width, + resize_x=ndd.tensor(width), resize_y=height, ) for (tensor,) in reader.next_epoch(batch_size=batch_size): From d1f0de96833c080fa653dbb04b2db15438e8e59a Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Fri, 13 Mar 2026 17:59:16 +0000 Subject: [PATCH 15/23] Fix tensor arg tracking in reader op constructor Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_op_builder.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 2cae5cfd91c..3c20485f44b 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -199,6 +199,7 @@ def build_constructor(schema, op_class): # Note: Base __init__ will keep the **kwargs def init(self, max_batch_size, name, **kwargs): if is_reader: + actual_tensor_arg_names = {name for name in tensor_arg_names if kwargs.get(name)} tensor_args = {} for k in tensor_arg_names: arg = kwargs.get(k) @@ -213,7 +214,7 @@ def init(self, max_batch_size, name, **kwargs): kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: # Need to be done here not to be overridden by the constructor - self._tensor_arg_names = {name for name in tensor_arg_names if kwargs.get(name)} + self._tensor_arg_names = actual_tensor_arg_names self._raw_tensor_args = tensor_args if stateful: self._call_id = 0 From 09b7dd76697d5d8b65b32c5199c138fc28418efe Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 16 Mar 2026 09:09:05 +0000 Subject: [PATCH 16/23] Properly use reader tensor args in TorchData integration Signed-off-by: Rostan Tabet --- .../nvidia/dali/experimental/dynamic/pytorch/nodes.py | 7 ++++--- docs/examples/use_cases/pytorch/resnet50/main.py | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py b/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py index 8d6a14b4826..511ab3d8e90 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py +++ b/dali/python/nvidia/dali/experimental/dynamic/pytorch/nodes.py @@ -134,9 +134,9 @@ def reset(self, initial_state: dict | None = None): def get_state(self): return {} - def get_metadata(self, batch_size: int) -> _ops.ReaderMeta: + def get_metadata(self) -> _ops.ReaderMeta: """Returns the metadata of the underlying reader operator""" - return self._reader.get_metadata(batch_size) + return self._reader.get_metadata(self._batch_size) class DictMapper(tn.BaseNode[dict[str, T]], metaclass=_CUDANodeMeta): @@ -202,7 +202,8 @@ def __init__( elif isinstance(output_stream, torch.cuda.Stream | None): self._stream_context = torch.cuda.stream(output_stream) # no-op if None else: - self._dali_stream = _stream(output_stream) # keep it alive in case the caller doesn't + # Keep it alive in case the caller doesn't + self._dali_stream = _stream(stream=output_stream) self._stream_context = torch.cuda.stream( torch.cuda.ExternalStream(self._dali_stream.handle, self._dali_stream.device_id) ) diff --git a/docs/examples/use_cases/pytorch/resnet50/main.py b/docs/examples/use_cases/pytorch/resnet50/main.py index 4268cc2986f..170f0f68716 100644 --- a/docs/examples/use_cases/pytorch/resnet50/main.py +++ b/docs/examples/use_cases/pytorch/resnet50/main.py @@ -225,7 +225,7 @@ def build_ndd_loader( loader = tn.Loader(prefetch_node) # WAR to get the length of the loader - epoch_size = reader_node.get_metadata(batch_size)["epoch_size_padded"] + epoch_size = reader_node.get_metadata()["epoch_size_padded"] loader._size = epoch_size // num_shards return loader From e3de1406d11fff2592e296e6d67b2120840ec9d3 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 16 Mar 2026 09:23:03 +0000 Subject: [PATCH 17/23] Fix signature of reader constructors Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/ops/_signatures.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dali/python/nvidia/dali/ops/_signatures.py b/dali/python/nvidia/dali/ops/_signatures.py index 07d9c39160c..2e822054d1f 100644 --- a/dali/python/nvidia/dali/ops/_signatures.py +++ b/dali/python/nvidia/dali/ops/_signatures.py @@ -801,6 +801,8 @@ def __init__{_call_signature( return_annotation=False, include_kwargs=True, include_init_header=True, + allow_data_node_kwargs=False, + allow_batch_kwargs=False, )}: ... From 2137a04a24e5bdd60b363d29864f9b8dc9d99997 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 16 Mar 2026 09:27:46 +0000 Subject: [PATCH 18/23] Fix tensor arg handling in reader op constructor Signed-off-by: Rostan Tabet --- .../nvidia/dali/experimental/dynamic/_op_builder.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 3c20485f44b..d2937ae56da 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -199,18 +199,20 @@ def build_constructor(schema, op_class): # Note: Base __init__ will keep the **kwargs def init(self, max_batch_size, name, **kwargs): if is_reader: - actual_tensor_arg_names = {name for name in tensor_arg_names if kwargs.get(name)} + actual_tensor_arg_names = { + arg_name for arg_name in tensor_arg_names if kwargs.get(arg_name) is not None + } tensor_args = {} - for k in tensor_arg_names: - arg = kwargs.get(k) + for arg_name in tensor_arg_names: + arg = kwargs.get(arg_name) if arg is None or isinstance(arg, (int, float, bool, str, tuple, list)): continue - del kwargs[k] + del kwargs[arg_name] if isinstance(arg, Batch): raise ValueError("Readers cannot be constructed with batch keyword arguments") if not isinstance(arg, Tensor): # perform a copy if not an ndd tensor arg = to_tensor(arg) - tensor_args[k] = arg + tensor_args[arg_name] = arg kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: # Need to be done here not to be overridden by the constructor From ccbe8279954e23c4687f66221d3ff0ac83afa74f Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 16 Mar 2026 09:57:15 +0000 Subject: [PATCH 19/23] Fix typos Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_op_builder.py | 2 +- .../general/data_loading/numpy_reader/dynamic_mode.ipynb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index d2937ae56da..6e21a879908 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -302,7 +302,7 @@ def call(self, *raw_args, batch_size=None, _process_params=True, **raw_kwargs): if overlap: raise ValueError( f"Keyword argument{'s'[:len(overlap)^1]} {sorted(overlap)}" - f" cannot be passed in both in the constructor and __call__." + f" cannot be passed both in the constructor and __call__." ) raw_kwargs = {**raw_kwargs, **self._raw_tensor_args} diff --git a/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb b/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb index 28065005135..78006e45a8a 100644 --- a/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb +++ b/docs/examples/general/data_loading/numpy_reader/dynamic_mode.ipynb @@ -334,7 +334,7 @@ "
\n", "Note
\n", "\n", - "It also also possible to specify the ROI by calling the reader directly: `reader(roi_start=..., roi_end=...)`.\n", + "It is also possible to specify the ROI by calling the reader directly: `reader(roi_start=..., roi_end=...)`.\n", "
\n", "\n", "Let us see a few practical examples:" From f2382ac465e8d8cb9a25074dbf656232e4f1c03b Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Wed, 18 Mar 2026 13:26:11 +0000 Subject: [PATCH 20/23] Copy all tensors passed to constructors and perform only broadcast in _process_tensor_args Signed-off-by: Rostan Tabet --- .../dali/experimental/dynamic/_op_builder.py | 4 +--- .../nvidia/dali/experimental/dynamic/_ops.py | 17 +++++++++-------- 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index 6e21a879908..b3735a9e274 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -210,9 +210,7 @@ def init(self, max_batch_size, name, **kwargs): del kwargs[arg_name] if isinstance(arg, Batch): raise ValueError("Readers cannot be constructed with batch keyword arguments") - if not isinstance(arg, Tensor): # perform a copy if not an ndd tensor - arg = to_tensor(arg) - tensor_args[arg_name] = arg + tensor_args[arg_name] = to_tensor(arg) kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: # Need to be done here not to be overridden by the constructor diff --git a/dali/python/nvidia/dali/experimental/dynamic/_ops.py b/dali/python/nvidia/dali/experimental/dynamic/_ops.py index 59666e17ee8..dc8e17bf85a 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_ops.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_ops.py @@ -679,14 +679,15 @@ def _process_tensor_args(self, batch_size: int | None): """Converts stored tensor args to Batch/Tensor form for the given batch_size.""" if not self._raw_tensor_args: return {} - if self._previous_batch_size == batch_size: - return self._tensor_args - _, self._tensor_args = self._process_params( - self._backend, - self._device, - batch_size, - **self._raw_tensor_args, - ) + + if batch_size is None: + self._tensor_args = self._raw_tensor_args + elif self._previous_batch_size != batch_size: + self._tensor_args = { + name: Batch.broadcast(sample, batch_size) + for name, sample in self._raw_tensor_args.items() + } + self._previous_batch_size = batch_size return self._tensor_args From 59aa5c642b3aabf9f2ae480de20a8f61bdfa690a Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Wed, 18 Mar 2026 17:02:16 +0000 Subject: [PATCH 21/23] Revert the change to the caller depth. PR #6262 fixes the caller depth properly. Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py | 1 + dali/python/nvidia/dali/experimental/dynamic/_invocation.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py b/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py index c38ac9527b9..315a0579d06 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py @@ -64,6 +64,7 @@ def __call__( is_batch=False, batch_size=None, previous_invocation=None, + caller_depth=3, ) invocation.apply_eval_policy(_op_builder.is_external(batch)) return Tensor(invocation_result=invocation[0]) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py index 539ba77eab4..a57a458c63d 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py @@ -50,7 +50,7 @@ def __init__( is_batch: bool = False, batch_size: Optional[int] = None, previous_invocation: Optional["Invocation"] = None, - caller_depth: int = 3, + caller_depth: int = 4, ): """ Parameters From 0a640ea6a58dfd1dac0822287f67ccddd2d48bbb Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Thu, 19 Mar 2026 13:31:20 +0000 Subject: [PATCH 22/23] Perform dtype conversion of reader constructor arguments Signed-off-by: Rostan Tabet --- dali/python/nvidia/dali/experimental/dynamic/_invocation.py | 2 +- dali/python/nvidia/dali/experimental/dynamic/_op_builder.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py index a57a458c63d..f5fd62c8e9f 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_invocation.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_invocation.py @@ -26,7 +26,7 @@ from nvidia.dali import backend as _b if TYPE_CHECKING: - from .ops import Operator + from ._ops import Operator class Invocation: diff --git a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py index b3735a9e274..3e6c1054979 100644 --- a/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py +++ b/dali/python/nvidia/dali/experimental/dynamic/_op_builder.py @@ -210,7 +210,8 @@ def init(self, max_batch_size, name, **kwargs): del kwargs[arg_name] if isinstance(arg, Batch): raise ValueError("Readers cannot be constructed with batch keyword arguments") - tensor_args[arg_name] = to_tensor(arg) + dtype = op_class._argument_conversion_map[arg_name] + tensor_args[arg_name] = to_tensor(arg, dtype=dtype) kwargs = {k: _scalar_decay(v) for k, v in kwargs.items()} op_class.__base__.__init__(self, max_batch_size, name, **kwargs) if is_reader: # Need to be done here not to be overridden by the constructor From cd2bd3918310e185d2b04de844f4169f60f35991 Mon Sep 17 00:00:00 2001 From: Rostan Tabet Date: Mon, 13 Apr 2026 17:19:33 +0000 Subject: [PATCH 23/23] Do not add trailing wildcards in glob patterns Signed-off-by: Rostan Tabet --- dali/test/python/experimental_mode/test_reader_decoder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dali/test/python/experimental_mode/test_reader_decoder.py b/dali/test/python/experimental_mode/test_reader_decoder.py index 9c64e66ffc8..9441dfa17ec 100644 --- a/dali/test/python/experimental_mode/test_reader_decoder.py +++ b/dali/test/python/experimental_mode/test_reader_decoder.py @@ -184,7 +184,7 @@ def test_reader_shards_error(): num_shards=99999, ) with assert_raises( - RuntimeError, glob='Assert on "num_shards_ <= Size()" failed: The number of input samples:*' + RuntimeError, glob='Assert on "num_shards_ <= Size()" failed: The number of input samples:' ): tuple(reader.next_epoch()) @@ -240,5 +240,5 @@ def test_video_resize_tensor_repeated_args(): resize_x=108, resize_y=192, ) - with assert_raises(ValueError, glob="*resize_x*"): + with assert_raises(ValueError, glob="resize_x"): reader(resize_x=144)