Tao Generate Referring Expressions

Image Referring Expression Pipeline

Generate referring-expression and grounding annotations from images with KITTI-format bounding box labels. A single VLM (Gemini or any OpenAI-compatible endpoint) runs four steps: per-object region descriptions, holistic image captions, grouped grounding expressions tied to bboxes, and an optional double-check verification pass.

Purpose

Transform (image, KITTI labels) pairs into a unified annotations.jsonl containing rich, grounded referring expressions. The VLM acts as a "teacher" annotator: Steps 0-1 see the image; Step 2 groups Step 0 outputs into grouping phrases with bbox lists; Step 3 (optional) re-examines those bboxes against the image and corrects mismatches.

Pipeline Architecture

Step 0: Region expression  ──┐
                              ├──▶  Step 2: Grounding expression  ──▶  [Step 3: Double check]
Step 1: Image caption  ──────┘                                                   (optional)

• Step 0 (region_expr) — VLM emits one short discriminative phrase per KITTI bbox (bbox_2d, type, color, description).
• Step 1 (image_caption) — VLM emits a holistic, location-agnostic scene caption.
• Step 2 (grounding_expr) — VLM groups Step 0 objects into grouping phrases and returns one bbox list per group, optionally using Step 1's caption as extra context.
• Step 3 (double_check) — VLM re-checks each Step 2 bbox against the image; bad matches are removed, slightly-off boxes get tightened.

Steps 0 and 1 run in parallel within a single thread pool (they only depend on the seed records). Each step writes its own step_<N>_*/annotations.jsonl and skips already-processed images on re-run unless workflow.force_reprocess: true.

Instructions

Initial setup

When a user wants to run this pipeline, walk through these steps:

