Skip to content
OpenSmartRoute
Skillv1.0.0

tao-convert-dataset-format

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 d

by nvidia(0) 0 installs
Free
Sign in to install

Free account. Installing gives you the manifest plus copy-paste snippets.

See reviews

About

Imported from nvidia/skills (skills/tao-convert-dataset-format/SKILL.md) via skills.sh. Install upstream with npx skills add nvidia/skills --skill tao-convert-dataset-format. Copyright stays with the author (Apache-2.0).

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.

Use it

Copy one of these into your project. Installing also returns the manifest and these snippets.

yaml
targets:
  - https://api.opensmartroute.ai/api/v1/registry/nvidia-skills-tao-convert-dataset-format/manifest   # or paste the manifest below

Manifest

An Open Capability Manifest: the router reads it to know what this does, what it costs and when to pick it.

nvidia-skills-tao-convert-dataset-format.ocm.jsonjson
{
  "ocm": "1",
  "id": "nvidia-skills-tao-convert-dataset-format",
  "kind": "skill",
  "name": "tao-convert-dataset-format",
  "description": "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`.",
  "publisher": "nvidia",
  "version": "1.0.0",
  "capabilities": {
    "domains": [
      "data_analysis"
    ],
    "tags": [
      "skill-md",
      "tao-daft",
      "dataset",
      "conversion",
      "vlm",
      "cosmos-reason",
      "skills-sh"
    ],
    "languages": [
      "en"
    ]
  },
  "quality_prior": 0.6,
  "examples": [
    "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`."
  ],
  "primary": false,
  "metadata": {
    "source": {
      "provider": "skills.sh",
      "repository": "https://github.com/nvidia/skills",
      "path": "skills/tao-convert-dataset-format/SKILL.md",
      "ref": "HEAD",
      "url": "https://www.skills.sh/nvidia/skills/tao-convert-dataset-format",
      "key": "nvidia/skills/skills/tao-convert-dataset-format/SKILL.md"
    },
    "compatibility": "Requires Python 3.10+ and the nvidia-tao-sdk package (pip install nvidia-tao-daft).",
    "allowed_tools": [
      "Read",
      "Bash"
    ],
    "license": "Apache-2.0"
  },
  "instructions": "# Convert a TAO DAFT Dataset\n\n> **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).\n\n## Quick start\n\n```bash\ntao-daft convert <source-format> <target-format> --path <input> --output <output>\n```\n\nSource and target are positional subcommands; `--path` and `--output` are flags.\nDiscover the supported formats and per-pair flags from the leaf `--help`\n(see \"CLI conventions\" below).\n\n## Preflight\n```bash\npython -c \"import nvidia_tao_daft\" 2>/dev/null || {\n  echo \"MISSING: tao-",
  "cost": {
    "context_tokens": 1161
  }
}

Fetch it by URL: GET /api/v1/registry/nvidia-skills-tao-convert-dataset-format/manifest?version=1.0.0

Reviews

Star ratings from people who tried it. One review per account; edit yours any time.

No reviews yet. Install it, try it, and be the first to rate it.