Official agent skill

TAO Object Detection Gap Analysis

by NVIDIA in NVIDIA/skills

Runs TAO Data Services gap analysis that compares ground-truth and predicted boxes to find weak images by per-class recall, precision and AP50.

OfficialApache-2.0Auto-check: notesAI & LLM Engineering

Install TAO Object Detection Gap Analysis

skills CLI
$ npx skills add NVIDIA/skills --skill tao-analyze-gaps-od-map -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install NVIDIA/skills tao-analyze-gaps-od-map --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/tao-analyze-gaps-od-map .claude/skills/tao-analyze-gaps-od-map && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
tao-analyze-gaps-od-map
GitHub stars
3.6k
Token cost
~1.8k tokens
SKILL.md length
671 words
Files
9 (incl. scripts, references, assets)
Skills in repo
390
Repo updated
First seen
Licence
Apache-2.0

At a glance

Runs TAO Data Services gap analysis that compares ground-truth and predicted boxes to find weak images by per-class recall, precision and AP50.

  • Works in 3 steps: Verify Docker access → Resolve and pull the data-services image… → Confirm RUN_ROOT contains the spec, both…
  • Finding images where a detector underperforms for a class
  • SKILL.md covers Inputs, Quick Start, Preflight and Outputs, plus 1 more section
  • Runs Python scripts from its folder; calls docker and python3

What it does

The skill runs the gap_analysis object_detection entrypoint of the TAO Data Services container against an object detection spec. It compares ground-truth and inference annotations in KITTI or COCO format, computes per-image, per-class TP, FP, FN and AP50, and flags images where any class metric falls below its threshold. It does not run inference, so predictions must already exist.

The spec requires paths for ground truth, inference, images and results, a kpi tag and an explicit input_format. Optional fields set the IoU threshold (default 0.5), a confidence cutoff, minimum box area, class mapping and per-class weak thresholds, and the notes advise setting the default AP50 fallback to 0 so unlisted classes never mark an image weak. A template spec and verify_object_detection_spec.py are bundled, and the spec should be filled from the template rather than hand-written.

When your agent uses it

  • Finding images where a detector underperforms for a class
  • Selecting weak images for another training round
  • Setting per-class recall and AP50 thresholds
  • Checking KITTI or COCO predictions against ground truth

Example prompts

  • “Analyze OD gaps for my COCO ground truth and model predictions.”
  • “Find weak images where car recall is below 0.99.”
  • “Run mAP gap analysis and write the results to the results directory.”

Requirements

  • docker and nvidia-container-toolkit
  • The TAO data-services container pinned in versions.yaml
  • Inference annotations from an earlier step
  • Compatibility (from SKILL.md): Requires docker, nvidia-container-toolkit, and the TAO data-services container pinned in versions.yaml.
  • Pre-approved tools (allowed-tools): Read, Bash

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Verify Docker access
  2. Resolve and pull the data-services image if needed
  3. Confirm RUN_ROOT contains the spec, both annotation sources, and the image directory. Mount RUN_ROOT to the same absolute path inside…

What it can do on your machine

Read from SKILL.md and the folder at commit 14a98ae. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • docker
    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use docker, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Requires docker, nvidia-container-toolkit, and the TAO data-services container pinned in versions.yaml.

    From compatibility in the SKILL.md frontmatter.

Context cost

TAO Object Detection Gap Analysis loads about 1.8k tokens when it runs, and up to ~1.9k if it reads all its reference files. Until then it costs about 98 tokens; SKILL.md has 671 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~98
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~1.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Bash

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from NVIDIA/skills at commit 14a98ae, republished under its Apache-2.0 licence (© NVIDIA). 671 words, ~1,756 tokens.

Download SKILL.mdSave it as .claude/skills/tao-analyze-gaps-od-map/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
tao-analyze-gaps-od-map
description
Run TAO Data Services object-detection gap analysis from ground-truth and inference annotations. Use when an object detection workflow needs to identify weak images by comparing model predictions against ground truth using per-class recall, precision, and AP50 thresholds. Use when the user asks to "analyze OD gaps", "find weak OD images", or "run mAP gap analysis".
allowed-tools
Read, Bash
compatibility
Requires docker, nvidia-container-toolkit, and the TAO data-services container pinned in versions.yaml.
license
Apache-2.0
metadata.author
NVIDIA Corporation
metadata.version
0.1.0
tags
tao, data, gap-analysis, object-detection, mAP, rcca

TAO Analyze Gaps OD mAP

