AutoGineer
Generated banner for Tao Analyze Gaps Od Map
Generated logo for Tao Analyze Gaps Od Map

Tao Analyze Gaps Od Map

NVIDIAOfficialCreated by NVIDIA Corporation

  • Skill
  • Review and audit
  • Software development
  • Apache-2.0
  • Medium risk
  • Has scripts
Download ZIP

From the author

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".
— the description by NVIDIA Corporation

AutoGineer summary

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

The TAO Analyze Gaps OD mAP skill identifies weak images in an object detection dataset by evaluating model performance against ground truth. It computes metrics such as TP, FP, FN, and AP50 on a per-image and per-class basis. By applying configurable thresholds, the skill flags images where model performance is insufficient, providing actionable data for downstream mining and model improvement workflows. It requires pre-existing inference annotations and ground truth data to function.

What it does

  • Compares ground-truth and inference annotations to identify model performance gaps.
  • Calculates per-image and per-class metrics including recall, precision, and AP50.
  • Generates a list of weak images based on user-defined performance thresholds.
  • Produces detailed parquet reports for box-level gaps and image-level metrics.
  • Validates configuration specifications to ensure correct input formats and pathing.
  • Outputs a JSON gap report summarizing FP/FN counts and run settings.

When to use it

  • When you need to identify images where an object detection model is underperforming.
  • When preparing data for active learning or image mining workflows.
  • When you need to audit model predictions against ground truth annotations.
  • When you need to generate a quantitative report on model weaknesses per class.

Advantages

  • Enables targeted data collection by identifying specific weak images.
  • Supports both KITTI and COCO annotation formats.
  • Provides granular metrics for per-class performance analysis.
  • Ensures reproducibility by linking output artifacts with the specific experiment configuration.

Usage examples

“Analyze OD gaps for my current model predictions.”
The agent will guide you to configure the object_detection.yaml spec with your annotation paths and run the gap analysis container to identify weak images.
“Find weak OD images where car recall is below 0.9.”
The agent will help you set the weak_thresholds in your spec to include a car recall threshold of 0.9 and execute the analysis to filter the dataset.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/nvidia/tao-analyze-gaps-od-map/download

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

    mkdir -p .agents/skills && unzip tao-analyze-gaps-od-map.zip -d .agents/skills

Documentation by NVIDIA Corporation

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:

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:

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.

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.

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="$(scripts/resolve_versions_key.py images.tao_toolkit.data_services)"

RUNTIME_HOME="$RUN_ROOT/.tao-runtime/home"
mkdir -p "$RUNTIME_HOME/.cache"

docker run --rm --gpus "$GPU_COUNT" --shm-size=8g --network=host \
  --user "$(id -u):$(id -g)" \
  -e USER="$(id -un)" -e LOGNAME="$(id -un)" \
  -e HOME="$RUNTIME_HOME" -e XDG_CACHE_HOME="$RUNTIME_HOME/.cache" \
  -v "$RUN_ROOT:$RUN_ROOT" \
  -w "$RUN_ROOT" \
  "$DS_IMAGE" \
  gap_analysis object_detection -e "$SPEC"

Keep --user and the identity env block above. TAO DS images call getpass.getuser() at startup; without USER/LOGNAME they fail with KeyError: 'getpwuid(): uid not found: <uid>' because the UID has no /etc/passwd entry. Do not work around it by running the container as root; that leaves root-owned outputs. This follows the launch contract in tao-run-on-docker.

Preflight

  1. Verify Docker access:

docker info > /dev/null

  1. Resolve and pull the data-services image if needed:

DS_IMAGE="$(scripts/resolve_versions_key.py 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 ran without --user, so it wrote as root. Relaunch with the --user and identity env block shown above.

Files

skill-card.md

Description: <br>

Run TAO Data Services object-detection gap analysis from ground-truth and inference annotations, identifying weak images by comparing model predictions against ground truth using per-class recall, precision, and AP50 thresholds. <br>

