AutoGineer
Generated banner for Tao Convert Dataset Format
Generated logo for Tao Convert Dataset Format

Tao Convert Dataset Format

NVIDIAOfficialCreated by NVIDIA Corporation

  • Skill
  • Tool integration
  • Agent tooling
  • Apache-2.0
  • Medium risk
Download ZIP

From the author

Run `tao-daft convert` to convert NVIDIA TAO DAFT datasets between supported formats. Do not use for non-DAFT data. Use when the user asks to convert a DAFT dataset, change DAFT format, change a TAO dataset format, or run `tao-daft convert`.
— the description by NVIDIA Corporation

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides an interface to the tao-daft convert command, enabling users to transform DAFT-formatted datasets into different supported versions or formats. It emphasizes the use of the underlying CLI tool to ensure compatibility and accuracy, requiring users to discover supported format slugs and flags dynamically via the tool's help system. The skill is strictly for DAFT-to-DAFT conversions and requires the nvidia-tao-daft package.

What it does

  • Executes the tao-daft convert command to transform dataset formats.
  • Supports discovery of available source and target formats via CLI help.
  • Handles path and output directory specifications for dataset conversion.
  • Provides guidance on using per-pair flags for specific conversion requirements.
  • Verifies the installation of the required nvidia-tao-daft package.

When to use it

  • When you need to convert a DAFT dataset from one format to another.
  • When preparing DAFT datasets for VLM training or specific task workflows.
  • When you need to change the format of a TAO dataset.
  • When you need to run the tao-daft convert command within an agentic workflow.

Advantages

  • Ensures consistency by using the official CLI as the single source of truth.
  • Supports tree-based conversion for large dataset directories.
  • Provides a structured approach to discovering valid format pairs and flags.
  • Reduces errors by enforcing correct flag usage for paths and outputs.

Usage examples

“Convert my DAFT dataset at /data/input to the cosmos-reason-v1.0 format in /data/output.”
The agent will identify the source format, verify the target, and execute the tao-daft convert command with the appropriate flags.
“What formats can I convert my metropolis-v3.0 dataset into?”
The agent will run tao-daft convert metropolis-v3.0 --help to list all valid target formats supported by the current installation.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/tao-convert-dataset-format/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip tao-convert-dataset-format.zip -d .agents/skills

Documentation by NVIDIA Corporation

Convert a TAO DAFT Dataset

Standalone install? If this session was not initialized by the TAO skill bank plugin, run the tao-setup skill first (host preflight, credentials, cross-skill discovery).

Quick start

tao-daft convert <source-format> <target-format> --path <input> --output <output>

Source and target are positional subcommands; --path and --output are flags. Discover the supported formats and per-pair flags from the leaf --help (see "CLI conventions" below).

Preflight

python -c "import nvidia_tao_daft" 2>/dev/null || {
  echo "MISSING: tao-daft not installed. Run:"
  echo "  pip install nvidia-tao-daft"
  exit 1
}

Quick Start

Discover the installed CLI surface before choosing format slugs, then run the leaf conversion command with explicit --path and --output flags:

tao-daft --version
tao-daft convert --help
tao-daft convert <source-format> --help
tao-daft convert <source-format> <target-format> --path /path/to/daft --output /path/to/converted

Purpose

Drives tao-daft convert to transform a DAFT dataset (or a tree of them) between supported formats. The CLI does the real work; the skill picks the right source/target pair and flags, then explains the result.

Trigger on: converting a DAFT dataset, packaging DAFT QA / summarization / temporal tasks for VLM training, producing a meta.json-style training set, or the command tao-daft convert. Do not trigger for non-DAFT → DAFT conversion (COCO, YOLO, Data Factory JSONL) — redirect to the upstream nvidia-tao-daft repo's converter skills.

If the user opens ambiguously, run a few --help calls first.

Prerequisites

  • nvidia-tao-daft installed (wheel only, not the source repo). Confirm with tao-daft --version.

  • A DAFT dataset, or a parent directory containing many, on local disk.

Instructions

CLI conventions

tao-daft is nested argparse subcommands. The conventions below are stable across versions even when format names or flags change, so always discover the current surface from --help rather than relying on names this doc happens to mention.

  1. Source and target are both positional subcommands, not --from/--to: tao-daft convert <source> <target> [flags]. Format slugs are versioned, lowercase, dot-separated (metropolis-v3.0, cosmos-reason-v1.0, ...).

  2. Path and output are flags — --path PATH (source), --output OUTPUT (destination). Both required at the leaf; passing positionally fails.

  3. --path accepts both granularities — a single scene/dataset or a parent directory; the converter walks the tree.

  4. Per-pair flags live at the leaf — flag sets differ between targets (e.g. media-handling). Always check the leaf --help.