1. Images: Ask for data.image_dir, the directory containing .jpg, .jpeg, or .png images. 2. KITTI labels: Ask for data.kitti_label_dir, the directory containing one .txt label file per image. Each label line must use KITTI format: <type> <truncated> <occluded> <alpha> <bbox_left> <bbox_top> <bbox_right> <bbox_bottom> .... Lines with fewer than 8 fields are silently skipped. Set this even for Step 1-only runs because Steps 0 and 2 require it. 3. Resume from existing annotations: If the user already has a unified annotations.jsonl from a previous run, set data.input_annotations_jsonl to that file instead of seeding from data.image_dir and data.kitti_label_dir. 4. API access: Ask the user which VLM endpoint they want to use. Present these five options and act on the choice: 1. Gemini — set vlm.backend: "gemini"; require GOOGLE_API_KEY (env var or vlm.gemini.api_key). 2. NIM (e.g. https://inference-api.nvidia.com/v1) — set vlm.backend: "openai"; collect base_url, model_name, and api_key. 3. TAO inference microservice (self-hosted, OpenAI-compatible). Confirm whether the server is already running:

• Running — collect base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".
• Not running — guide the user through the skills/applications/tao-run-inference-service skill, which stands up a local TAO inference microservice with an OpenAI-compatible API. Before promising a specific model, check skills/applications/tao-run-inference-service/references/service.yaml for valid_network_arch_config_basenames. Once the server is up, collect base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".

4. vLLM (self-hosted, OpenAI-compatible). Confirm whether the server is already running:

• Running — collect base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".
• Not running — follow references/vllm_server.md to install and launch a vLLM server, then collect base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".

5. Custom (any other OpenAI-compatible endpoint) — set vlm.backend: "openai"; collect base_url, model_name, and (optionally) api_key.

If the user has no endpoint and does not want to set one up, stop and help resolve API access first. 5. Workflow steps: Choose one of:

• Full pipeline: ["0", "1", "2", "3"]
• No caption generation: ["0", "2", "3"], where Step 2 falls back to image-only context
• No verification: ["0", "1", "2"]
• Custom subset: any supported subset of steps

6. Output format: Choose one of:

• jsonl: unified schema only
• legacy: byte-compatible .txt.stepN files only
• both: writes both formats and is the default for downstream tooling

Running the pipeline

The pipeline runs inside the TAO Toolkit container via the auto_label CLI:

auto_label generate -e /path/to/spec.yaml \
    results_dir=/results \
    image_referring_expression.data.image_dir=/data/images \
    image_referring_expression.data.kitti_label_dir=/data/labels \
    image_referring_expression.vlm.gemini.api_key=$GOOGLE_API_KEY

Generate a default spec: auto_label default_specs results_dir=/results module_name=auto_label, then set autolabel_type: "image_referring_expression". All fields support Hydra dot-notation overrides on the command line.

See references/configuration.md for the full YAML structure, all parameters, model/endpoint setup, and error patterns.

Recommended pilot workflow

1. Run on 5-10 images with all four steps. 2. Inspect step_0_region_expr/annotations.jsonl — are object types, colors, and discriminating phrases accurate? 3. Inspect step_2_grounding_expr/annotations.jsonl — are objects grouped sensibly, and do bbox coordinates match the described groups? 4. Inspect step_3_double_check/annotations.jsonl — were mismatched bboxes removed or tightened? Are any new errors introduced (rare)? 5. If quality is insufficient, switch the VLM to a stronger model (e.g. gemini-2.5-pro or a larger Qwen3-VL endpoint), raise media_resolution / max_output_tokens, then re-run with workflow.force_reprocess=true. 6. Scale to the full dataset once satisfied.

Configuration

Key configuration fields (full reference in references/configuration.md):

Inputs

Two ways to seed the pipeline:

1. Image directory + KITTI labels (default). Set data.image_dir and data.kitti_label_dir. The orchestrator walks the image directory, reads the matching <stem>.txt KITTI file, parses bboxes (fields 0 + 4-7), reads each image's width/height via PIL, and writes a seed_annotations.jsonl to results_dir/. 2. Pre-seeded annotations JSONL (resume / pre-computed regions). Set data.input_annotations_jsonl to a file with one {"image_id", "image_path", "width", "height", "kitti_bboxes": [...]} object per line.

Outputs

All outputs go to results_dir/:

• seed_annotations.jsonl — initial per-image records (unless input_annotations_jsonl was supplied).
• step_0_region_expr/annotations.jsonl — adds regions[] (each with bbox/bbox_2d, type, color, description).
• step_1_image_caption/annotations.jsonl — adds caption (string).
• step_2_grounding_expr/annotations.jsonl — adds expressions[] (each {text, instances: [{bbox: [x1,y1,x2,y2]}]}).
• step_3_double_check/annotations.jsonl — same shape as Step 2, with bboxes removed/updated.
• results_dir/annotations.jsonl — copy of the last completed step's output.
• When workflow.output_format is "legacy" or "both", each step also writes byte-compatible step_<N>_*/labels/<stem>.txt.stepN files for the original 2d-data-engine tooling.

Prerequisites

• Container: nvcr.io/nvidia/tao/tao-toolkit:6.26.3-pyt
• API access: At least one VLM endpoint (Gemini API key or OpenAI-compatible endpoint capable of image input)
• PIL / Pillow: Required to read image dimensions during seeding (already present in the TAO container)

Evaluation Report

Evaluation of the tao-generate-referring-expressions skill before publication through NVSkills-Eval.

This benchmark summarizes 3-Tier Evaluation from NVSkills-Eval results for the skill. The goal is to document whether the skill is safe, discoverable, effective, and useful for agents before it is published for broader workflow use.

Evaluation Summary

• Skill: tao-generate-referring-expressions
• Evaluation date: 2026-06-06
• NVSkills-Eval profile: external
• Environment: astra-sandbox
• Dataset: 1 evaluation tasks
• Attempts per task: 2
• Pass threshold: 50%
• Overall verdict: FAIL

The skill should be reviewed before NVSkills-Eval publication. Skill owners should address the applicable findings below and rerun NVSkills-Eval to refresh this benchmark.

Agents Used

• claude-code
• codex

Metrics Used

Reported benchmark dimensions:

• Security: checks whether skill-assisted execution avoids unsafe behavior such as secret leakage, destructive commands, or unauthorized access.
• Correctness: checks whether the agent follows the expected workflow and produces the correct final output.
• Discoverability: checks whether the agent loads the skill when relevant and avoids using it when irrelevant.
• Effectiveness: checks whether the agent performs measurably better with the skill than without it.
• Efficiency: checks whether the agent uses fewer tokens and avoids redundant work.

Underlying evaluation signals used in this run:

• security (Security): checks for unsafe operations, secret leakage, and unauthorized access.
• skill_execution (Skill Execution): verifies that the agent loaded the expected skill and workflow.
• skill_efficiency (Efficiency): checks routing quality, decoy avoidance, and redundant tool usage.
• accuracy (Accuracy): grades final-answer correctness against the reference answer.
• goal_accuracy (Goal Accuracy): checks whether the overall user task completed successfully.
• behavior_check (Behavior Check): verifies expected behavior steps, including safety expectations.
• token_efficiency (Token Efficiency): compares token usage with and without the skill.

Test Tasks

The benchmark dataset contained 1 evaluation tasks:

• Positive tasks: 1 tasks where the skill was expected to activate.
• Negative tasks: 0 tasks where no skill was expected.
• Unlabeled tasks: 0 tasks where positive/negative intent could not be inferred.

Task composition is derived from the evaluation dataset when possible. Entries with expected_skill set are treated as positive skill-activation cases, while entries with expected_skill: null are treated as negative activation cases.

Results

Score values show skill-assisted performance. Values in parentheses show uplift versus the no-skill baseline when baseline data is available.

Tier 1: Static Validation Summary

Tier 1 validation passed with observations. NVSkills-Eval ran 9 checks and found 13 total findings.

Top findings:

• MEDIUM SCHEMA/folder_hierarchy: Unexpected nesting depth for general skill (skills/data/tao-generate-referring-expressions)
• MEDIUM SCHEMA/body_recommended_section: Missing recommended section: '## Examples' (skills/data/tao-generate-referring-expressions/SKILL.md)
• MEDIUM SECURITY/Unknown (SQP-2): The skill collects API keys (GOOGLE_API_KEY, OpenAI-compatible keys) and transmits them as part of VLM endpoint configur (SKILL.md:57)
• MEDIUM SECURITY/Unknown (SQP-2): The configuration reference shows API keys being stored in plaintext YAML files (e.g., vlm.gemini.api_key, vlm.openai (references/configuration.md:14`)
• MEDIUM SECURITY/Unknown (SQP-2): The skill configures Gemini as the default VLM backend and will transmit user-provided images (and potentially sensitive (references/skill_info.yaml:30)

Tier 2: Deduplication Summary

Tier 2 validation reported findings. NVSkills-Eval ran 2 checks and found 1 total findings.

Top findings:

• HIGH DUPLICATE/duplicate: Duplicate content found within SKILL.md:

"# Image Referring Expression Pipeline" in SKILL.md (lines 1-4) vs "## Purpose" in SKILL.md (lines 5-8) (SKILL.md:1)

Image Referring Expression — Full Configuration Reference

Complete YAML Structure

Generate a default experiment spec with auto_label default_specs results_dir=/results module_name=auto_label, then set autolabel_type: "image_referring_expression".

results_dir: ???                        # Required — output directory
autolabel_type: "image_referring_expression"

image_referring_expression:
  # --- VLM (vision-language model, used for all four steps) ---
  vlm:
    backend: "gemini"                   # "gemini" or "openai"
    gemini:
      api_key: ""                       # Or set GOOGLE_API_KEY env var
      model: "gemini-3.1-flash-lite-preview"
      media_resolution: "MEDIA_RESOLUTION_HIGH"   # LOW / MEDIUM / HIGH
      temperature: 0.3
      max_output_tokens: 8192
      timeout: 120
    openai:                             # For OpenAI-compatible endpoints (NIM, vLLM, etc.)
      api_key: ""
      base_url: ""                      # e.g. "https://inference-api.nvidia.com/v1" — no /chat/completions
      model_name: ""                    # e.g. "Qwen/Qwen3-VL-235B-A22B-Instruct"
      temperature: 0.7
      max_tokens: 4096
      timeout: 60

  # --- Workflow ---
  workflow:
    steps: ["0", "1", "2", "3"]         # 0=region_expr, 1=image_caption, 2=grounding_expr, 3=double_check
    max_workers: 4                      # Parallel threads per step
    force_reprocess: false              # Ignore cached step outputs
    output_format: "both"               # "jsonl", "legacy", or "both"

  # --- Input data ---
  data:
    image_dir: ???                      # Directory of input images (.jpg / .jpeg / .png)
    kitti_label_dir: ???                # Directory of KITTI-format .txt label files
    input_annotations_jsonl: ""         # Optional: pre-seeded annotations.jsonl to resume from

Key Configuration Decisions

Model / Endpoint Configuration

Gemini (default)

Set the API key via environment variable or config:

export GOOGLE_API_KEY=your_key_here

Or in the YAML: image_referring_expression.vlm.gemini.api_key: "your_key".

Recommended model assignments:

• For all steps: gemini-2.5-flash (fast, good enough for most images) or gemini-2.5-pro (better at small / cluttered objects and at the Step 3 verification pass).

Temperature guidance:

• Region & grounding (Steps 0, 2, 3): 0.2-0.3 for stable, factual output.
• Caption (Step 1): 0.3-0.5 for slightly more natural phrasing.

OpenAI-compatible endpoints

For NVIDIA Inference API, vLLM-served Qwen3-VL, NIM endpoints, etc.:

image_referring_expression:
  vlm:
    backend: "openai"
    openai:
      base_url: "https://inference-api.nvidia.com/v1"   # no /chat/completions
      model_name: "gcp/google/gemini-3-flash-preview"
      api_key: "your_key"
      temperature: 0.3
      max_tokens: 8192

For self-hosted models, the pipeline accepts any endpoint that speaks the OpenAI chat-completions API. Two common ways to provision one:

1. `skills/applications/tao-run-inference-service` skill — workflow for standing up a TAO inference microservice locally. Should support Cosmos, Qwen, and Gemma. Check that skill's references/service.yaml valid_network_arch_config_basenames for the current model list. 2. Bring-your-own deployment — vLLM, NIM, or any other OpenAI-compatible server.

image_referring_expression:
  vlm:
    backend: "openai"
    openai:
      base_url: "http://localhost:8000/v1"
      model_name: "Qwen/Qwen3-VL-8B-Instruct"   # must match vLLM --served-model-name
      api_key: "EMPTY"                      # vLLM ignores it but the SDK requires non-null
      temperature: 0.3
      max_tokens: 4096
      timeout: 300

All Parameters

Input KITTI Label Schema

One line per object, space-separated, with at least 8 fields. Lines with fewer than 8 fields are silently skipped.

<type> <truncated> <occluded> <alpha> <bbox_left> <bbox_top> <bbox_right> <bbox_bottom> [<height> <width> <length> <x> <y> <z> <rotation_y> <score>]

• <type> (field 0) — string class name (car, pedestrian, truck, ...). Used by Step 0 prompts and Step 2 grouping.
• <bbox_left> <bbox_top> <bbox_right> <bbox_bottom> (fields 4-7) — pixel-space [x1, y1, x2, y2].
• All remaining fields are accepted but ignored.

Bboxes are normalized to a 0-1000 coordinate scale before being sent to the VLM in Step 0 and Step 2, then converted back to pixel coordinates in the output records.

Resume Schema (data.input_annotations_jsonl)

When supplied, each line must have at least:

{
  "image_id": "stem-of-image-filename",
  "image_path": "/abs/or/relative/path/to/image.jpg",
  "width": 1920,
  "height": 1080,
  "kitti_bboxes": [[x1, y1, x2, y2, "type"], ...],
  "source": "image_referring_expression",
  "pipeline_steps": []
}

This is exactly the format produced by the default seeding pass (results_dir/seed_annotations.jsonl).

Output Layout

results_dir/
├── seed_annotations.jsonl                     # initial per-image records (skipped if resuming)
├── annotations.jsonl                          # copy of the last completed step's output
├── step_0_region_expr/
│   ├── annotations.jsonl                      # adds regions[] to each record
│   └── labels/<stem>.txt.step0                # legacy 2d-data-engine format (when output_format != "jsonl")
├── step_1_image_caption/
│   ├── annotations.jsonl                      # adds caption to each record
│   └── labels/<stem>.txt.step1
├── step_2_grounding_expr/
│   ├── annotations.jsonl                      # adds expressions[] to each record
│   └── labels/<stem>.txt.step2
└── step_3_double_check/
    ├── annotations.jsonl                      # expressions[] with bboxes removed/updated
    └── labels/<stem>.txt.step3

Each output record carries:

• image_id, image_path, width, height — preserved from the seed.
• kitti_bboxes — original parsed KITTI rows ([x1, y1, x2, y2, type]).
• regions[] (after Step 0) — {bbox: [x1,y1,x2,y2], bbox_2d: [..], type, color, description} per object.
• caption (after Step 1) — holistic, location-agnostic scene caption.
• expressions[] (after Step 2 and updated by Step 3) — {text, instances: [{bbox: [x1,y1,x2,y2]}, ...]}.
• pipeline_steps[] — list of step names that have processed this record.
• source — set to "image_referring_expression".

Error Patterns

vLLM Server Setup for Vision-Language Models

This guide walks the user through standing up a self-hosted vLLM server that exposes an OpenAI-compatible /v1/chat/completions endpoint for vision-language models (VLMs). Once the server is running, point the pipeline at it with vlm.backend: "openai" and the matching base_url / model_name / api_key values.

1. Prerequisites

• NVIDIA GPU(s) with enough VRAM for the chosen VLM (≥24 GB for 7-8B-class models, ≥80 GB for 32B+ models; tensor-parallel across multiple GPUs is supported via --tensor-parallel-size).
• A recent NVIDIA driver and nvidia-container-toolkit (for the recommended Docker path).
• Docker (recommended). Python ≥ 3.10 is only needed for the optional host install path.
• For gated HuggingFace repos: a HF_TOKEN with access to the model.

2. Install vLLM

Default: Docker (Option A). Use it unless you have a specific reason to install on the host — Docker pins a known-good CUDA/PyTorch/vLLM combination and avoids local environment drift. The pip path (Option B) is provided for advanced users who need to patch vLLM, debug locally, or run on a system where Docker is not available.

Option A — Docker (default, recommended)

docker pull vllm/vllm-openai:latest

Option B — pip (host install, advanced)

pip install --upgrade "vllm>=0.7.0"

3. Pick a VLM checkpoint

vLLM supports many vision models; the pipelines just need an OpenAI-compatible chat-completions endpoint that accepts image inputs. Common picks:

If the chosen repo is gated, accept its license on the HuggingFace web UI first, then export HF_TOKEN=<your_token> before launching.

4. Launch the server

Use the launcher that matches the install path. Both commands listen on 0.0.0.0:8000 and serve an OpenAI-compatible API at /v1. Prefer Option A (Docker) unless you installed via pip in Section 2.

Option A — Docker (default, recommended)

docker run --runtime nvidia --gpus all \
    -p 8000:8000 \
    -e HF_TOKEN=<your_hf_token> \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    vllm/vllm-openai:latest \
    --model Qwen/Qwen3-VL-8B-Instruct \
    --served-model-name Qwen/Qwen3-VL-8B-Instruct \
    --tensor-parallel-size 1 \
    --gpu-memory-utilization 0.9 \
    --media-io-kwargs '{"video": {"num_frames": -1, "fps": -1}}'

Option B — pip install (host launch, advanced)

export HF_TOKEN=<your_hf_token>          # only required for gated models

vllm serve Qwen/Qwen3-VL-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --dtype bfloat16 \
    --served-model-name Qwen/Qwen3-VL-8B-Instruct \
    --tensor-parallel-size 1 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \
    --media-io-kwargs '{"video": {"num_frames": -1, "fps": -1}}'

Key flags:

• --served-model-name <NAME> — value to use later for vlm.openai.model_name. Defaults to the full HF repo path if omitted.
• --tensor-parallel-size <N> — number of GPUs to shard the model across.
• --max-model-len <N> — context window; image tokens count against this, so leave headroom for multi-image prompts.
• --limit-mm-per-prompt image=<N> — max images per request. Bump it if a prompt sends multiple images.
• --gpu-memory-utilization <0..1> — lower (e.g. 0.85) if you hit OOM at load time.

The first launch downloads weights to ~/.cache/huggingface; expect several minutes for 7B+ models.

5. Verify the endpoint

Wait for the log line Uvicorn running on http://0.0.0.0:8000, then sanity-check the server.

List served models:

curl http://localhost:8000/v1/models

Send a minimal vision request:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen3-VL-8B-Instruct",
        "messages": [{
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/640px-Cat03.jpg"}},
                {"type": "text", "text": "Describe this image in one sentence."}
            ]
        }],
        "max_tokens": 128
    }'

A non-empty choices[0].message.content in the response confirms the server is ready.

6. Wire the server into the pipeline

Once verified, collect these three values from the running server and pass them to the pipeline spec:

• base_url — e.g. http://localhost:8000/v1 (no /chat/completions suffix). If vLLM runs on another host, use http://<host_or_ip>:8000/v1 and make sure the port is reachable.
• model_name — must match --served-model-name exactly.
• api_key — vLLM ignores it but the OpenAI SDK requires a non-null string; use "EMPTY" if no auth is configured.

YAML snippet:

vlm:
  backend: "openai"
  openai:
    base_url: "http://localhost:8000/v1"
    model_name: "Qwen3-VL-8B-Instruct"
    api_key: "EMPTY"
    temperature: 0.3
    max_tokens: 4096
    timeout: 300

Common issues

Description: <br>

Four-step image referring-expression pipeline: turns images plus KITTI bounding-box labels into region descriptions, scene captions, grounded referring expressions, and (optionally) verified expressions via VLM distillation. <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 who need to generate rich, grounded referring-expression annotations from images with KITTI-format bounding-box labels for training or evaluating object-grounding and referring-expression models. <br>

Deployment Geography for Use: <br>

Global <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>

• Configuration Reference <br>
• vLLM Server Setup <br>
• Skill Info <br>

Skill Output: <br>

Output Type(s): [Files, Shell commands, Configuration instructions] <br> Output Format: [JSONL annotations with per-step outputs and optional legacy text format] <br> Output Parameters: [1D] <br> Other Properties Related to Output: [Per-step outputs cached and resumable; supports jsonl, legacy, or both output formats] <br>

Evaluation Agents Used: <br>

• Claude Code (claude-code) <br>
• Codex (codex) <br>

Evaluation Tasks: <br>

Evaluated against 1 evaluation task (1 positive skill-activation case) with 2 attempts per task in the NVSkills-Eval external profile. <br>

Evaluation Metrics Used: <br>

Reported benchmark dimensions: <br>

• Security: Checks whether skill-assisted execution avoids unsafe behavior such as secret leakage, destructive commands, or unauthorized access. <br>
• Correctness: Checks whether the agent follows the expected workflow and produces the correct final output. <br>
• Discoverability: Checks whether the agent loads the skill when relevant and avoids using it when irrelevant. <br>
• Effectiveness: Checks whether the agent performs measurably better with the skill than without it. <br>
• Efficiency: Checks whether the agent uses fewer tokens and avoids redundant work. <br>

Underlying evaluation signals used in this run: <br>

• security: Checks for unsafe operations, secret leakage, and unauthorized access. <br>
• skill_execution: Verifies that the agent loaded the expected skill and workflow. <br>
• skill_efficiency: Checks routing quality, decoy avoidance, and redundant tool usage. <br>
• accuracy: Grades final-answer correctness against the reference answer. <br>
• goal_accuracy: Checks whether the overall user task completed successfully. <br>
• behavior_check: Verifies expected behavior steps, including safety expectations. <br>
• token_efficiency: Compares token usage with and without the skill. <br>

Evaluation Results: <br>

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>