Use this skill to run TAO Data Services object-detection gap analysis. The skill compares ground-truth and inference annotations, computes per-image per-class TP/FP/FN/AP50 metrics, and identifies weak images where any class metric falls below its threshold. It does not run inference; upstream steps must produce the inference annotations first.

The container entrypoint is:

bash
gap_analysis object_detection -e /absolute/path/to/object_detection.yaml

Inputs

Required spec fields:

FieldMeaning
ground_truth_ann_pathKITTI label directory or COCO .json with ground-truth boxes.
inference_ann_pathKITTI label directory or COCO .json with model predictions.
images_dirRoot image directory. Establishes the full image universe including unannotated images.
results_dirOutput directory for all artifacts.
kpiIdentifier tag written to every output row.
input_formatkitti or coco. Must be declared explicitly; never inferred from the path.

Common optional fields:

FieldDefaultMeaning
iou_threshold0.5IoU at or above which a prediction is accepted as a true positive.
conf_threshold0.0Predictions below this confidence are dropped before matching.
min_area0Boxes whose pixel area (w × h) is strictly below this value are discarded.
class_mapping{}Maps raw annotation label strings to canonical class names. Absent labels are kept as-is.
weak_thresholds{}Per-class thresholds as {class_name: {recall, precision, ap50}}. Absent keys fall back to the default_*_threshold values. Reference ITS defaults: car 0.99, bicycle 0.7, person 0.7 — a strict gate on the abundant, well-learned class and looser gates on the rare ones the loop exists to improve.
default_recall_threshold0.5Fallback recall threshold for classes not listed in weak_thresholds.
default_precision_threshold0.0Fallback precision threshold. Set to 0.0 to disable precision-based weak selection.
default_ap50_threshold0.5Fallback for classes absent from weak_thresholds. Set 0.0 so unlisted classes never mark an image weak — the reference filter had no fallback, and leaving TAO DS's 0.5 in place silently gates every class you did not list.

Do not hand-write the spec. Copy the template and fill in the nulls — every tuning value it already carries is the one this stage wants — then validate:

bash
cp skills/data/tao-analyze-gaps-od-map/assets/default_object_detection.yaml "$SPEC"
# fill ground_truth_ann_path, inference_ann_path, images_dir, results_dir, kpi, input_format
python3 skills/data/tao-analyze-gaps-od-map/scripts/verify_object_detection_spec.py --spec "$SPEC"

verify rejects the spellings that fail — uppercase input_format, relative or missing paths, a weak_thresholds entry that is a bare number rather than a mapping — and reports every gated class plus the default_* fallbacks, so the selection criteria behind a weak set are recoverable from the run's output. It warns when a fallback is above zero, since that gates classes you did not list.

Show full SKILL.md (290 more words)Show less

Quick Start

Run from the tao-skill-bank repo root.

Write the spec into the results directory. The run emits four artifacts and does not retain the spec, so a completed gap analysis otherwise cannot tell you which thresholds produced its weak set — and that weak set sizes the mining budget downstream. Keeping them together makes the selection criteria recoverable from the run alone.

bash
RESULTS_DIR=/absolute/path/for/this/run          # results_dir in the spec
SPEC="$RESULTS_DIR/object_detection.yaml"        # spec lives beside its outputs
RUN_ROOT=/absolute/path/that/contains/annotations/images/and/results
GPU_COUNT=1

DS_IMAGE=nvcr.io/nvidia/tao/tao-toolkit:7.2.0-data-services  # versions-key: images.tao_toolkit.data_services

docker run --rm --gpus "$GPU_COUNT" --shm-size=8g --network=host \
  -v "$RUN_ROOT:$RUN_ROOT" \
  -w "$RUN_ROOT" \
  "$DS_IMAGE" \
  gap_analysis object_detection -e "$SPEC"

Do not pass --user $(id -u):$(id -g); some TAO DS images call getpass.getuser() at startup and fail when the UID is not in /etc/passwd.

Preflight

  1. Verify Docker access:
bash
docker info > /dev/null
  1. Resolve and pull the data-services image if needed:
bash
DS_IMAGE=nvcr.io/nvidia/tao/tao-toolkit:7.2.0-data-services  # versions-key: images.tao_toolkit.data_services
docker image inspect "$DS_IMAGE" > /dev/null || docker pull "$DS_IMAGE"
  1. Confirm RUN_ROOT contains the spec, both annotation sources, and the image directory. Mount RUN_ROOT to the same absolute path inside Docker.

Outputs

