1# Quickstart: Fine-Tune Your First Model
2 
36 steps from zero to a fine-tuned model using SFT with synthetic data.
4 
5> **Time**: ~20 min active + 1-3 hours training.
6 
7## Prerequisites
8 
9- Azure AI Foundry project with a deployed model (e.g., `gpt-4.1-mini`)
10- Python 3.10+ with `openai` installed
11- Project endpoint URL and API key (Foundry portal → Project Settings)
12 
13## Step 1: Connect to Your Project
14 
15```bash
16export OPENAI_BASE_URL="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>/openai/v1/"
17export AZURE_OPENAI_API_KEY="<your-key>"
18```
19 
20```python
21from openai import OpenAI
22import os
23 
24client = OpenAI(base_url=os.environ["OPENAI_BASE_URL"], api_key=os.environ["AZURE_OPENAI_API_KEY"])
25resp = client.chat.completions.create(model="gpt-4.1-mini", messages=[{"role": "user", "content": "Hello"}], max_tokens=10)
26print(resp.choices[0].message.content)
27```
28 
29## Step 2: Generate Training Data
30 
31```python
32import json, re
33 
34SYSTEM_PROMPT = "You are a concise technical support agent. Answer in 1-2 sentences."
35 
36generation_prompt = """Generate 50 diverse technical support conversations.
37Each should have a customer question and an ideal agent response (1-2 sentences).
38Cover: password resets, billing, product setup, account changes, shipping, troubleshooting.
39Return a JSON array where each element has "question" and "answer" fields."""
40 
41resp = client.chat.completions.create(
42    model="gpt-4.1-mini", messages=[{"role": "user", "content": generation_prompt}],
43    max_tokens=8000, temperature=1.0,
44)
45 
46content = resp.choices[0].message.content
47match = re.search(r'```(?:json)?\s*\n(.*?)\n```', content, re.DOTALL)
48json_str = match.group(1) if match else content.strip().strip("`").replace("json\n", "")
49examples = json.loads(json_str)
50 
51for split, name, rng in [("train", "train.jsonl", examples[:40]), ("val", "val.jsonl", examples[40:])]:
52    with open(name, "w") as f:
53        for ex in rng:
54            f.write(json.dumps({"messages": [
55                {"role": "system", "content": SYSTEM_PROMPT},
56                {"role": "user", "content": ex["question"]},
57                {"role": "assistant", "content": ex["answer"]},
58            ]}) + "\n")
59```
60 
61Validate: `python scripts/validate/validate_sft.py train.jsonl`
62 
63## Step 3: Baseline the Base Model
64 
65```python
66with open("val.jsonl") as f:
67    test_examples = [json.loads(line) for line in f][:5]
68 
69for ex in test_examples:
70    resp = client.chat.completions.create(
71        model="gpt-4.1-mini", messages=ex["messages"][:2], max_tokens=200)
72    print(f"Q: {ex['messages'][1]['content']}")
73    print(f"Expected: {ex['messages'][2]['content']}")
74    print(f"Base model: {resp.choices[0].message.content}\n")
75```
76 
77## Step 4: Upload Data and Submit Job
78 
79```python
80import time
81 
82with open("train.jsonl", "rb") as f:
83    train = client.files.create(file=f, purpose="fine-tune")
84with open("val.jsonl", "rb") as f:
85    val = client.files.create(file=f, purpose="fine-tune")
86 
87for _ in range(30):
88    if client.files.retrieve(train.id).status == "processed" and client.files.retrieve(val.id).status == "processed":
89        break
90    time.sleep(10)
91 
92job = client.fine_tuning.jobs.create(
93    model="gpt-4.1-mini", training_file=train.id, validation_file=val.id,
94    suffix="my-first-ft",
95    method={"type": "supervised"},
96    hyperparameters={"n_epochs": 2, "learning_rate_multiplier": 1.0},
97)
98print(f"Job submitted: {job.id}")
99```
100 
101Or via script:
102```bash
103python scripts/submit_training.py --model gpt-4.1-mini --training-file train.jsonl --validation-file val.jsonl --type sft --suffix my-first-ft --epochs 2
104```
105 
106## Step 5: Monitor
107 
108```bash
109python scripts/monitor_training.py --job-id <your-job-id>
110```
111 
112Or check [Azure AI Foundry portal](https://ai.azure.com) → Fine-tuning → Jobs.
113 
114## Step 6: Deploy, Test, and Compare
115 
116```bash
117python scripts/deploy_model.py --model-id <fine-tuned-model-name> --name my-ft-deployment --capacity 50
118```
119 
120```python
121for ex in test_examples:
122    base = client.chat.completions.create(model="gpt-4.1-mini", messages=ex["messages"][:2], max_tokens=200)
123    ft = client.chat.completions.create(model="my-ft-deployment", messages=ex["messages"][:2], max_tokens=200)
124    print(f"Q: {ex['messages'][1]['content']}")
125    print(f"Base:       {base.choices[0].message.content}")
126    print(f"Fine-tuned: {ft.choices[0].message.content}\n")
127```
128 
129## What's Next
130 
131- **Scale data**: 200-500 examples → `workflows/dataset-creation.md`
132- **Try RFT**: For verifiable answers → `references/training-types.md`
133- **Debug**: `workflows/diagnose-poor-results.md`
134- **Full guide**: `workflows/full-pipeline.md`
135