Generated banner for Tao Analyze Gaps Vlm Bcq
Generated logo for Tao Analyze Gaps Vlm Bcq

Tao Analyze Gaps Vlm Bcq

NVIDIAOfficialCreated by NVIDIA Corporation

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

From the author

Extract false-positive and false-negative gaps from VLM binary-classification-question (BCQ, yes/no) predictions. Use when the user asks to "analyze VLM BCQ gaps", "extract VLM false positives and false negatives", or identify failure cases from a predictions JSON for DEFT root-cause analysis on a binary-classification VLM workflow.
— the description by NVIDIA Corporation

AutoGineer summary

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

This skill automates the evaluation of Vision Language Model (VLM) binary classification tasks. By comparing model responses against ground truth data, it identifies specific failure cases—false positives and false negatives—and generates structured reports. These outputs are designed to facilitate root-cause analysis and support iterative model improvement workflows.

What it does

  • Parses VLM prediction JSON files for binary yes/no classification results.
  • Compares model responses against provided ground truth labels.
  • Identifies and categorizes false-positive and false-negative prediction errors.
  • Generates a JSONL file containing detailed records of each identified failure case.
  • Produces a human-readable summary report detailing total error counts.
  • Supports relative path resolution for video assets referenced in predictions.

When to use it

  • When you need to audit VLM performance on binary classification tasks.
  • When preparing data for root-cause analysis (RCCA) in a DEFT iteration workflow.
  • When you need to extract specific failure samples from a large set of model predictions.
  • When you need to generate KPI reports for model evaluation cycles.

Advantages

  • Automates the tedious process of manual error identification in VLM outputs.
  • Produces machine-readable output for seamless integration with downstream analysis tools.
  • Provides clear, human-readable summary reports for quick performance assessment.
  • Standardizes the evaluation process for binary classification workflows.

Usage examples

“Analyze my VLM BCQ gaps using the results.json file.”
The skill will process the predictions, compare them against ground truth, and generate a kpi_gaps.jsonl file and a kpi_gaps_report.txt summary.
“Extract false positives and false negatives from my model predictions.”
The agent will identify the failure cases based on the provided predictions JSON and output the specific samples that were misclassified.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/tao-analyze-gaps-vlm-bcq/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip tao-analyze-gaps-vlm-bcq.zip -d .agents/skills

Documentation by NVIDIA Corporation

VLM Binary Classification Gap Analysis

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).

Reads a VLM predictions JSON, compares each model response against ground truth, and writes FP/FN failure cases to a JSONL file with a summary report. Run it with a TAO Data Services spec file; the data-services entrypoint requires -e <spec>.

Purpose

After running a VLM on a binary yes/no evaluation task, the predictions need to be compared against ground truth to identify failure cases. This skill produces a structured list of FP (false positive) and FN (false negative) samples that downstream RCCA stages (e.g., cosmos generation, root cause analysis) consume to drive a DEFT iteration.

Usage

Generate a vlm_bcq_spec.yaml with the bundled helper:

python3 skills/data/tao-analyze-gaps-vlm-bcq/scripts/prepare_vlm_bcq_spec.py \
  --predictions-json /path/to/results.json \
  --videos-dir /path/to/videos/root \
  --results-dir /path/to/output/gaps \
  --output-spec /path/to/output/gaps/vlm_bcq_spec.yaml

Omit --videos-dir when prediction video_id values are already absolute. The generated spec has this shape:

predictions_json: /path/to/results.json
videos_dir: ""
results_dir: /path/to/output/gaps

Set videos_dir when video_id values in the predictions are relative paths:

predictions_json: /path/to/results.json
videos_dir: /path/to/videos/root
results_dir: /path/to/output/gaps

Invoke the vlm_bcq action inside the TAO Toolkit data services container with -e <spec>:

gap_analysis vlm_bcq -e /path/to/vlm_bcq_spec.yaml

Request exactly one GPU from the selected platform (compute_shape.gpus: 1, compute_shape.nodes: 1). VLM BCQ gap analysis does not perform GPU compute, but the Data Services image always calls nvidia-smi and fails when no GPU is visible. One is a GPU count, not a device ID; the platform selects the device.

After the run, surface the FP/FN counts from kpi_gaps_report.txt and point downstream stages at kpi_gaps.jsonl.

Inputs

  • config spec: YAML file passed with -e. Template: assets/default_vlm_bcq.yaml.

  • predictions_json: Path to predictions JSON file. Must be a JSON array where each item has video_id, response, and gt fields. response and gt are parsed with word-boundary matching — 'yes' or 'no' anywhere in the string is recognized. Samples where both or neither are present are skipped with a warning.

  • videos_dir (optional): Base directory for resolving relative video_id paths. If omitted, video_id values are used as absolute paths.

  • results_dir: Output directory for gap-analysis artifacts.

Predictions JSON format:

[
  {
    "video_id": "/path/to/video.mp4",
    "response": "Yes, there is a collision.",
    "gt": "B. No",
    "question": "Is there a collision?"
  }
]

Outputs

  • kpi_gaps.jsonl: One JSON object per line for each FP/FN case. Fields: video_id (absolute path), error_type (FP or FN), question, ground_truth, response.

  • kpi_gaps_report.txt: Human-readable table with total FP/FN counts.

If no gaps are found, no files are written and a message is logged.

Spec Fields

ParameterRequiredDescription
predictions_jsonYesPath to predictions JSON file
results_dirYesOutput directory; created if it does not exist
videos_dirNoBase directory for resolving relative video_id paths

Keep the spec file and every path it references under the bind-mounted workspace so they resolve inside the container. Pass -e <spec> even if you also add Hydra overrides; current TAO Data Services entrypoints hard-require an experiment spec file before processing overrides.

Error Patterns

ErrorCauseFix
FileNotFoundErrorpredictions_json does not existCheck the path
requires the following argument: -e/--experiment_spec_fileThe container was launched without a spec fileWrite vlm_bcq_spec.yaml and pass gap_analysis vlm_bcq -e <spec>
ValueError: must be a JSON arrayPredictions file is not a listWrap predictions in [...]
ValueError: missing 'gt'/'response'/'video_id'A prediction item is missing a required fieldInspect and fix the predictions JSON
Samples silently skippedresponse or gt contains both or neither 'yes'/'no'Check logs for warnings; inspect those samples

Files

references/skill_info.yaml

network_arch: tao-analyze-gaps-vlm-bcq
type: data
container_image: nvcr.io/nvidia/tao/tao-toolkit:7.3.0-data-services  # versions-key: images.tao_toolkit.data_services
# Fixed compute requirement: request one GPU from the platform. Even though this
# function doesn't need a GPU, the Data Services image always calls nvidia-smi.
# This remains null because the strict VLM BCQ spec has no GPU-count field;
# gpu_spec_key is a spec-field pointer, not a GPU count or device ID.
gpu_spec_key: null
required_credentials: []
actions:
  vlm_bcq:
    command: gap_analysis vlm_bcq -e {config_path}
    config_format: yaml
    mode: config
    inputs:
      predictions_json:
        type: file
      videos_dir:
        type: folder
        optional: true
    outputs:
      results_dir:
        type: folder
    upload_excludes:
    - inputs/
    defaults:
      videos_dir: ''

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 Docker, NVIDIA Container Toolkit, and one visible GPU.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • 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-vlm-bcq · 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-vlm-bcq.zip