TAO Hugging Face Model Integrator
Connect Hugging Face computer-vision models to NVIDIA TAO training, ONNX export, and TensorRT deployment workflows.
The skill explicitly enforces local-only changes, forbids remote pushes, and requests user-supplied images, credentials, and confirmations at key gates. However, it requires HF_TOKEN, an NGC API key, Docker/GPU privileges, and write access across multiple repositories; credentials are passed through environment variables, while fine-grained permissions, sensitive-data handling, rollback, and complete data-flow disclosure are incomplete, so points are deducted.
The documentation provides phase gates, a build-test-fix loop, container isolation, and a troubleshooting table, making the main path statically coherent. However, many critical steps depend on unprovided reference files, external TAO repositories, and specific images, and there is no committed executable evidence covering this skill's key paths; the static ceiling therefore limits the score.
Triggers, supported computer-vision tasks, rejected non-vision tasks, and phase goals are clearly described. The environment is nevertheless highly demanding, depending on CUDA 13, NVIDIA container tooling, NGC images, and HuggingFace access, with no mainland-China reachability assessment, alternative platform, or sufficiently explicit non-fit boundaries; points are deducted.
SKILL.md has useful phase organization, cross-references, version metadata, an Apache-2.0 declaration, author attribution, and publisher ownership. It lacks the recommended Instructions and Examples sections, has incomplete changelog and maintenance-update guidance, uses a nonstandard author format, and distributes important assumptions across many external references, so points are deducted.
The skill defines an end-to-end objective spanning HuggingFace inspection, TAO training, ONNX, TensorRT, packaging, and container validation, with artifact flow and gates. However, representative final outputs are not statically verifiable, the workflow is expensive, and model adaptation still requires substantial manual implementation. The limited benchmark report supports only plausible core-task completion, so the score remains below the static cap.
The files contain concrete commands, checklists, artifact paths, and a limited evaluation report. However, the evaluation covers only one planning task and there is no committed test suite covering the key implementation paths or multi-source corroboration; conclusions rely mainly on author-provided material, so only limited credit is justified.
- The skill requires NGC and HuggingFace access plus an NVIDIA GPU, CUDA 13, and Docker; core execution may be unavailable on mainland-China networks or without the required credentials.
- Handling guidance for HF_TOKEN and NGC credentials is insufficient; confirm that secrets will not enter logs, shell history, or persistent caches before execution.
- Phase 0 performs local state changes including image pulls, package removal, and scratch cleanup; a general rollback procedure is not provided.
- The benchmark report contains only one evaluation task and does not establish reliable full-model porting, TensorRT deployment, or end-to-end results.
What does this skill do, and when should you use it?
This skill is for developers who want to turn a Hugging Face computer-vision model into a TAO Toolkit model. It coordinates a seven-phase workflow covering environment checks, model validation, codebase research, tao-core configuration, tao-pytorch training, ONNX export, and tao-deploy TensorRT integration. It supports classification, object detection, semantic, instance and panoptic segmentation, zero-shot detection, and depth estimation. All changes and validation are intended to run locally inside Docker, with an iterative build, test, debug, fix, and retest loop.
Checks Python, Git, NVIDIA drivers, CUDA, Docker, NVIDIA Container Toolkit, NGC authentication, and Hugging Face credentials; prepares TAO Toolkit container images; inspects the Hugging Face task type, configuration, weight schema, and ONNX export; creates tao-core experiment configuration; implements training, inference, evaluation, and MLOps in tao-pytorch; adds ONNX export and TensorRT engine, inference, and evaluation support in tao-deploy; registers command-line entry points and L0 tests; runs containerized unit tests, static checks, wheel builds, and end-to-end train→export→TensorRT→inference/evaluate validation; and optionally tunes accuracy, latency, or model size.
- A computer-vision developer wants to integrate a Hugging Face ViT, DETR, or SegFormer model with TAO Toolkit.
- A TAO user needs native training, evaluation, inference, and configuration support for a new Hugging Face model.
- A deployment engineer needs to export a Hugging Face model to ONNX and build a TensorRT inference path.
- A team wants to validate training artifacts and TensorRT outputs on a local NVIDIA GPU Docker setup.
What are this skill's strengths and limitations?
- Covers the full path from model inspection through TensorRT deployment and containerized end-to-end validation.
- Requires continuous testing and repair after failures instead of accumulating untested code.
- Addresses multiple computer-vision tasks and provides a TAO reference-model mapping approach.
- Explicitly keeps edits, builds, and tests local.
- The setup is demanding: it requires NVIDIA GPU software, Docker, NGC credentials, HF_TOKEN, and TAO container images.
- The workflow requires local clones of four TAO repositories and careful handling of the tao-core submodule override.
- The supplied source provides no actual test results, performance measurements, or platform coverage for this specific skill.
- Execution depends on several referenced documents that are not included in the supplied material.
- The workflow does not publish code, images, or artifacts to remote repositories or registries.
How do you install this skill?
Install it from the NVIDIA/skills collection with the skills CLI: npx skills add nvidia/skills --skill tao-port-huggingface-model --yes. The README does not document the exact installation directory; the CLI prompts for the destination. The skill is located at skills/tao-port-huggingface-model/SKILL.md.
How do you use this skill?
Give the agent a Hugging Face model ID or URL and request TAO integration, for example: “Integrate org/model-name into TAO Toolkit.” Before starting, prepare NGC authentication, HF_TOKEN, a model short name, and exact image references for tao-pytorch, tao-deploy, and optionally tao-dataservices; Phase 0 asks for these inputs.