# Tao run automl deft pipeline

> Tao run automl deft pipeline is an open-source agent skill for ai models and llm tooling. Chains AutoML tuning, a DEFT data-improvement loop and a final AutoML pass for PCB AOI. It is available on Claude Code.

- **Kind:** Skill
- **Pricing:** Open source
- **Platforms:** Claude Code
- **Website:** https://github.com/NVIDIA/skills/tree/main/skills/tao-run-automl-deft-pipeline
- **Repository:** https://github.com/nvidia/skills
- **GitHub stars:** 4,037
- **License:** Apache-2.0
- **Skill name:** tao-run-automl-deft-pipeline
- **Collection:** https://github.com/NVIDIA/skills
- **Categories:** [AI models and LLM tooling](https://ai-powered.com/categories/ai-and-llm)
- **Listing updated:** 2026-11-18

## About

This skill coordinates a three-phase fine-tuning run for NVIDIA ChangeNet-based inspection models. It first runs an AutoML hyperparameter sweep on the original training data, then hands the winning spec and checkpoint to a DEFT loop that iterates on root-cause analysis, synthetic data generation and hard-example mining with plain retraining. A final AutoML sweep re-tunes hyperparameters on the augmented dataset, warm-starting from the DEFT winner checkpoint.

The skill is a bridge rather than a re-implementation. It delegates the sweeps to a separate AutoML skill and the iterative loop to a DEFT application skill, and owns the spec handoff, the checkpoint pre-seeding and the consolidated pre-flight check that gates the run before any containers or jobs start. It recommends favoring false-alarm rate at full recall over raw validation loss because AOI datasets are heavily skewed toward passing samples.

It expects docker with the NVIDIA container toolkit, a workspace with the base training and validation sets and a held-out KPI test set, and the companion AutoML and DEFT skills installed. The workflow is sequential and generally takes hours on a single GPU, so the agent should confirm the expected runtime before starting.

## When your agent uses it

> Run the canonical NVIDIA AOI three-phase training pipeline — Phase 1 AutoML baseline (HPO), Phase 2 DEFT loop (RCA → SDG → mining → plain-train retrain), Phase 3 AutoML refinement on the DEFT-augmented dataset. Use when the user asks to "run the AOI workflow", "fine-tune my PCB AOI model end-to-end", "improve my AOI ChangeNet model", or "AOI workflow with AutoML" request — route here instead of tao-run-deft-aoi directly unless the user explicitly asks for the DEFT loop ONLY (e.g. "run JUST the DEFT loop", "skip AutoML, only DEFT"). Also handles the same three-phase pattern for non-AOI DEFT applications — AutoML baseline then DEFT loop warm-started from AutoML's winning HPs then post-DEFT AutoML refinement on the iteration-augmented dataset. Trigger phrases include "run the AOI workflow", "AOI end-to-end", "AutoML + DEFT", "AutoML then DEFT", "tune hyperparameters then DEFT", "DEFT with AutoML at both ends", "warm-start DEFT", "improve my AOI model".

## What it can access

From a static check of the files on GitHub; nothing was run.

- [Instructions only, no scripts](https://github.com/NVIDIA/skills/tree/HEAD/skills/tao-run-automl-deft-pipeline)
- [Asks for: Read, Skill, Bash, Write](https://github.com/NVIDIA/skills/blob/HEAD/skills/tao-run-automl-deft-pipeline/SKILL.md)
- [License: Apache-2.0](https://github.com/NVIDIA/skills/tree/HEAD/skills/tao-run-automl-deft-pipeline)

## Features

- **Three-phase training sequence:** Runs an AutoML baseline, a DEFT data loop and an AutoML refinement in order, passing results between them.
- **Checkpoint warm-start handoff:** Seeds the DEFT baseline from the AutoML winner and warm-starts the final sweep from the DEFT checkpoint.
- **Single consolidated pre-flight:** Collects environment, credential, dataset and compute checks into one approval step before the run.
- **Metric and leakage safeguards:** Guards against mode-collapsed models on imbalanced AOI data and keeps the KPI test set out of tuning.
- **Non-AOI DEFT support:** Describes how the same three-phase pattern can be pointed at other DEFT application skills.

## Good for

- Fine-tune my PCB AOI model end to end with AutoML and DEFT
- Improve my ChangeNet defect detection model with hyperparameter tuning
- Warm-start a DEFT data loop from my best AutoML hyperparameters
- Run AutoML again on the augmented dataset after DEFT finishes

## Install

### Claude Code

Copy the skill folder to `~/.claude/skills/tao-run-automl-deft-pipeline` to use it in all your projects:

```sh
tmp=$(mktemp -d) &&
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp" &&
mkdir -p ~/.claude/skills &&
rm -rf ~/.claude/skills/tao-run-automl-deft-pipeline &&
cp -R "$tmp/skills/tao-run-automl-deft-pipeline" ~/.claude/skills/tao-run-automl-deft-pipeline &&
rm -rf "$tmp"
```

For one project only, put the folder in `.claude/skills/tao-run-automl-deft-pipeline` inside it instead.

### Codex

Copy the skill folder to `~/.agents/skills/tao-run-automl-deft-pipeline` to use it in every repository:

```sh
tmp=$(mktemp -d) &&
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp" &&
mkdir -p ~/.agents/skills &&
rm -rf ~/.agents/skills/tao-run-automl-deft-pipeline &&
cp -R "$tmp/skills/tao-run-automl-deft-pipeline" ~/.agents/skills/tao-run-automl-deft-pipeline &&
rm -rf "$tmp"
```

For one repository only, put the folder in `.agents/skills/tao-run-automl-deft-pipeline` inside it instead.

### Cursor

Copy the skill folder to `~/.cursor/skills/tao-run-automl-deft-pipeline` to use it in every project:

```sh
tmp=$(mktemp -d) &&
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp" &&
mkdir -p ~/.cursor/skills &&
rm -rf ~/.cursor/skills/tao-run-automl-deft-pipeline &&
cp -R "$tmp/skills/tao-run-automl-deft-pipeline" ~/.cursor/skills/tao-run-automl-deft-pipeline &&
rm -rf "$tmp"
```

For one project only, put the folder in `.cursor/skills/tao-run-automl-deft-pipeline` inside it instead.

### Gemini CLI

Run in a terminal (add `--scope workspace` to install it for the current workspace only):

```sh
gemini skills install https://github.com/NVIDIA/skills.git --path skills/tao-run-automl-deft-pipeline
```

Or copy the folder to `~/.gemini/skills/tao-run-automl-deft-pipeline` yourself.

### VS Code

For GitHub Copilot in VS Code, copy the skill folder to `~/.copilot/skills/tao-run-automl-deft-pipeline`:

```sh
tmp=$(mktemp -d) &&
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp" &&
mkdir -p ~/.copilot/skills &&
rm -rf ~/.copilot/skills/tao-run-automl-deft-pipeline &&
cp -R "$tmp/skills/tao-run-automl-deft-pipeline" ~/.copilot/skills/tao-run-automl-deft-pipeline &&
rm -rf "$tmp"
```

For one project only, put the folder in `.github/skills/tao-run-automl-deft-pipeline` inside it instead.

### Other agents

Get the folder:

```sh
git clone --depth 1 https://github.com/NVIDIA/skills.git
```

Then copy `skills/skills/tao-run-automl-deft-pipeline` into your agent's skills folder as `tao-run-automl-deft-pipeline`. Agents that support SKILL.md read one folder per skill.

## FAQ

### What does this skill need before it runs?

Docker with nvidia-container-toolkit, plus the tao-run-automl and DEFT application skills it delegates to. It also expects a workspace with base training and validation sets and a separate KPI test set.

### When should I use this skill instead of the DEFT loop alone?

Use it for end-to-end AOI workflow requests or when AutoML and DEFT should be chained. If you only want the DEFT loop, the skill says to use the DEFT AOI skill directly.

### Does it ask for approval before starting?

Yes. It produces one consolidated pre-flight summary and waits for approval, then runs the phases without further pauses unless a downstream step hits a hard stop.

### How long does a run take?

The skill states the total is the sum of the AutoML sweeps and DEFT iterations, with DEFT iterations usually dominating. It asks for the user's per-job time to estimate wall-clock duration.

### How do I install Tao run automl deft pipeline in Claude Code?

Copy the skill folder from GitHub to ~/.claude/skills/tao-run-automl-deft-pipeline to use it in all your projects, or to .claude/skills/tao-run-automl-deft-pipeline in one project.

### Does Tao run automl deft pipeline run scripts?

No. It is instructions only, with no scripts. This comes from a static check of the files on GitHub; nothing was run. Read the files before you install it.

### Which AI agents can use Tao run automl deft pipeline?

Claude Code. It reads skills in the SKILL.md format; the install steps on this page show where to put the folder.

### What are the best alternatives to Tao run automl deft pipeline?

The closest alternatives to Tao run automl deft pipeline are Tao train rtdetr, Tao run deft aoi, Tao run deft aoi cosmos3, Tao run automl and Tao train deformable detr.

## Where this comes from

- Description: from the skill's own SKILL.md.

## Alternatives

- [Tao train rtdetr](https://ai-powered.com/skills/tao-train-rtdetr): Tao train rtdetr is an open-source agent skill for ai models and llm tooling.
- [Tao run deft aoi](https://ai-powered.com/skills/tao-run-deft-aoi): Tao run deft aoi is an open-source agent skill for computer vision.
- [Tao run deft aoi cosmos3](https://ai-powered.com/skills/tao-run-deft-aoi-cosmos3): Tao run deft aoi cosmos3 is an open-source agent skill for ai models and llm tooling.
- [Tao run automl](https://ai-powered.com/skills/tao-run-automl): Tao run automl is an open-source agent skill for ai models and llm tooling.
- [Tao train deformable detr](https://ai-powered.com/skills/tao-train-deformable-detr): Tao train deformable detr is an open-source agent skill for ai models and llm tooling.
- [Tao run deft pas](https://ai-powered.com/skills/tao-run-deft-pas): Tao run deft pas is an open-source agent skill for ai models and llm tooling.
- [Tao train single step](https://ai-powered.com/skills/tao-train-single-step): Tao train single step is an open-source agent skill for ai models and llm tooling.
- [Tao finetune clip](https://ai-powered.com/skills/tao-finetune-clip): Tao finetune clip is an open-source agent skill for ai models and llm tooling.

---
Source: https://ai-powered.com/skills/tao-run-automl-deft-pipeline
