DALI Dynamic Mode Assistant
Helps agents write, review, and migrate NVIDIA DALI imperative dynamic-mode code.
The skill is guidance-only, requires no API key or external credential, and contains no network access, exfiltration, destructive operation, or disproportionate permission instructions. It lacks explicit execution confirmation, sensitive-data boundaries, dependency-integrity checks, and rollback guidance, so 7 points are deducted.
SKILL.md gives internally consistent rules and examples for dynamic mode, batching, stateful readers, asynchronous execution, checkpointing, and troubleshooting. However, it depends on NVIDIA DALI/CUDA/PyTorch, has no pinned versions or locally reproducible tests, and provides limited abnormal-input coverage. Static evidence supports 9 points under the calibration cap.
Audience, scenarios, and the boundary excluding pipeline-only tasks are clear, with migration, debugging, and varied batch examples. Semantic trigger details, broader non-fit ranges, Chinese support, and mainland-China reachability are not established; GPU requirements also constrain environments, so 5 points are deducted.
The documentation is well organized and covers prerequisites, data types, readers, devices, execution, checkpointing, examples, mistakes, migration, limitations, and troubleshooting. Apache-2.0 licensing, authorship, team ownership, version metadata, and evaluation information are present. There is no dedicated changelog, precise dependency versioning, installation procedure, or clear update path, so 5 points are deducted.
The skill directly addresses writing, reviewing, migrating, and debugging DALI dynamic-mode code, with examples that can be adapted into Python outputs. The evaluation report provides limited task-level correctness and effectiveness evidence, but its source dataset and representative outputs are unavailable, and not all claimed scenarios are covered. The static cap therefore limits the score to 7.
Committed migration fixtures, assertion-based evals, and an evaluation report provide some auditability. The report says the evaluation dataset is unavailable, and there is no executable test suite or independent reproduction covering the skill's key paths. Static review cannot independently verify API correctness, so 6 points are deducted.
- Before execution, verify compatible NVIDIA DALI, CUDA/driver, and target-framework versions; the supplied material does not pin versions or prove execution for this revision.
- The evaluation report's source dataset is unavailable, so its results should not be treated as independently reproducible evidence.
- The skill involves local data reads, GPU execution, and checkpoint writes; users should independently review paths, data sensitivity, resource consumption, and recovery procedures.
- Mainland-China network reachability is not established by the source material; the core function depends on local NVIDIA software and GPU hardware rather than a clearly required overseas online service.
What does this skill do, and when should you use it?
This skill targets NVIDIA DALI's imperative dynamic API, nvidia.dali.experimental.dynamic, commonly abbreviated as ndd. It guides agents to call DALI operators directly from ordinary Python control flow instead of building and running a Pipeline graph. It covers Tensor and Batch handling, stateful readers, device behavior, execution modes, RNG, checkpointing, and PyTorch conversion. It is intended for dynamic-mode development and Pipeline-to-dynamic migration, not Pipeline-only tasks.
Guides agents to import ndd and write direct DALI calls; create and reuse stateful readers; pass explicit batch_size to random operations; use GPU decoding, Tensor/Batch slicing, and PyTorch conversion; select synchronous evaluation modes for debugging; configure seeds and worker threads; register, save, and restore reader and RNG checkpoints; and correct common mistakes through Pipeline-to-dynamic API mappings.
- A DALI developer needs to build data-loading and preprocessing code with ordinary Python control flow.
- An engineer is migrating code that uses Pipeline, @pipeline_def, or pipe.run() to dynamic mode.
- A computer-vision training workflow needs image reading, GPU decoding, resizing, cropping, and normalization.
- A developer needs to handle variable-shaped batches and convert them to padded PyTorch tensors.
- A distributed-training workflow needs sharded readers or reader and RNG checkpoint restoration.
- A developer is debugging asynchronous DALI operations and needs failures to surface at the call site.
What are this skill's strengths and limitations?
- Covers dynamic-mode data types, readers, device inference, evaluation modes, RNG, and checkpointing.
- Clearly distinguishes sample selection with batch.tensors[] from within-sample slicing with batch.slice[].
- Provides concrete Pipeline-to-dynamic mappings and common-error corrections.
- Explains padded PyTorch conversion for variable-shaped batches.
- Dynamic mode may perform slightly worse than Pipeline mode; Pipeline mode is preferred for maximum throughput.
- GPU decoding and GPU operators require a CUDA-capable DALI build plus an available NVIDIA GPU and driver.
- PyTorch conversion of ragged batches requires pad=True and otherwise raises for non-uniform shapes.
- The source does not provide an independent test suite, numeric performance benchmarks, or a specific supported DALI version.
How do you install this skill?
Install the specific skill with the NVIDIA skills CLI: npx skills add nvidia/skills --skill dali-dynamic-mode --yes. The README does not specify an independent skill version, extra package source, or fixed installation directory; the CLI handles the destination.
How do you use this skill?
After installation, give the agent a task-specific request such as: “Using nvidia.dali.experimental.dynamic as ndd, migrate this DALI Pipeline code to dynamic mode and follow the next_epoch(batch_size=64), device="gpu", and explicit Batch slicing rules.” Skip the skill for Pipeline-only work. Before running or validating code, ensure nvidia.dali.experimental.dynamic is importable; PyTorch is additionally required for .torch() examples.
How does this skill compare with similar options?
Compared with DALI Pipeline mode, dynamic mode uses direct ordinary-Python calls, stateful readers, and next_epoch(batch_size), while using device="gpu" instead of device="mixed". The skill describes dynamic mode as more flexible but potentially slower, and recommends Pipeline mode for maximum throughput.