ArtifactLocationContents
FP/FN box gapsresults_dir/box_gaps.parquetOne row per unmatched box: kpi, image_id, filepath, class, gap_type (FP/FN), bbox, confidence, best_iou.
Per-image metricsresults_dir/image_metrics.parquetPer-image per-class: tp, fp, fn, precision, recall, ap50.
Weak imagesresults_dir/weak_images.parquetImages where any class metric falls below threshold: filepath, weak_classes, weak_recall, weak_precision, weak_ap50. Feed this into tao-mine-od-images.
Gap reportresults_dir/gap_report.jsonFP/FN counts by type and class, plus run settings.

All four artifacts are always written, even when no gaps are found.

Troubleshooting

The subtask object_detection requires -e/--experiment_spec_file: rerun with gap_analysis object_detection -e "$SPEC".

Input path not found inside Docker: use a RUN_ROOT mount where host and container paths are identical.

input_format error: set input_format: kitti or input_format: coco explicitly — it is never inferred from the path.

weak_images.parquet is empty: all class metrics are above their thresholds. Lower default_recall_threshold / default_ap50_threshold or add per-class entries to weak_thresholds.

Output directory not writable after Docker exits: the container writes as root. Chown back with docker run --rm -v "$RUN_ROOT:$RUN_ROOT" alpine chown -R "$(id -u):$(id -g)" "$RESULTS_DIR".

© NVIDIA, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (scripts, references, assets) in skills/tao-analyze-gaps-od-map of NVIDIA/skills.

  • SKILL.md
  • BENCHMARK.md
  • assets/default_object_detection.yaml
  • config/skillspector-baseline.yaml
  • evals/evals.json
  • references/skill_info.yaml
  • scripts/verify_object_detection_spec.py
  • skill-card.md
  • skill.oms.sig

Open the folder on GitHubat commit 14a98ae

Compare with similar skills

TAO Object Detection Gap Analysis next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

TAO Object Detection Gap Analysis compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
TAO Object Detection Gap Analysis this skillNVIDIA/skills3.6k—~1.8kAutomated safety check: NotesApache-2.0
Setup Workshop Nemoclawbrevdev/workshop-build-an-agent146—~5.2kAutomated safety check: PassApache-2.0
Matlab Use Visual Inspectionmatlab/matlab-agentic-toolkit1.1k—~3.1kAutomated safety check: PassCustom licence
Yolo Detection 2026SharpAI/DeepCamera3.1k—~1.5kAutomated safety check: PassMIT
Yolo Detection 2026 OpenvinoSharpAI/DeepCamera3.1k—~1.3kAutomated safety check: PassMIT
Dstack Prototypingdstackai/dstack2.3k—~1.6kAutomated safety check: PassMPL-2.0

Similar skills

  • Setup Workshop Nemoclaw

    brevdev/workshop-build-an-agent

    Set up the NVIDIA "Build an Agent" DevX workshop as a working JupyterLab environment from INSIDE a locked-down OpenShell/NemoClaw sandbox, and hand the user the token URL + access commands.

    146 GitHub stars~5.2k tokensUpdated 2 days ago
    AI & LLM EngineeringAuto-check passed
  • Matlab Use Visual Inspection

    matlab/matlab-agentic-toolkit

    Build machine vision inspection systems with MATLAB Visual Inspection Toolbox.

    1.1k GitHub stars~3.1k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed
  • Yolo Detection 2026

    SharpAI/DeepCamera

    YOLO 2026 — state-of-the-art real-time object detection. An agent skill from SharpAI/DeepCamera.

    3.1k GitHub stars~1.5k tokensUpdated 23 days ago
    AI & LLM EngineeringAuto-check passed
  • OpenVINO — real-time object detection via Docker (NCS2, Intel GPU, CPU)

    3.1k GitHub stars~1.3k tokensUpdated 23 days ago
    AI & LLM EngineeringAuto-check passed
  • Dstack Prototyping

    dstackai/dstack

    Use with the dstack skill for model-serving work when the image, serving command, resources, backend/fleet choice, or service behavior is not proven.

    2.3k GitHub stars~1.6k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Nemotron Customizer Airgap

    NVIDIA-NeMo/Nemotron

    Prepare, validate, build, and use Nemotron Customizer airgap image bundles for offline clusters.

    2.1k GitHub stars~1.2k tokensUpdated 3 days ago
    AI & LLM EngineeringAuto-check passed

More from NVIDIA/skills

