Generated banner for Finetuning
Generated logo for Finetuning

Finetuning

MicrosoftOfficialCreated by Microsoft

  • Skill
  • Tool integration
  • Data and AI
  • MIT
  • Low risk
  • Has scripts

From the author

Fine-tune models on Microsoft Foundry using SFT (supervised), DPO (preference), or RFT (reinforcement with graders). Covers dataset preparation, training job submission, deployment, and evaluation. USE FOR: fine-tune, SFT, DPO, RFT, training data, grader, distillation, fine-tuned model, training job, large file upload, calibrate grader, deploy fine-tuned model, evaluate fine-tuned model. DO NOT USE FOR: general model deployment without fine-tuning (use deploy-model), agent creation (use agents), prompt optimization without training (use prompt-optimizer).
— the description by Microsoft

AutoGineer summary

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

This skill provides the necessary procedures and tools for fine-tuning AI models on Microsoft Foundry. It supports three primary training methodologies: Supervised Fine-Tuning (SFT), Direct Preference Optimization (DPO), and Reinforcement Fine-Tuning (RFT). The skill encompasses the entire lifecycle, including dataset preparation, training job submission, monitoring, model evaluation, and deployment. It also includes specific guidance for agentic RFT, where models are trained to utilize external tools, and provides scripts for data validation, grader calibration, and resource management.

What it does

  • Supports SFT, DPO, and RFT training methodologies.
  • Provides data validation scripts for SFT, DPO, and RFT formats.
  • Facilitates training job submission and monitoring on Microsoft Foundry.
  • Enables calibration of RFT graders and pass thresholds.
  • Offers tools for model evaluation and deployment via ARM REST API.
  • Includes utilities for synthetic data generation and dataset quality scoring.

When to use it

  • When you need to adapt a base model to specific tasks or domains.
  • When preparing or validating training datasets for SFT, DPO, or RFT.
  • When training models for agentic scenarios involving tool calling.
  • When you need to evaluate and deploy a fine-tuned model.
  • When troubleshooting training jobs or diagnosing poor model performance.

Advantages

  • Standardized workflows for different training types.
  • Includes built-in validation to prevent common data formatting errors.
  • Supports complex agentic RFT training with tool integration.
  • Provides robust scripts for monitoring and evaluating training progress.
  • Offers clear guidance on grader design and hyperparameter tuning.

Usage examples

“How do I validate my SFT dataset before training?”
The agent will instruct you to use the python scripts/validate/validate_sft.py script on your data.jsonl file to ensure it meets the required format.
“Submit an SFT training job using gpt-4.1-mini.”
The agent will provide the command using scripts/submit_training.py with the appropriate flags for model, training file, validation file, and type.
“How can I calibrate my RFT grader?”
The agent will guide you to use scripts/calibrate_grader.py to find the optimal pass_threshold, aiming for a 25-50% failure rate on the base model.
“Deploy my fine-tuned model after training.”
The agent will provide the command to use scripts/deploy_model.py, specifying the model-id and a deployment name.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/finetuning/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip finetuning.zip -d .agents/skills

Documentation by Microsoft

Fine-Tuning on Microsoft Foundry

Fine-tune models using SFT (supervised), DPO (preference), or RFT (reinforcement with graders). Covers dataset prep, training, deployment, and evaluation.

When to Use

Use this sub-skill when the user asks about:

  • Fine-tuning a model (SFT, DPO, or RFT)

  • Preparing, validating, or formatting training data

  • Submitting, monitoring, or diagnosing training jobs

  • Calibrating graders or pass thresholds for RFT

  • Deploying or evaluating a fine-tuned model

  • Choosing between training types (SFT vs DPO vs RFT)

  • Distillation, synthetic data generation, or dataset quality scoring

  • Large file uploads for training data

  • Cleaning up fine-tuning resources (files, deployments)

Do NOT use for: General model deployment without fine-tuning (use deploy-model), agent creation (use agents), prompt optimization without training (use prompt-optimizer).

Workflows

References

Scripts

ScriptPurpose
scripts/submit_training.pySubmit SFT/DPO/RFT jobs
scripts/monitor_training.pyPoll job until completion
scripts/calibrate_grader.pyFind optimal RFT pass_threshold
scripts/check_training.pyAnalyze curves, list checkpoints
scripts/deploy_model.pyDeploy via ARM REST API
scripts/evaluate_model.pyLLM judge evaluation
scripts/convert_dataset.pyConvert between SFT/DPO/RFT formats
scripts/generate_distillation_data.pyGenerate synthetic training data
scripts/score_dataset.pyQuality scoring on training data
scripts/cleanup.pyDelete old files and deployments
scripts/validate/Data validators (SFT, DPO, RFT) + stats