Operating procedure:

  1. tao-daft --version — confirm install, pin version in any report.

  2. tao-daft convert --help — list supported source formats.

  3. tao-daft convert <source> --help — list valid targets for that source.

  4. Infer source from layout (same directory markers as the tao-validate-dataset-format skill's "Format inference"). If you cannot infer or the target is unspecified, ask.

  5. tao-daft convert <source> <target> --help — pick flags for the user's intent (task subset, media copy vs reference, metadata).

  6. Execute, then interpret (see below).

Reading output

Per-scene progress prints to stdout; non-zero exit on failure. The converted dataset is written under --output — spot-check it with the tao-validate-dataset-format skill before training. For large trees, capture the full output and partial-read if huge.

Limitations

  • DAFT-supported source formats only. For non-DAFT layouts use the upstream repo's converter skills.

  • Supported pairs are whatever --help reports for the installed version — don't pass an unconfirmed pair.

  • Source and target are positional; --path / --output are flags.

  • convert only — validate and info have their own skills.

  • Do not reimplement conversion in Python; the CLI is the spec.

Troubleshooting

  • tao-daft: command not found — wheel not installed; pip install nvidia-tao-daft, verify with tao-daft --version.

  • error: argument --path/--output is required — passed positionally; move behind the flag.

  • invalid choice: '<format>' — slug not wired up in this version. Re-run the relevant --help.

  • Output rejected by tao-daft validate — re-check per-pair flags (media handling, task subset) via leaf --help; a misset flag often produces a structurally valid but semantically wrong target.

Files

BENCHMARK.md

Skill Benchmark: tao-convert-dataset-format

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

Recommended for publication based on the completed evaluation evidence in this report.

Evaluation Metadata

  • Skill: tao-convert-dataset-format

  • Evaluation date: 2026-09-17

  • Evaluator version: 1.5.6

  • Agents: Claude Code (aws/anthropic/bedrock-claude-opus-4-8), Codex (openai/openai/gpt-5.5)

  • Tasks: 1 evaluation tasks (1 positive)

  • Dataset digest: sha256:2fbc3074b2bf29c63e5b9adbd1040448530ede1c8e428e64ca96693b0b9236a1 (skill-evaluator-dataset-snapshot/1)

  • Attempts per task: 3

  • Environment: k8s-sandbox

  • Tier 2 evidence: required for publication

  • Tier 3 evidence: required for publication

Each task attempt ran in its own isolated sandbox pod.

What This Report Answers

The three-tier evaluation checks whether the skill:

  • is safe to use;

  • produces correct answers;

  • is discovered and activated when needed;

  • helps the agent complete the user's goal and expected workflow; and

  • avoids wasted skill and tool usage.

Results at a Glance

MeasureClaude Code (Baseline → Skill Uplift)Codex (Baseline → Skill Uplift)
Overall99.6% — baseline ran, but no comparable score was available; uplift unavailable70.7% — baseline ran, but no comparable score was available; uplift unavailable
Security100.0% → 100.0% (±0.0 points)100.0% → 100.0% (±0.0 points)
Correctness0.0% → 100.0% (+100.0 points)0.0% → 80.0% (+80.0 points)
Discoverability100.0% — baseline ran, but no comparable score was available; uplift unavailable0.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness16.7% → 100.0% (+83.3 points)16.7% → 75.0% (+58.3 points)
Efficiency97.8% — baseline ran, but no comparable score was available; uplift unavailable99.7% → 98.6% (-1.1 points)

How to read this table: baseline is the same task attempted without the target skill. Scores are rounded to one decimal; threshold-adjacent values use additional precision so their displayed band matches the verdict. Uplift is derived from those displayed scores and shown in percentage points.

Example: 47.0% → 92.0% (+45.0 points) means the skill-assisted run scored 92.0%, 45.0 percentage points above its 47.0% no-skill baseline.

A partial dimension was calculated from only the available configured signals; review the detailed report before relying on it.

Token Usage

Actual Tier 3 execution usage is reported for every observed agent/case pair and both conditions.

AgentDataset caseWith skillWithout skillDeltaChangeCoverage
claude-codeAll cases66,92390,910N/AN/Askill 1/1; base 3/3
claude-codetao-convert-dataset-format-basic66,92390,910N/AN/Askill 1/1; base 3/3
codexAll cases13,78440,805N/AN/Askill 1/1; base 3/3
codextao-convert-dataset-format-basic13,78440,805N/AN/Askill 1/1; base 3/3
ALL AGENTSDataset aggregate80,707131,715N/AN/Askill 2/2; base 6/6

Prompt tokens include cached reads, so total tokens are prompt + completion (cached is not added twice). The Efficiency score uses (prompt - cached) + completion. N/A means the relevant trajectory counters were not available; coverage is never estimated.

Tier Status

TierPurposeStatusEvidence
Tier 1Static validationPASSED WITH OBSERVATIONS11 validator(s); 8 finding(s)
Tier 2Semantic deduplicationPASSED WITH OBSERVATIONS2 validator(s); 1 finding(s)
Tier 3Live agent evaluationPASS2 agent(s); 1 task(s)

Findings and Observations

<details> <summary>Show detailed findings and successful checks</summary>

  • HIGH DUPLICATE/duplicate: Duplicate content found within SKILL.md: "# Convert a TAO DAFT Dataset" in SKILL.md (lines 1-4) vs "## Quick start" in SKILL.md (lines 5-14) vs "## Quick Start" in SKILL.md (lines 24-35) vs "## Purpose" in SKILL.md (lines 36-51) vs "### CLI conventions" in SKILL.md (lines 61-92) (SKILL.md:1)

  • MEDIUM QUALITY/quality_correctness: SKILL_SPEC recommended field missing: 'metadata.tags' (skills/data/tao-convert-dataset-format/SKILL.md)

  • MEDIUM SCHEMA/frontmatter_field_placement: Root field 'tags' is ignored; use 'metadata.tags' (skills/data/tao-convert-dataset-format/SKILL.md)

  • MEDIUM SCHEMA/folder_hierarchy: Unexpected nesting depth for general skill (skills/data/tao-convert-dataset-format)

  • MEDIUM SCHEMA/body_recommended_section: Missing recommended section: '## Examples' (skills/data/tao-convert-dataset-format/SKILL.md)

  • 4 additional finding(s) are available in the full evaluation artifacts.

</details>

Scoring Methodology

<details> <summary>Show dimension definitions, source signals, and thresholds</summary>

DimensionQuestionScored signals
SecurityIs it safe to use?security (100%)
CorrectnessIs the answer correct?accuracy (100%)
DiscoverabilityWas the right skill loaded when needed?skill_execution (100%)
EffectivenessDid the skill help complete the task?goal_accuracy (50%) + behavior_check (50%)
EfficiencyDid it avoid wasted tool calls and token usage?skill_efficiency (50%) + token_efficiency (50%)

  • Dimension bands: PASS at 50% or above; NEUTRAL from 40% to below 50%; FAIL below 40%.

  • Overall Tier 3 lift: PASS at +5 points or more; FAIL at -10 points or less; values between those bands are NEUTRAL.

  • Overall verdict: PASS only when every configured dimension passes for at least one supported agent. Lift is reported as diagnostic evidence and does not override this gate.

  • The 50% attempt pass threshold is a separate per-task gate; it is not the dimension pass threshold.

  • Effectiveness is the equal-weight mean of goal completion (goal_accuracy) and expected workflow adherence (behavior_check).

  • Efficiency is 50% tool-call productivity (the backward-compatible skill_efficiency wire id) and 50% token_efficiency. Positive-case skill routing is scored under Discoverability, not Efficiency; a negative case without a routing target is N/A. N/A sources are omitted, remaining weights are renormalized, and the dimension is marked partial.

Signals present in this run:

  • security (Security): unsafe operations, secret leakage, and unauthorized access.

  • skill_execution (Skill Execution): whether the expected skill was selected, decoys were avoided, and the workflow executed.

  • skill_efficiency (Tool Productivity): tool-call productivity (legacy wire id; routing is scored under Discoverability).

  • accuracy (Accuracy): final-answer correctness against the reference answer.

  • goal_accuracy (Goal Accuracy): whether the user's goal was achieved.

  • behavior_check (Behavior Check): whether the expected workflow behavior was followed.

  • token_efficiency (Token Efficiency): actual uncached prompt plus completion usage (50% of Efficiency).

</details>

Freshness

Regenerate this benchmark when the skill, evaluation dataset, target agent/model, evaluator version, environment, or scoring policy changes.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Declares allowed tools, Needs Python

The author says: Requires Python 3.10+ and the nvidia-tao-daft package (pip install nvidia-tao-daft).

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
NVIDIA Corporation
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/tao-convert-dataset-format · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by NVIDIA Corporation or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download tao-convert-dataset-format.zip