All 390 skills in this repo
  • Official

    A skill your agent uses when the user wants to deploy, run, debug, tear down, or call the REST API of the RTVI-CV 2D detection / tracking microservice.

    3.6k GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check passed
  • Official

    Generates, validates, compares and explains HOLOLINK_def.svh macro files for the HSB IP, using bundled Python scripts and asking before it writes anything.

    3.6k GitHub stars~2.9k tokensUpdated today
    Auto-check passed
  • Official

    Runs and validates an end-to-end Mission Control demo in a locally installed Isaac Sim, with a Nova Carter robot driven through a Python server.

    3.6k GitHub stars~4.8k tokensUpdated today
    Auto-check passed
  • Orchestrates defect image generation for PCBA, metal surface and glass inspection with NVIDIA Cosmos AnomalyGen on OSMO, from cold-start Day 0 to real-photo Day 1 labeling.

    3.6k GitHub stars~5k tokensUpdated today
    Auto-check: notes
  • Orchestrates video data augmentation and auto-labeling workflows on OSMO, from flow selection and preflight checks to submission, monitoring and output download.

    3.6k GitHub stars~4.7k tokensUpdated today
    Auto-check: notes
  • Official

    Runs NVIDIA TAO Data Services KPI analysis on object detection results, comparing predictions to ground truth and writing per-class precision, recall and AP to a CSV.

    3.6k GitHub stars~2.7k tokensUpdated today
    Auto-check: notes

Questions about TAO Object Detection Gap Analysis

What does TAO Object Detection Gap Analysis do?

Runs TAO Data Services gap analysis that compares ground-truth and predicted boxes to find weak images by per-class recall, precision and AP50. The skill runs the gap_analysis object_detection entrypoint of the TAO Data Services container against an object detection spec. It compares ground-truth and inference annotations in KITTI or COCO format, computes per-image, per-class TP, FP, FN and AP50, and flags images where any class metric falls below its threshold.

When should I use TAO Object Detection Gap Analysis?

TAO Object Detection Gap Analysis fits situations like: finding images where a detector underperforms for a class; selecting weak images for another training round; setting per-class recall and AP50 thresholds; checking KITTI or COCO predictions against ground truth.

How do I install TAO Object Detection Gap Analysis in Claude Code?

Run `npx skills add NVIDIA/skills --skill tao-analyze-gaps-od-map -a claude-code`. Or copy the skill folder (skills/tao-analyze-gaps-od-map in NVIDIA/skills) into .claude/skills/tao-analyze-gaps-od-map in your project. Claude Code loads it when a task matches its description.

How do I install TAO Object Detection Gap Analysis in Codex?

Run `npx skills add NVIDIA/skills --skill tao-analyze-gaps-od-map -a codex`. Or copy the skill folder (skills/tao-analyze-gaps-od-map in NVIDIA/skills) into .agents/skills/tao-analyze-gaps-od-map in your project. Codex loads it when a task matches its description.

Can I use TAO Object Detection Gap Analysis in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NVIDIA/skills --skill tao-analyze-gaps-od-map -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tao-analyze-gaps-od-map, .gemini/skills/tao-analyze-gaps-od-map, .github/skills/tao-analyze-gaps-od-map and .opencode/skills/tao-analyze-gaps-od-map in your project.

What does TAO Object Detection Gap Analysis need to run?

Going by SKILL.md and its folder, TAO Object Detection Gap Analysis needs Python for the scripts in its folder and the command-line tools its instructions call (docker and python3). Our summary lists: docker and nvidia-container-toolkit; The TAO data-services container pinned in versions.yaml; Inference annotations from an earlier step. Its frontmatter pre-approves these tools: Read, Bash. Compatibility (from SKILL.md): Requires docker, nvidia-container-toolkit, and the TAO data-services container pinned in versions.yaml..

Does TAO Object Detection Gap Analysis access the network?

SKILL.md contains no URLs. Its commands use docker, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is TAO Object Detection Gap Analysis safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does TAO Object Detection Gap Analysis use?

TAO Object Detection Gap Analysis is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does TAO Object Detection Gap Analysis use?

About 1.8k tokens (SKILL.md is roughly 7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 165 tokens, read only when the agent opens those files.

What are the alternatives to TAO Object Detection Gap Analysis?

Skills that share tags, products or a category with TAO Object Detection Gap Analysis: Setup Workshop Nemoclaw (brevdev/workshop-build-an-agent, 146 stars), Matlab Use Visual Inspection (matlab/matlab-agentic-toolkit, 1.1k stars), Yolo Detection 2026 (SharpAI/DeepCamera, 3.1k stars) and Yolo Detection 2026 Openvino (SharpAI/DeepCamera, 3.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains TAO Object Detection Gap Analysis?

NVIDIA (a GitHub organization, an official publisher) maintains it in NVIDIA/skills, which has 3,555 GitHub stars. The repository holds 390 skills in this directory. The repository was last updated on October 9, 2026.

Source: NVIDIA/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.