This skill is ready for commercial/non-commercial use. <br>

Owner

NVIDIA <br>

License/Terms of Use: <br>

Apache 2.0 <br>

Use Case: <br>

Developers and engineers building NVIDIA TAO object-detection workflows use this skill to run Data Services gap analysis that compares inference annotations against ground truth (KITTI or COCO), computes per-image per-class TP/FP/FN/AP50 metrics, and produces a weak-image set for downstream data mining. <br>

Deployment Geography for Use: <br>

Global <br>

Requirements / Dependencies: <br>

Requires API Key or External Credential: [Not Specified] <br> Credential Type(s): [None identified] <br>

Do not include secrets in prompts/logs/output; use least-privilege credentials; rotate keys as appropriate. <br>

Known Risks and Mitigations: <br>

Risk: Review before execution as proposals could introduce incorrect or misleading guidance into skills. <br> Mitigation: Review and scan skill before deployment. <br>

Reference(s): <br>

Skill Output: <br>

Output Type(s): [Shell commands, Configuration instructions, Files, Analysis] <br> Output Format: [Markdown with inline bash code blocks; YAML spec; Parquet and JSON gap-analysis artifacts] <br> Output Parameters: [1D] <br> Other Properties Related to Output: [Writes box_gaps.parquet, image_metrics.parquet, weak_images.parquet, and gap_report.json to the configured results_dir] <br>

Evaluation Agents Used: <br>

  • Claude Code (aws/anthropic/bedrock-claude-opus-4-8) <br>

  • Codex (openai/openai/gpt-5.5) <br>

Evaluation Tasks: <br>

1 evaluation task (1 positive), 1 attempt per task, each run in an isolated k8s-sandbox pod; evaluator version 1.5.6, evaluated 2026-10-16. <br>

Evaluation Metrics Used: <br>

Reported benchmark dimensions: <br>

  • Security: Is it safe to use? Scored from the security signal. <br>

  • Correctness: Is the answer correct? Scored from the accuracy signal. <br>

  • Discoverability: Was the right skill loaded when needed? Scored from the skill_execution signal. <br>

  • Effectiveness: Did the skill help complete the task? Equal-weight mean of goal_accuracy and behavior_check. <br>

  • Efficiency: Did it avoid wasted tool calls and token usage? Equal-weight mean of skill_efficiency and token_efficiency. <br>

Underlying evaluation signals used in this run: <br>

  • security: Unsafe operations, secret leakage, and unauthorized access. <br>

  • skill_execution: Whether the expected skill was selected, decoys were avoided, and the workflow executed. <br>

  • skill_efficiency: Tool-call productivity. <br>

  • accuracy: Final-answer correctness against the reference answer. <br>

  • goal_accuracy: Whether the user's goal was achieved. <br>

  • behavior_check: Whether the expected workflow behavior was followed. <br>

  • token_efficiency: Actual uncached prompt plus completion token usage. <br>

Evaluation Results: <br>

MeasureClaude Code (Baseline → Skill Uplift)Codex (Baseline → Skill Uplift)
Overall92.1% — baseline ran, but no comparable score was available; uplift unavailable96.2% — 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)20.0% → 100.0% (+80.0 points)
Discoverability100.0% — baseline ran, but no comparable score was available; uplift unavailable95.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness12.5% → 87.5% (+75.0 points)40.0% → 87.5% (+47.5 points)
Efficiency73.1% — baseline ran, but no comparable score was available; uplift unavailable98.5% — baseline ran, but no comparable score was available; uplift unavailable

Skill Version(s): <br>

0.1.0 (source: frontmatter) <br>

Ethical Considerations: <br>

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal team to ensure this skill meets requirements for the relevant industry and use case and addresses unforeseen product misuse. <br>

(For Release on NVIDIA Platforms Only) <br> Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns here. <br>

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 a command-line tool, Needs Python

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

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • References to credential files
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

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-analyze-gaps-od-map · 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-analyze-gaps-od-map.zip