Rules

  1. Always baseline first — evaluate the base model before fine-tuning

  2. Validate data before submitting — run scripts/validate/validate_sft.py

  3. Calibrate RFT graders — target 25-50% failure rate on the base model

  4. Evaluate checkpoints — don't blindly deploy the final one

  5. Measure token cost alongside accuracy when comparing models

Quick Reference

TaskCommand
Validate SFT datapython scripts/validate/validate_sft.py data.jsonl
Submit SFT jobpython scripts/submit_training.py --model gpt-4.1-mini --training-file train.jsonl --validation-file val.jsonl --type sft
Monitor jobpython scripts/monitor_training.py --job-id ftjob-xxx
Analyze curvespython scripts/check_training.py --job-id ftjob-xxx
Deploy modelpython scripts/deploy_model.py --model-id ft:gpt-4.1-mini:... --name my-eval
Evaluate modelpython scripts/evaluate_model.py --deployment-name my-eval --test-file test.jsonl

Error Handling

ErrorCauseFix
"API version not supported"Older openai SDK on /v1/ endpointUpgrade to openai>=1.0
"does not support fine-tuning with Standard TrainingType"OSS model needs globalStandardUse --use-rest flag or script auto-falls back
Job stuck in post-training evalUnder-provisioned tool endpoint (RFT)Scale to S2+, enable Always On
"DeploymentNotReady" after ARM succeedsARM/data-plane race conditionDelete and recreate deployment, wait 5 min
Content safety block at deploymentPII-dense training dataRemove problematic document types

Files

workflows/full-pipeline.md

Full Pipeline Workflow

End-to-end fine-tuning on Microsoft Foundry in 9 phases.

Prerequisites

  • Microsoft Foundry resource with fine-tuning enabled

  • Python 3.10+ with openai and requests

  • Azure CLI (az) authenticated

  • A clear task definition: what should the model do differently after fine-tuning?

Phase 1: Define the Task

Answer before touching data or models:

  1. What task? (e.g., "translate natural language to Python code")

  2. What does good output look like? Write 5 examples by hand.

  3. What does bad output look like? Write 3 anti-examples.

  4. How will you measure success? Define evaluation dimensions (see references/grader-design.md).

  5. Which base model? Pick 1-3 candidates from the supported model list.

Phase 2: Prepare the Dataset

Option A: You Have Data
  1. Convert to SFT JSONL format (see references/dataset-formats.md)

  2. Split: 80% train, 10% validation, 10% held-out test

  3. Remove or fix low-quality examples

Option B: Synthetic Data
  1. Generate using LLM prompts (see workflows/dataset-creation.md)

  2. Convert to SFT JSONL with scripts/convert_dataset.py

Option C: Hybrid (Seed + Synthetic)
  1. Use existing data as seed, generate synthetic variations

  2. Merge, deduplicate, and quality-filter

Checkpoint: You should have training.jsonl, validation.jsonl, and test.jsonl (never used for training).

Phase 3: Establish Baselines

  1. Deploy base model (or use existing deployment)

  2. Record scores — this is your "zero" that every fine-tune must beat

Phase 4: Choose Training Type

See references/training-types.md for the full decision framework.

ConditionTraining Type
Have input-output pairsSFT
Can write a grading functionRFT (reasoning models only)
Need style alignmentDPO

Most projects start with SFT. Move to RFT/DPO only if SFT isn't sufficient.

Phase 5: Upload and Submit Training

Use scripts/submit_training.py or the API directly. See references/hyperparameters.md for starting HP values.

Foundry CLI alternative (no Python):

azd ai finetuning jobs submit -f ./fine-tune-job.yaml

Phase 6: Monitor and Analyze

  1. Wait for completion or use scripts/monitor_training.py

  2. Analyze training curves with scripts/check_training.py

  3. Read references/training-curves.md to interpret results

  4. Check for overfitting — consider deploying an earlier checkpoint if detected

Phase 7: Evaluate Fine-Tuned Model

  1. Deploy fine-tuned model (see references/deployment.md for format/SKU)

  2. Compare against baseline and previous experiments

  3. Delete deployment after evaluation

Phase 8: Iterate

Follow workflows/iterative-training.md:

  • Adjust hyperparameters based on training curves

  • Try different data subsets or augmentations

  • Test different base models

  • Track everything in your leaderboard

Phase 9: Ship

When the model convincingly beats baseline:

  1. Deploy with production-appropriate capacity

  2. Monitor with Application Insights

  3. Periodically re-evaluate against test set for regression

  4. Retrain as new data becomes available

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: Needs Python

Security

What our scanner noticed· Low risk

  • 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
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/skills · .github/plugins/azure-skills/skills/microsoft-foundry/finetuning · commit 0696600
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from .github/plugins/azure-skills/LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Also distributed in
microsoft/azure-skills

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download finetuning.zip