Hugging Face GPU Fine-Tuning
Build reproducible Hugging Face fine-tuning pipelines on local NVIDIA GPUs.
The skill constrains credential reads by scenario, states presence-only token checks, and requires read-only local-data mounts, smoke tests, and stopping on repeated errors. However, Read/Bash/Write are broad, push_to_hub defaults to true, and the workflow can build large images, write local outputs, and affect HF Hub/W&B externally without explicit per-action confirmation or a concrete rollback plan, so points are deducted.
The six-step workflow, gates, minimal-change recovery rules, and committed example results improve diagnosability. Reliability is reduced because key referenced files are not supplied, execution depends on live research, Docker, NGC, Hugging Face, and specific GPU environments, and the platform/default image guidance is not fully consistent. Static review caps this score at 10.
Audience, inputs, supported tasks, and rejection conditions are fairly clear. Core operation nevertheless depends on NVIDIA GPUs, Docker, NGC, Hugging Face connectivity, and optionally W&B; Chinese-language support and mainland-China reachability are not addressed, while trigger boundaries and backend alternatives have limited evidence.
The skill has clear sections for inputs, compatibility, workflow, gates, error handling, version, and Apache-2.0 licensing; examples and the benchmark provide some maintenance evidence. Deductions apply for missing recommended Instructions/Examples sections, the benchmark-reported author-format issue, no explicit changelog or maintenance/update path, and referenced files absent from the supplied material.
The documented workflow targets qualification, training, evaluation, inference, Hub publication, and a rerunnable skill, with four examples and reported metrics suggesting useful outputs. Evidence is limited to one benchmark task, the example results are not independently verifiable in this static review, and users still bear substantial environment and dataset-adaptation costs, so the score remains conservative.
Example configs cite model cards, scripts, task documentation, and a paper, while committed benchmarks, reports, and example artifacts provide some auditability. There is no execution during this review, the benchmark has only one task, and its result claims cannot be independently reproduced from the supplied material; therefore the score stays below the static ceiling.
- push_to_hub defaults to true; confirm the Hub target, data scope, model-card contents, and external W&B logging before execution.
- The workflow depends on live Hugging Face/NGC documentation and overseas services; mainland-China reachability or credential failures may block progress.
- Many referenced files were not supplied, so their contents, dependency pins, and Docker security boundaries must be checked before use.
- Example metrics and benchmark results are submitted evidence, not execution verified by this static review.
What does this skill do, and when should you use it?
This skill guides an agent through fine-tuning Hugging Face computer-vision, vision-language, and language models on local NVIDIA GPUs inside an NGC PyTorch container. It supports full fine-tuning and LoRA, plus image classification, object detection, segmentation, depth estimation, VLM SFT/LoRA, and LLM SFT, DPO, and GRPO. The workflow covers model and dataset qualification, hardware auditing, live recipe research, project generation, real-data smoke testing, training, evaluation, inference, Hub publishing, and rerun-skill generation. It is a fit for users who already have a Docker-based NVIDIA GPU environment and want reproducible training artifacts.
Reads a Hugging Face model ID, dataset ID or local dataset path, training settings, and optional session credentials; probes model configuration, model-card metadata, dataset format, and task schema in Docker; selects an NGC PyTorch image based on host driver and CUDA conditions; fetches live model cards, repository examples, task documentation, or papers for the training recipe; generates config.yaml, a Dockerfile, requirements.txt, data-preparation, training, evaluation, and inference scripts; runs a one-step smoke test on real data; performs baseline evaluation, training, post-training evaluation, and five inference samples; optionally pushes weights, the model card, configuration, reports, and samples to the Hugging Face Hub; and emits a self-contained rerun SKILL.md.
- A researcher wants to fine-tune a Hugging Face vision model on a local NVIDIA GPU and validate the pipeline with real data first.
- A machine-learning engineer needs LoRA fine-tuning for a vision-language or language model with a reproducible container and configuration.
- A team needs an end-to-end project for image classification, object detection, semantic segmentation, instance segmentation, or panoptic segmentation.
- A model developer wants to qualify a Hugging Face model and dataset locally before scaling up training.
- A team wants to publish fine-tuned weights, a model card, evaluation results, inference samples, and a rerun skill to the Hugging Face Hub.
What are this skill's strengths and limitations?
- Supports a broad set of Hugging Face vision, VLM, and LLM fine-tuning workflows.
- Requires live research of model cards, task documentation, and examples to reduce errors from stale library knowledge.
- Requires a real-data one-step smoke test with explicit finite-loss and positive-gradient criteria.
- Produces a complete set of container, configuration, training, evaluation, inference, and rerun artifacts.
- Defines minimal-change recovery rules for OOM, NaN, flat loss, and repeated failures.
- Requires Docker, NVIDIA Container Toolkit, an NVIDIA GPU, an NGC image, and substantial disk capacity.
- The hardware threshold is significant; the documented reference is at least 24 GB VRAM for models up to 3B parameters.
- The supplied material does not show a successful run for a particular model or dataset.
- Live research, image building, data preparation, and full training require network access, storage, and compute.
- Repository-level signing, evaluation, and benchmark claims in the README do not by themselves prove equivalent validation for this individual skill.
How do you install this skill?
Install the individual skill from the NVIDIA catalog with the skills CLI:
npx skills add nvidia/skills --skill tao-finetune-huggingface-model --yes
You can target a specific agent, for example:
npx skills add nvidia/skills --skill tao-finetune-huggingface-model --agent codex --yes
The README does not document another standalone installation method for this skill.
How do you use this skill?
After installation, ask the agent something like: “Use tao-finetune-huggingface-model to fine-tune google/vit-base-patch16-224 on a local NVIDIA GPU.” A model_id is required. You may provide a Hugging Face dataset_id, a local dataset path, or ask the agent to recommend a dataset. Optional inputs include task_type, training method, LoRA settings, output directory, baseline-evaluation behavior, and Hub publishing. The environment must provide Docker, NVIDIA Container Toolkit, a compatible NVIDIA GPU host, and sufficient disk space. The skill requires a successful smoke test before full training.