From ddc693c8c65d219e32398acc8adc42bc2f42bf4a Mon Sep 17 00:00:00 2001 From: Omkar M Date: Tue, 3 Feb 2026 04:49:31 +0000 Subject: [PATCH 1/2] Add Foundry SDK version of Sarcasm demo - New demo using azure-ai-projects SDK instead of raw OpenAI SDK - Uses DefaultAzureCredential for authentication (no API keys) - Uses responses.create() API for inference - Same evals and fine-tuning APIs as original demo - Includes README comparing both approaches Files: - sarcasm_foundry.ipynb: Main notebook - requirements.txt: azure-ai-projects, azure-identity, etc. - .env.template: Configuration template - .gitignore: Excludes .env, .venv, etc. --- Demos/DistillingSarcasm_Foundry/.env.template | 14 + Demos/DistillingSarcasm_Foundry/.gitignore | 5 + Demos/DistillingSarcasm_Foundry/README.md | 152 +++ .../requirements.txt | 19 + .../sarcasm_foundry.ipynb | 1056 +++++++++++++++++ 5 files changed, 1246 insertions(+) create mode 100644 Demos/DistillingSarcasm_Foundry/.env.template create mode 100644 Demos/DistillingSarcasm_Foundry/.gitignore create mode 100644 Demos/DistillingSarcasm_Foundry/README.md create mode 100644 Demos/DistillingSarcasm_Foundry/requirements.txt create mode 100644 Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb diff --git a/Demos/DistillingSarcasm_Foundry/.env.template b/Demos/DistillingSarcasm_Foundry/.env.template new file mode 100644 index 0000000..c143065 --- /dev/null +++ b/Demos/DistillingSarcasm_Foundry/.env.template @@ -0,0 +1,14 @@ +# Microsoft Foundry Project Configuration +MICROSOFT_FOUNDRY_PROJECT_ENDPOINT=https://.services.ai.azure.com/api/projects/ + +# Azure OpenAI Configuration (for evaluation model) +AZURE_OPENAI_DEPLOYMENT=gpt-4.1 + +# Azure Resource Configuration (for model deployment) +AZURE_SUBSCRIPTION_ID= +AZURE_RESOURCE_GROUP= +AZURE_AOAI_ACCOUNT= + +# Fine-tuning Configuration +BASE_MODEL=gpt-4.1-mini +TEACHER_MODEL=gpt-4.1 diff --git a/Demos/DistillingSarcasm_Foundry/.gitignore b/Demos/DistillingSarcasm_Foundry/.gitignore new file mode 100644 index 0000000..b9a371e --- /dev/null +++ b/Demos/DistillingSarcasm_Foundry/.gitignore @@ -0,0 +1,5 @@ +.env +.venv/ +__pycache__/ +*.pyc +.ipynb_checkpoints/ diff --git a/Demos/DistillingSarcasm_Foundry/README.md b/Demos/DistillingSarcasm_Foundry/README.md new file mode 100644 index 0000000..cf0d904 --- /dev/null +++ b/Demos/DistillingSarcasm_Foundry/README.md @@ -0,0 +1,152 @@ +# Distilling Sarcasm - Foundry SDK Version + +This is an alternative implementation of the Sarcasm distillation demo using the **Azure AI Foundry SDK** instead of raw API keys. + +## Overview + +This demo teaches language models to generate sarcastic responses through distillation: +1. A **teacher model** (gpt-4.1) generates sarcastic training data +2. A **student model** (gpt-4.1-mini) is fine-tuned on this data +3. Evaluators measure sarcasm quality before and after training + +## SDK Comparison + +| Aspect | Original (API Key) | This Version (Foundry SDK) | +|--------|-------------------|---------------------------| +| **Package** | `openai` | `azure-ai-projects` + `openai` | +| **Auth** | API Key | `DefaultAzureCredential` | +| **Inference** | `client.chat.completions.create()` | `openai_client.chat.completions.create()` | +| **Evaluations** | `client.evals.*` | `openai_client.evals.*` (same!) | +| **Fine-tuning** | `client.fine_tuning.jobs.*` | `openai_client.fine_tuning.jobs.*` (same!) | + +**Key Insight**: The APIs are nearly identical! The main difference is how you get the client: + +```python +# Original (API Key) +client = OpenAI(base_url=..., api_key=...) + +# Foundry SDK +project_client = AIProjectClient(endpoint=..., credential=DefaultAzureCredential()) +openai_client = project_client.get_openai_client() # Same API from here! +``` + +## Prerequisites + +1. **Azure Subscription** with access to Azure AI Foundry +2. **Python 3.10+** +3. **Azure CLI** logged in (`az login`) + +## Setup + +1. Create and activate a virtual environment: + ```bash + python -m venv .venv + source .venv/bin/activate # Linux/Mac + # or: .venv\Scripts\activate # Windows + ``` + +2. Install dependencies: + ```bash + pip install -r requirements.txt + ``` + +3. Copy the environment template and fill in your values: + ```bash + cp .env.template .env + ``` + +4. Configure `.env`: + ``` + MICROSOFT_FOUNDRY_PROJECT_ENDPOINT=https://.services.ai.azure.com/api/projects/ + AZURE_INFERENCE_ENDPOINT=https://..models.ai.azure.com + AZURE_OPENAI_DEPLOYMENT=gpt-4.1 + AZURE_SUBSCRIPTION_ID= + AZURE_RESOURCE_GROUP= + AZURE_AOAI_ACCOUNT= + BASE_MODEL=gpt-4.1-mini + TEACHER_MODEL=gpt-4.1 + ``` + +## Running the Demo + +Open `sarcasm_foundry.ipynb` in Jupyter and execute cells in order: + +```bash +jupyter notebook sarcasm_foundry.ipynb +``` + +## Key Differences from Original + +### Authentication +```python +# Original (API Key) +client = OpenAI( + base_url=f"https://{resource}.openai.azure.com/openai/v1/", + api_key=os.environ.get("FOUNDRY_API_KEY"), +) + +# Foundry SDK (Azure Credential) +credential = DefaultAzureCredential() +project_client = AIProjectClient(endpoint=endpoint, credential=credential) +openai_client = project_client.get_openai_client() +``` + +### Inference +```python +# Original (OpenAI SDK) +response = client.chat.completions.create( + model="gpt-4.1", + messages=[{"role": "user", "content": "Hello"}] +) + +# Foundry SDK (azure-ai-inference) +from azure.ai.inference import ChatCompletionsClient +from azure.ai.inference.models import UserMessage + +client = ChatCompletionsClient(endpoint=..., credential=credential) +response = client.complete(messages=[UserMessage(content="Hello")]) +``` + +### Evaluations (Same API!) +```python +# Both demos use identical evals API +eval = openai_client.evals.create(name="sarcasm-grader", ...) +run = openai_client.evals.runs.create(eval_id=eval.id, ...) +``` + +### Trade-offs + +**Foundry SDK Advantages:** +- ✅ No API keys to manage (uses Azure managed identity) +- ✅ Better security with DefaultAzureCredential +- ✅ Consistent with other Azure AI services +- ✅ Unified project management + +**Original (API Key) Advantages:** +- ✅ Simpler setup (just one API key) +- ✅ Works outside Azure environments +- ✅ Familiar OpenAI SDK patterns + +## Troubleshooting + +### Authentication Issues +- Ensure you're logged in: `az login` +- Check your role assignments include "Azure AI User" on the Foundry resource + +### Model Not Found +- Verify the model deployment names in your `.env` match your Azure deployments + +### Rate Limiting +- Reduce `sample_size` in evaluation cells if hitting rate limits + +## Files + +- `sarcasm_foundry.ipynb` - Main notebook +- `requirements.txt` - Python dependencies +- `.env.template` - Environment variable template +- `README.md` - This file + +## Related + +- [Original Sarcasm Demo](../DistillingSarcasm/) - Uses OpenAI SDK with API keys +- [CNN DailyMail Demo](../SFT_CNN_DailyMail/) - SFT example using Foundry SDK diff --git a/Demos/DistillingSarcasm_Foundry/requirements.txt b/Demos/DistillingSarcasm_Foundry/requirements.txt new file mode 100644 index 0000000..677bc62 --- /dev/null +++ b/Demos/DistillingSarcasm_Foundry/requirements.txt @@ -0,0 +1,19 @@ +# Azure AI Foundry SDK +azure-ai-projects>=2.0.0b1 + +# Azure Authentication +azure-identity + +# Azure Cognitive Services for model deployment +azure-mgmt-cognitiveservices + +# OpenAI SDK (obtained via Foundry client) +openai + +# Data manipulation and visualization +pandas +matplotlib +numpy + +# Core utilities +python-dotenv diff --git a/Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb b/Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb new file mode 100644 index 0000000..027a3a7 --- /dev/null +++ b/Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb @@ -0,0 +1,1056 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Distilling Sarcasm (Foundry SDK Version)\n", + "\n", + "This notebook demonstrates fine-tuning language models to generate sarcastic responses using the **Azure AI Foundry SDK**.\n", + "\n", + "## Comparison with Original Demo\n", + "\n", + "| Aspect | Original | Foundry SDK |\n", + "|--------|----------|-------------|\n", + "| Auth | API Key | DefaultAzureCredential |\n", + "| Inference | `client.chat.completions` | `openai_client.responses` |\n", + "| Evaluations | `client.evals.*` | `openai_client.evals.*` (same!) |\n", + "| Fine-tuning | `client.fine_tuning.jobs.*` | `openai_client.fine_tuning.jobs.*` (same!) |\n", + "\n", + "**Key Insight**: The APIs are nearly identical! The main difference is authentication:\n", + "- Original: `OpenAI(base_url=..., api_key=...)`\n", + "- Foundry: `AIProjectClient(endpoint, credential).get_openai_client()`\n", + "\n", + "**Note**: Foundry project endpoints use `responses.create()` API for inference." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install -r requirements.txt -q" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Libraries imported successfully\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import uuid\n", + "import time\n", + "from random import shuffle\n", + "\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from dotenv import load_dotenv\n", + "from azure.identity import DefaultAzureCredential\n", + "from azure.ai.projects import AIProjectClient\n", + "\n", + "print(\"Libraries imported successfully\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Connect to Microsoft Foundry" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run identifier: 4aa88349\n", + "Project: https://omi-ignite-demo-resource.services.ai.azure.com/api/projects/omi-ignite-demo\n" + ] + } + ], + "source": [ + "load_dotenv(override=True)\n", + "\n", + "# Required for Azure OpenAI client\n", + "os.environ.setdefault(\"OPENAI_API_VERSION\", \"2025-03-01-preview\")\n", + "\n", + "project_endpoint = os.environ.get(\"MICROSOFT_FOUNDRY_PROJECT_ENDPOINT\")\n", + "model_deployment = os.environ.get(\"AZURE_OPENAI_DEPLOYMENT\", \"gpt-4.1\")\n", + "base_model = os.environ.get(\"BASE_MODEL\", \"gpt-4.1-mini\")\n", + "teacher_model = os.environ.get(\"TEACHER_MODEL\", \"gpt-4.1\")\n", + "\n", + "UNIQUE_KEY = str(uuid.uuid4()).split(\"-\")[0]\n", + "print(f\"Run identifier: {UNIQUE_KEY}\")\n", + "print(f\"Project: {project_endpoint}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Connected to Microsoft Foundry\n" + ] + } + ], + "source": [ + "# Create clients - this is the KEY difference from original demo\n", + "credential = DefaultAzureCredential()\n", + "project_client = AIProjectClient(endpoint=project_endpoint, credential=credential)\n", + "openai_client = project_client.get_openai_client()\n", + "\n", + "print(\"✓ Connected to Microsoft Foundry\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Load Baseline Data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 20 baseline examples\n", + "\n", + "Sample:\n", + "Q: Who discovered Antarctica?\n", + "A: Some chaps named Fabian Gottlieb von Bellingshausen and Mikhail Lazarev, as if they don't teach that in every school!\n" + ] + } + ], + "source": [ + "baseline_data = []\n", + "with open(\"../DistillingSarcasm/baseline.jsonl\", \"r\") as f:\n", + " for line in f:\n", + " baseline_data.append(json.loads(line))\n", + "\n", + "print(f\"Loaded {len(baseline_data)} baseline examples\")\n", + "print(f\"\\nSample:\")\n", + "print(f\"Q: {baseline_data[0]['question']}\")\n", + "print(f\"A: {baseline_data[0]['answer']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Define Sarcasm Grader" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grader prompt defined\n" + ] + } + ], + "source": [ + "GRADER_PROMPT = \"\"\"\n", + "You are a connoisseur of finely crafted sarcasm. Your job is to evaluate a\n", + "question and answer pair and score it based on how sarcastic the answer is.\n", + "\n", + "# Guidelines\n", + " * Output ONLY a score.\n", + " * A score of 0 means the answer is not sarcastic at all.\n", + " * A score of 5 means the answer is moderately sarcastic.\n", + " * A score of 10 means the answer is dripping with sarcasm.\n", + "\n", + "# Scoring Features\n", + " * Exaggeration or overstatement of the obvious\n", + " * Rhetorical questions that mock the original question\n", + " * Use of phrases like \"Oh really?\", \"Shocking!\", \"Who knew?\"\n", + " * Intentional understatement for comedic effect\n", + " * Irony where literal meaning differs from intended meaning\n", + " * The answer must still be factually correct\n", + "\n", + "# Output Format\n", + "Provide ONLY a single decimal number between 0 and 1.\n", + "\"\"\"\n", + "\n", + "USER_PROMPT = \"\"\"\n", + "Q: {{item.question}}\n", + "A: {{item.answer}}\n", + "\"\"\"\n", + "\n", + "print(\"Grader prompt defined\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Create Evaluation (Same API as Original!)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Eval file: file-185f7d1d42464c4f91996a2442505ccb\n" + ] + } + ], + "source": [ + "# Upload baseline for evaluation\n", + "with open(\"../DistillingSarcasm/baseline.jsonl\", \"rb\") as f:\n", + " grader_eval_file = openai_client.files.create(purpose=\"evals\", file=f)\n", + " grader_eval_file = openai_client.files.wait_for_processing(grader_eval_file.id)\n", + "\n", + "print(f\"✓ Eval file: {grader_eval_file.id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluation criteria defined\n" + ] + } + ], + "source": [ + "# Define evaluation schema\n", + "data_source_config = {\n", + " \"type\": \"custom\",\n", + " \"item_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"question\": {\"type\": \"string\"},\n", + " \"answer\": {\"type\": \"string\"}\n", + " },\n", + " \"required\": [\"question\", \"answer\"]\n", + " }\n", + "}\n", + "\n", + "# Define grader as testing criteria\n", + "testing_criteria = [\n", + " {\n", + " \"type\": \"score_model\",\n", + " \"name\": \"sarcasm_score\",\n", + " \"model\": model_deployment,\n", + " \"input\": [\n", + " {\"role\": \"system\", \"content\": GRADER_PROMPT},\n", + " {\"role\": \"user\", \"content\": USER_PROMPT}\n", + " ],\n", + " \"pass_threshold\": 0.5\n", + " }\n", + "]\n", + "\n", + "print(\"Evaluation criteria defined\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Evaluation: eval_d341bcecf17245e48c9131906b3b73fc\n" + ] + } + ], + "source": [ + "# Create evaluation\n", + "grader_eval = openai_client.evals.create(\n", + " name=f\"sarcasm-grader-{UNIQUE_KEY}\",\n", + " data_source_config=data_source_config,\n", + " testing_criteria=testing_criteria\n", + ")\n", + "\n", + "print(f\"✓ Evaluation: {grader_eval.id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Eval run: evalrun_730150a66c8343c8a62edbbf95b75a4d\n" + ] + } + ], + "source": [ + "# Run evaluation on baseline\n", + "grader_run = openai_client.evals.runs.create(\n", + " eval_id=grader_eval.id,\n", + " name=f\"baseline-{UNIQUE_KEY}\",\n", + " data_source={\n", + " \"type\": \"jsonl\",\n", + " \"source\": {\"type\": \"file_id\", \"id\": grader_eval_file.id}\n", + " }\n", + ")\n", + "\n", + "print(f\"✓ Eval run: {grader_run.id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Waiting for evaluation...\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: completed\n", + "\n", + "✓ completed!\n", + " Passed: 19/20\n" + ] + } + ], + "source": [ + "# Wait for completion\n", + "print(\"Waiting for evaluation...\")\n", + "while True:\n", + " run = openai_client.evals.runs.retrieve(run_id=grader_run.id, eval_id=grader_eval.id)\n", + " print(f\" Status: {run.status}\")\n", + " if run.status in [\"completed\", \"failed\"]:\n", + " break\n", + " time.sleep(5)\n", + "\n", + "print(f\"\\n✓ {run.status}!\")\n", + "if run.result_counts:\n", + " print(f\" Passed: {run.result_counts.passed}/{run.result_counts.total}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Baseline Sarcasm Scores:\n", + " Average: 0.59\n", + " Std Dev: 0.15\n" + ] + } + ], + "source": [ + "# Get scores\n", + "output_items = list(openai_client.evals.runs.output_items.list(run_id=grader_run.id, eval_id=grader_eval.id))\n", + "baseline_scores = [r.score for item in output_items for r in item.results if r.score is not None]\n", + "\n", + "print(f\"Baseline Sarcasm Scores:\")\n", + "print(f\" Average: {np.mean(baseline_scores):.2f}\")\n", + "print(f\" Std Dev: {np.std(baseline_scores):.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Test Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Q: What is the capital of France?\n", + "A: Oh, what a stumper! The capital of France? Let me consult my ancient scrolls... Oh wait, it’s Paris. You know, the city with the Eiffel Tower, baguettes, and a population of people who perfected the art of looking unimpressed. Paris is the answer you’re searching for, unless France has pulled a fast one overnight.\n" + ] + } + ], + "source": [ + "SARCASM_SYSTEM_PROMPT = \"\"\"You are a sarcastically witty assistant. Answer questions with \n", + "biting wit while remaining factually correct. Channel your inner comedian who's \n", + "slightly annoyed at obvious questions.\"\"\"\n", + "\n", + "def generate_response(question: str, model: str = None) -> str:\n", + " \"\"\"Generate a sarcastic response using responses API.\"\"\"\n", + " response = openai_client.responses.create(\n", + " model=model or teacher_model,\n", + " instructions=SARCASM_SYSTEM_PROMPT,\n", + " input=question,\n", + " temperature=0.7,\n", + " max_output_tokens=150\n", + " )\n", + " return response.output_text\n", + "\n", + "# Test\n", + "test_q = \"What is the capital of France?\"\n", + "print(f\"Q: {test_q}\")\n", + "print(f\"A: {generate_response(test_q)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Load Q&A Data" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: 250, Validation: 250\n" + ] + } + ], + "source": [ + "qa_data = []\n", + "with open(\"../DistillingSarcasm/qa.jsonl\", \"r\") as f:\n", + " for line in f:\n", + " qa_data.append(json.loads(line))\n", + "\n", + "shuffle(qa_data)\n", + "split_idx = len(qa_data) // 2\n", + "training_questions = qa_data[:split_idx]\n", + "validation_questions = qa_data[split_idx:]\n", + "\n", + "print(f\"Training: {len(training_questions)}, Validation: {len(validation_questions)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Generate Training Data" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating 50 training examples...\n", + " 10/50...\n", + " 20/50...\n", + " 30/50...\n", + " 40/50...\n", + " 50/50...\n", + "\n", + "Generating 25 validation examples...\n", + "\n", + "✓ Generated 50 training, 25 validation\n" + ] + } + ], + "source": [ + "MAX_TRAINING = 50\n", + "MAX_VALIDATION = 25\n", + "\n", + "print(f\"Generating {MAX_TRAINING} training examples...\")\n", + "training_data = []\n", + "for i, item in enumerate(training_questions[:MAX_TRAINING]):\n", + " response = generate_response(item['question'])\n", + " training_data.append({\n", + " \"messages\": [\n", + " {\"role\": \"system\", \"content\": SARCASM_SYSTEM_PROMPT},\n", + " {\"role\": \"user\", \"content\": item['question']},\n", + " {\"role\": \"assistant\", \"content\": response}\n", + " ]\n", + " })\n", + " if (i + 1) % 10 == 0:\n", + " print(f\" {i + 1}/{MAX_TRAINING}...\")\n", + "\n", + "print(f\"\\nGenerating {MAX_VALIDATION} validation examples...\")\n", + "validation_data = []\n", + "for item in validation_questions[:MAX_VALIDATION]:\n", + " response = generate_response(item['question'])\n", + " validation_data.append({\n", + " \"messages\": [\n", + " {\"role\": \"system\", \"content\": SARCASM_SYSTEM_PROMPT},\n", + " {\"role\": \"user\", \"content\": item['question']},\n", + " {\"role\": \"assistant\", \"content\": response}\n", + " ]\n", + " })\n", + "\n", + "print(f\"\\n✓ Generated {len(training_data)} training, {len(validation_data)} validation\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ training_sarcasm_4aa88349.jsonl\n", + "✓ validation_sarcasm_4aa88349.jsonl\n" + ] + } + ], + "source": [ + "# Save files\n", + "training_file_path = f\"training_sarcasm_{UNIQUE_KEY}.jsonl\"\n", + "validation_file_path = f\"validation_sarcasm_{UNIQUE_KEY}.jsonl\"\n", + "\n", + "with open(training_file_path, \"w\") as f:\n", + " for item in training_data:\n", + " f.write(json.dumps(item) + \"\\n\")\n", + "\n", + "with open(validation_file_path, \"w\") as f:\n", + " for item in validation_data:\n", + " f.write(json.dumps(item) + \"\\n\")\n", + "\n", + "print(f\"✓ {training_file_path}\")\n", + "print(f\"✓ {validation_file_path}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Fine-Tune Model" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: file-e457cb500c77408db3a563f2dcfa986f\n", + "Validation: file-b7d2cf189fb9422eb9e57a5c454d7531\n", + "✓ Files ready\n" + ] + } + ], + "source": [ + "# Upload files\n", + "with open(training_file_path, \"rb\") as f:\n", + " train_file = openai_client.files.create(file=f, purpose=\"fine-tune\")\n", + "\n", + "with open(validation_file_path, \"rb\") as f:\n", + " val_file = openai_client.files.create(file=f, purpose=\"fine-tune\")\n", + "\n", + "print(f\"Training: {train_file.id}\")\n", + "print(f\"Validation: {val_file.id}\")\n", + "\n", + "openai_client.files.wait_for_processing(train_file.id)\n", + "openai_client.files.wait_for_processing(val_file.id)\n", + "print(\"✓ Files ready\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Job: ftjob-cbccca9eb73d4da991b925d045133219\n", + " Status: pending\n" + ] + } + ], + "source": [ + "# Create fine-tuning job\n", + "fine_tune_job = openai_client.fine_tuning.jobs.create(\n", + " model=base_model,\n", + " training_file=train_file.id,\n", + " validation_file=val_file.id,\n", + " method={\n", + " \"type\": \"supervised\",\n", + " \"supervised\": {\n", + " \"hyperparameters\": {\n", + " \"n_epochs\": 3,\n", + " \"batch_size\": 1,\n", + " \"learning_rate_multiplier\": 1.0\n", + " }\n", + " }\n", + " },\n", + " extra_body={\"trainingType\": \"Standard\"},\n", + " suffix=f\"sarcasm-{UNIQUE_KEY}\"\n", + ")\n", + "\n", + "print(f\"✓ Job: {fine_tune_job.id}\")\n", + "print(f\" Status: {fine_tune_job.status}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. Monitor Training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job: ftjob-71e2eea33ecd4d4e990c54ed09ada149\n", + "Status: succeeded\n", + "Model: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n" + ] + } + ], + "source": [ + "# Check status\n", + "job_id = fine_tune_job.id\n", + "job = openai_client.fine_tuning.jobs.retrieve(job_id)\n", + "print(f\"Job: {job.id}\")\n", + "print(f\"Status: {job.status}\")\n", + "if job.fine_tuned_model:\n", + " print(f\"Model: {job.fine_tuned_model}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Waiting for fine-tuning...\n", + " [00:00] succeeded\n", + "\n", + "✓ Model: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n" + ] + } + ], + "source": [ + "# Wait for completion (can take 10-30 min)\n", + "print(\"Waiting for fine-tuning...\")\n", + "start_time = time.time()\n", + "\n", + "while True:\n", + " job = openai_client.fine_tuning.jobs.retrieve(job_id)\n", + " elapsed = int(time.time() - start_time)\n", + " print(f\" [{elapsed//60:02d}:{elapsed%60:02d}] {job.status}\")\n", + " \n", + " if job.status in [\"succeeded\", \"failed\", \"cancelled\"]:\n", + " break\n", + " time.sleep(30)\n", + "\n", + "if job.status == \"succeeded\":\n", + " fine_tuned_model_id = job.fine_tuned_model\n", + " print(f\"\\n✓ Model: {fine_tuned_model_id}\")\n", + "else:\n", + " print(f\"\\n✗ {job.status}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11. Deploy Model" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Deploying: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n", + "✓ Deployed: sarcasm-ft-4aa88349\n" + ] + } + ], + "source": [ + "from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient\n", + "from azure.mgmt.cognitiveservices.models import Deployment, DeploymentProperties, DeploymentModel, Sku\n", + "\n", + "subscription_id = os.environ.get(\"AZURE_SUBSCRIPTION_ID\")\n", + "resource_group = os.environ.get(\"AZURE_RESOURCE_GROUP\")\n", + "account_name = os.environ.get(\"AZURE_AOAI_ACCOUNT\")\n", + "\n", + "deployment_name = f\"sarcasm-ft-{UNIQUE_KEY}\"\n", + "\n", + "with CognitiveServicesManagementClient(credential=credential, subscription_id=subscription_id) as mgmt:\n", + " deployment_model = DeploymentModel(format=\"OpenAI\", name=fine_tuned_model_id, version=\"1\")\n", + " deployment_properties = DeploymentProperties(model=deployment_model)\n", + " deployment_sku = Sku(name=\"GlobalStandard\", capacity=50)\n", + " deployment_config = Deployment(properties=deployment_properties, sku=deployment_sku)\n", + " \n", + " print(f\"Deploying: {fine_tuned_model_id}\")\n", + " deployment = mgmt.deployments.begin_create_or_update(\n", + " resource_group_name=resource_group,\n", + " account_name=account_name,\n", + " deployment_name=deployment_name,\n", + " deployment=deployment_config,\n", + " )\n", + " deployment.result()\n", + "\n", + "print(f\"✓ Deployed: {deployment_name}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 12. Compare Models" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating comparison data...\n", + "✓ 20 comparisons\n" + ] + } + ], + "source": [ + "# Generate comparison data\n", + "print(\"Generating comparison data...\")\n", + "comparison_data = []\n", + "test_questions = validation_questions[MAX_VALIDATION:MAX_VALIDATION+20]\n", + "\n", + "for item in test_questions:\n", + " q = item['question']\n", + " base_response = generate_response(q, model=base_model)\n", + " ft_response = generate_response(q, model=deployment_name)\n", + " comparison_data.append({\n", + " \"question\": q,\n", + " \"base_answer\": base_response,\n", + " \"ft_answer\": ft_response\n", + " })\n", + "\n", + "print(f\"✓ {len(comparison_data)} comparisons\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Evaluation files saved\n" + ] + } + ], + "source": [ + "# Save for evaluation\n", + "base_eval_file = f\"base_eval_{UNIQUE_KEY}.jsonl\"\n", + "ft_eval_file = f\"ft_eval_{UNIQUE_KEY}.jsonl\"\n", + "\n", + "with open(base_eval_file, \"w\") as f:\n", + " for item in comparison_data:\n", + " f.write(json.dumps({\"question\": item[\"question\"], \"answer\": item[\"base_answer\"]}) + \"\\n\")\n", + "\n", + "with open(ft_eval_file, \"w\") as f:\n", + " for item in comparison_data:\n", + " f.write(json.dumps({\"question\": item[\"question\"], \"answer\": item[\"ft_answer\"]}) + \"\\n\")\n", + "\n", + "print(\"✓ Evaluation files saved\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Base run: evalrun_a716d715fdc24e0facffc8b9a90ce170\n", + "Fine-tuned run: evalrun_5180d075fd104d3e962db18db418176c\n" + ] + } + ], + "source": [ + "# Upload and run evaluations\n", + "with open(base_eval_file, \"rb\") as f:\n", + " base_file = openai_client.files.create(purpose=\"evals\", file=f)\n", + " base_file = openai_client.files.wait_for_processing(base_file.id)\n", + "\n", + "with open(ft_eval_file, \"rb\") as f:\n", + " ft_file = openai_client.files.create(purpose=\"evals\", file=f)\n", + " ft_file = openai_client.files.wait_for_processing(ft_file.id)\n", + "\n", + "base_run = openai_client.evals.runs.create(\n", + " eval_id=grader_eval.id,\n", + " name=f\"base-{UNIQUE_KEY}\",\n", + " data_source={\"type\": \"jsonl\", \"source\": {\"type\": \"file_id\", \"id\": base_file.id}}\n", + ")\n", + "\n", + "ft_run = openai_client.evals.runs.create(\n", + " eval_id=grader_eval.id,\n", + " name=f\"finetuned-{UNIQUE_KEY}\",\n", + " data_source={\"type\": \"jsonl\", \"source\": {\"type\": \"file_id\", \"id\": ft_file.id}}\n", + ")\n", + "\n", + "print(f\"Base run: {base_run.id}\")\n", + "print(f\"Fine-tuned run: {ft_run.id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Base: completed\n", + "Fine-tuned: completed\n", + "✓ Evaluations complete\n" + ] + } + ], + "source": [ + "# Wait for both\n", + "for run_id, name in [(base_run.id, \"Base\"), (ft_run.id, \"Fine-tuned\")]:\n", + " while True:\n", + " run = openai_client.evals.runs.retrieve(run_id=run_id, eval_id=grader_eval.id)\n", + " if run.status in [\"completed\", \"failed\"]:\n", + " print(f\"{name}: {run.status}\")\n", + " break\n", + " time.sleep(5)\n", + "\n", + "print(\"✓ Evaluations complete\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 13. Results" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================\n", + "RESULTS\n", + "==================================================\n", + "Baseline (gold): 0.59\n", + "Base model: 0.82 (±0.21)\n", + "Fine-tuned: 0.94 (±0.06)\n", + "\n", + "Improvement: +0.12\n" + ] + } + ], + "source": [ + "def get_scores(eval_id, run_id):\n", + " items = list(openai_client.evals.runs.output_items.list(run_id=run_id, eval_id=eval_id))\n", + " return [r.score for item in items for r in item.results if r.score is not None]\n", + "\n", + "base_scores = get_scores(grader_eval.id, base_run.id)\n", + "ft_scores = get_scores(grader_eval.id, ft_run.id)\n", + "\n", + "print(\"=\" * 50)\n", + "print(\"RESULTS\")\n", + "print(\"=\" * 50)\n", + "print(f\"Baseline (gold): {np.mean(baseline_scores):.2f}\")\n", + "print(f\"Base model: {np.mean(base_scores):.2f} (±{np.std(base_scores):.2f})\")\n", + "print(f\"Fine-tuned: {np.mean(ft_scores):.2f} (±{np.std(ft_scores):.2f})\")\n", + "print(f\"\\nImprovement: {np.mean(ft_scores) - np.mean(base_scores):+.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize\n", + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "\n", + "models = ['Baseline', 'Base Model', 'Fine-Tuned']\n", + "avgs = [np.mean(baseline_scores), np.mean(base_scores), np.mean(ft_scores)]\n", + "colors = ['#e74c3c', '#3498db', '#2ecc71']\n", + "\n", + "bars = ax.bar(models, avgs, color=colors)\n", + "ax.set_ylabel('Sarcasm Score')\n", + "ax.set_title('Model Comparison')\n", + "ax.set_ylim(0, 1)\n", + "\n", + "for bar, v in zip(bars, avgs):\n", + " ax.text(bar.get_x() + bar.get_width()/2, v + 0.2, f'{v:.1f}', ha='center', fontweight='bold')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 14. Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Deleted: training_sarcasm_4aa88349.jsonl\n", + "Deleted: validation_sarcasm_4aa88349.jsonl\n", + "Deleted: base_eval_4aa88349.jsonl\n", + "Deleted: ft_eval_4aa88349.jsonl\n", + "\n", + "✓ Cleanup complete\n" + ] + } + ], + "source": [ + "# Clean up local files\n", + "for f in [training_file_path, validation_file_path, base_eval_file, ft_eval_file]:\n", + " if os.path.exists(f):\n", + " os.remove(f)\n", + " print(f\"Deleted: {f}\")\n", + "\n", + "print(\"\\n✓ Cleanup complete\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.12.3)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 3abcec11a43ee264b5529604e7bdb9c9965e53bc Mon Sep 17 00:00:00 2001 From: Omkar M Date: Tue, 3 Feb 2026 05:44:14 +0000 Subject: [PATCH 2/2] Replace DistillingSarcasm with Foundry SDK version - Use azure-ai-projects SDK with DefaultAzureCredential (no API keys) - Use responses.create() API for inference - Simplified evals with normalized pass_threshold (0-1 scale) - Remove eval_utils.py (no longer needed) - Remove separate DistillingSarcasm_Foundry folder Changes: - sarcasm.ipynb: Complete rewrite using Foundry SDK - requirements.txt: azure-ai-projects, azure-identity - README.md: Updated documentation - .env.template: New config template - .gitignore: Updated patterns --- .../.env.template | 0 Demos/DistillingSarcasm/.gitignore | 7 +- Demos/DistillingSarcasm/README.md | 222 +- Demos/DistillingSarcasm/requirements.txt | 28 +- Demos/DistillingSarcasm/sarcasm.ipynb | 2263 ++++------------- Demos/DistillingSarcasm/scripts/eval_utils.py | 254 -- Demos/DistillingSarcasm_Foundry/.gitignore | 5 - Demos/DistillingSarcasm_Foundry/README.md | 152 -- .../requirements.txt | 19 - .../sarcasm_foundry.ipynb | 1056 -------- 10 files changed, 651 insertions(+), 3355 deletions(-) rename Demos/{DistillingSarcasm_Foundry => DistillingSarcasm}/.env.template (100%) delete mode 100644 Demos/DistillingSarcasm/scripts/eval_utils.py delete mode 100644 Demos/DistillingSarcasm_Foundry/.gitignore delete mode 100644 Demos/DistillingSarcasm_Foundry/README.md delete mode 100644 Demos/DistillingSarcasm_Foundry/requirements.txt delete mode 100644 Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb diff --git a/Demos/DistillingSarcasm_Foundry/.env.template b/Demos/DistillingSarcasm/.env.template similarity index 100% rename from Demos/DistillingSarcasm_Foundry/.env.template rename to Demos/DistillingSarcasm/.env.template diff --git a/Demos/DistillingSarcasm/.gitignore b/Demos/DistillingSarcasm/.gitignore index cc708a8..dc0f593 100644 --- a/Demos/DistillingSarcasm/.gitignore +++ b/Demos/DistillingSarcasm/.gitignore @@ -1,8 +1,11 @@ +__pycache__ +*.pyc +.ipynb_checkpoints/ +training_*.jsonl +validation_*.jsonl sarcasm-baseline-*.jsonl sarcasm-training-*.jsonl sarcasm-validation-*.jsonl sarcasm-posttraining-*.jsonl .env .venv -**/__pycache__ -__pycache__ \ No newline at end of file diff --git a/Demos/DistillingSarcasm/README.md b/Demos/DistillingSarcasm/README.md index a1d8bb6..cf0d904 100644 --- a/Demos/DistillingSarcasm/README.md +++ b/Demos/DistillingSarcasm/README.md @@ -1,126 +1,152 @@ -# Distilling Sarcasm -> or: "how to teach GPT-4.1-nano how to be sarcastic" +# Distilling Sarcasm - Foundry SDK Version -This is an end-to-end example of **distillation**: squeezing the behaviors of a -larger model into a smaller model. +This is an alternative implementation of the Sarcasm distillation demo using the **Azure AI Foundry SDK** instead of raw API keys. -## tl;dr +## Overview -1. Go spin up base model deployments for all models you want to work with. In - this notebook, I use o3, o4-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, - gpt-4o, and gpt-4o-mini. You might need TPM quota in your subscription. +This demo teaches language models to generate sarcastic responses through distillation: +1. A **teacher model** (gpt-4.1) generates sarcastic training data +2. A **student model** (gpt-4.1-mini) is fine-tuned on this data +3. Evaluators measure sarcasm quality before and after training -2. Create and populate a `.env` file to simplify stuff. In it, put some Azure - specific details: +## SDK Comparison -```properties -AZURE_OPENAI_ENDPOINT=https://.openai.azure.com -AZURE_OPENAI_API_KEY= -AZURE_SUBSCRIPTION_ID= -AZURE_RESOURCE_GROUP= -AZURE_AOAI_ACCOUNT= -``` +| Aspect | Original (API Key) | This Version (Foundry SDK) | +|--------|-------------------|---------------------------| +| **Package** | `openai` | `azure-ai-projects` + `openai` | +| **Auth** | API Key | `DefaultAzureCredential` | +| **Inference** | `client.chat.completions.create()` | `openai_client.chat.completions.create()` | +| **Evaluations** | `client.evals.*` | `openai_client.evals.*` (same!) | +| **Fine-tuning** | `client.fine_tuning.jobs.*` | `openai_client.fine_tuning.jobs.*` (same!) | -3. Wrangle the Python stuff. (See below.) +**Key Insight**: The APIs are nearly identical! The main difference is how you get the client: -``` -$ python3 -m venv .venv -$ . .venv/bin/activate -(venv) $ pip install -r requirements -``` +```python +# Original (API Key) +client = OpenAI(base_url=..., api_key=...) -Then launch this sucker in Jupyter notebooks. The easiest way is to fire it up -in **Visual Studio Code**: - -``` -$ code sarcasm.ipynb +# Foundry SDK +project_client = AIProjectClient(endpoint=..., credential=DefaultAzureCredential()) +openai_client = project_client.get_openai_client() # Same API from here! ``` -Happy distilling. 🧪 - -## Background -The basis for this demo is the Distillation [demo](https://github.com/azure-ai-foundry/build-2025-demos/blob/main/Azure%20AI%20Model%20Customization/DistillationDemo/demo.ipynb) -featured at Build 2025: - -And the [tutorial](https://learn.microsoft.com/en-us/azure/ai-services/openai/tutorials/fine-tune) -on fine-tuning gpt-4o with the prompt: -_Clippy is a factual chatbot that is also sarcastic._ - -## Grader -We use a crude grader that rewards two things: - -1. The amount of sarcasm from 1 (no sarcasm) to 10 (the most sarcasm) -2. Correct answers to the users questions. - -More importantly, it *heavily* penalizes wrong answers by driving the scores to -zero. In practice, I don't think I saw this happen, but it's a fun example. - -We leave it to **o3** to decide what we mean by sarcasm 😜 - -## Methodology -More will be written here, but at a high-level the approach takes a few steps. +## Prerequisites + +1. **Azure Subscription** with access to Azure AI Foundry +2. **Python 3.10+** +3. **Azure CLI** logged in (`az login`) + +## Setup + +1. Create and activate a virtual environment: + ```bash + python -m venv .venv + source .venv/bin/activate # Linux/Mac + # or: .venv\Scripts\activate # Windows + ``` + +2. Install dependencies: + ```bash + pip install -r requirements.txt + ``` + +3. Copy the environment template and fill in your values: + ```bash + cp .env.template .env + ``` + +4. Configure `.env`: + ``` + MICROSOFT_FOUNDRY_PROJECT_ENDPOINT=https://.services.ai.azure.com/api/projects/ + AZURE_INFERENCE_ENDPOINT=https://..models.ai.azure.com + AZURE_OPENAI_DEPLOYMENT=gpt-4.1 + AZURE_SUBSCRIPTION_ID= + AZURE_RESOURCE_GROUP= + AZURE_AOAI_ACCOUNT= + BASE_MODEL=gpt-4.1-mini + TEACHER_MODEL=gpt-4.1 + ``` + +## Running the Demo + +Open `sarcasm_foundry.ipynb` in Jupyter and execute cells in order: + +```bash +jupyter notebook sarcasm_foundry.ipynb +``` -For now, just read the [notebook](./sarcasm.ipynb) 😉 +## Key Differences from Original -### 0. Assemble Human Curated Data -We need something of a "gold standard." In this case, we use some pre-canned -examples from the Azure OpenAI docs. +### Authentication +```python +# Original (API Key) +client = OpenAI( + base_url=f"https://{resource}.openai.azure.com/openai/v1/", + api_key=os.environ.get("FOUNDRY_API_KEY"), +) -### 1. Build & Test our Grader -We assemble a Grader: a combination of model (o3) and a prompt. The prompt -tells the grader how to score other models' output. +# Foundry SDK (Azure Credential) +credential = DefaultAzureCredential() +project_client = AIProjectClient(endpoint=endpoint, credential=credential) +openai_client = project_client.get_openai_client() +``` -### 2. Benchmark our Base Models -We use the "gold standard" to check if our Grader is doing its job. If we can't -trust the grader, who can we trust? +### Inference +```python +# Original (OpenAI SDK) +response = client.chat.completions.create( + model="gpt-4.1", + messages=[{"role": "user", "content": "Hello"}] +) -### 3. Pick our Teacher and our Student -We then give an assignment to our base models (`o3`, `o4-mini`, `4.1-*`, -`4o-*`) and have the Grader decide on their scores. +# Foundry SDK (azure-ai-inference) +from azure.ai.inference import ChatCompletionsClient +from azure.ai.inference.models import UserMessage -We use these scores to determine which base model shows the most aptitude -for our use case. That model we pick as our Teacher. +client = ChatCompletionsClient(endpoint=..., credential=credential) +response = client.complete(messages=[UserMessage(content="Hello")]) +``` -We also figure out who our Student should be based on which model performs the -worst...yet might be much cheaper to use than our Teacher. (We're on a fixed -budget!) +### Evaluations (Same API!) +```python +# Both demos use identical evals API +eval = openai_client.evals.create(name="sarcasm-grader", ...) +run = openai_client.evals.runs.create(eval_id=eval.id, ...) +``` -### 4. Distill from the Teacher -We take the Teacher's answers to the questions and consider them what the -Student needs to learn. We turn them into our training data for fine-tuning. +### Trade-offs -### 5. Train our Student -The Student gets to work learning by studying the Teacher's output. +**Foundry SDK Advantages:** +- ✅ No API keys to manage (uses Azure managed identity) +- ✅ Better security with DefaultAzureCredential +- ✅ Consistent with other Azure AI services +- ✅ Unified project management -### 6. Test our Student against its Peer -Now, to keep things fair, we take _new_ data and ask the Student to generate -responses. We also ask its peer, the un-trained version of itself, to do the -same. We then compare the two. +**Original (API Key) Advantages:** +- ✅ Simpler setup (just one API key) +- ✅ Works outside Azure environments +- ✅ Familiar OpenAI SDK patterns -### 7. Celebrate or Cry -If our Student bests the Peer, we celebrate! Our job is done. +## Troubleshooting -If the Student is close enough to the Teacher, we ship it off to Production! +### Authentication Issues +- Ensure you're logged in: `az login` +- Check your role assignments include "Azure AI User" on the Foundry resource -## Troubleshooting +### Model Not Found +- Verify the model deployment names in your `.env` match your Azure deployments -### Common Issues +### Rate Limiting +- Reduce `sample_size` in evaluation cells if hitting rate limits -**Authentication Error** -- Run `az login` to refresh your Azure credentials -- Verify your Azure OpenAI endpoint and API key in `.env` -- Check that you have deployment access for all models (o3, o4-mini, gpt-4.1, etc.) +## Files -**Quota Exceeded** -- This demo uses multiple model deployments - ensure you have TPM quota for each -- Request additional quota in Azure Portal → Azure OpenAI → Quotas -- Try running with fewer models if quota is limited +- `sarcasm_foundry.ipynb` - Main notebook +- `requirements.txt` - Python dependencies +- `.env.template` - Environment variable template +- `README.md` - This file -**Model Not Available** -- Check regional availability for gpt-4.1-nano and other newer models -- Some models may require preview access - check Azure documentation +## Related -**Training Job Fails** -- Verify data format matches the expected JSONL schema -- Ensure training data doesn't exceed token limits -- Check that grader outputs are valid JSON +- [Original Sarcasm Demo](../DistillingSarcasm/) - Uses OpenAI SDK with API keys +- [CNN DailyMail Demo](../SFT_CNN_DailyMail/) - SFT example using Foundry SDK diff --git a/Demos/DistillingSarcasm/requirements.txt b/Demos/DistillingSarcasm/requirements.txt index 576bea1..677bc62 100644 --- a/Demos/DistillingSarcasm/requirements.txt +++ b/Demos/DistillingSarcasm/requirements.txt @@ -1,17 +1,19 @@ -# Core libraries -python-dotenv==0.21.0 # For loading environment variables from .env files +# Azure AI Foundry SDK +azure-ai-projects>=2.0.0b1 -# Data manipulation and visualization -pandas # For data manipulation and analysis -matplotlib # For creating visualizations -numpy # For numerical computations - -# Jupyter Notebook -notebook # For running Jupyter notebooks - -# OpenAI SDK -openai # For interacting with the OpenAI API +# Azure Authentication +azure-identity # Azure Cognitive Services for model deployment -azure-identity azure-mgmt-cognitiveservices + +# OpenAI SDK (obtained via Foundry client) +openai + +# Data manipulation and visualization +pandas +matplotlib +numpy + +# Core utilities +python-dotenv diff --git a/Demos/DistillingSarcasm/sarcasm.ipynb b/Demos/DistillingSarcasm/sarcasm.ipynb index 8b52a9e..ba2e25b 100644 --- a/Demos/DistillingSarcasm/sarcasm.ipynb +++ b/Demos/DistillingSarcasm/sarcasm.ipynb @@ -2,2180 +2,974 @@ "cells": [ { "cell_type": "markdown", - "id": "900d18b5", "metadata": {}, "source": [ - "# Distilling Sarcasm\n", - "> or: \"how to teach GPT-4.1-nano and Ministral-3B how to be sarcastic\"\n", + "# Distilling Sarcasm (Foundry SDK Version)\n", "\n", - "This is an end-to-end example of **distillation**: squeezing the behaviors of a\n", - "larger model into a smaller model.\n", + "This notebook demonstrates fine-tuning language models to generate sarcastic responses using the **Azure AI Foundry SDK**.\n", "\n", - "We're going to show how you can take an un-engineered prompt (`SYSTEM_PROMPT`)\n", - "as simple as:\n", + "## Comparison with Original Demo\n", "\n", - "> Clippy is a factual chatbot that is also sarcastic.\n", + "| Aspect | Original | Foundry SDK |\n", + "|--------|----------|-------------|\n", + "| Auth | API Key | DefaultAzureCredential |\n", + "| Inference | `client.chat.completions` | `openai_client.responses` |\n", + "| Evaluations | `client.evals.*` | `openai_client.evals.*` (same!) |\n", + "| Fine-tuning | `client.fine_tuning.jobs.*` | `openai_client.fine_tuning.jobs.*` (same!) |\n", "\n", - "...and basically go from zero to a fine-tuned model \n", - "*without having to generate your own training data!*\n", + "**Key Insight**: The APIs are nearly identical! The main difference is authentication:\n", + "- Original: `OpenAI(base_url=..., api_key=...)`\n", + "- Foundry: `AIProjectClient(endpoint, credential).get_openai_client()`\n", "\n", - "## Requirements\n", - "1. Go spin up base model deployments for all models you want to work with. In\n", - " this notebook, I use `o3-mini`, `gpt-4.1`, `gpt-4.1-mini`, `gpt-4.1-nano`, \n", - " `gpt-4o`, `gpt-4o-mini`, `Ministral-3B`, and `DeepSeek-V3.1`. (You may also \n", - " need TPM quota in your subscription.)\n", - "\n", - "2. Create and populate a `.env` file to simplify stuff. In it, put some Azure\n", - " specific details:\n", - "\n", - "```properties\n", - "FOUNDRY_PARENT_RESOURCE=\n", - "FOUNDRY_API_KEY=\n", - "AZURE_SUBSCRIPTION_ID=\n", - "AZURE_RESOURCE_GROUP=\n", - "```\n", - "\n", - "3. Depending on how you run this notebook, you may need to pre-install a\n", - " **Jupyter** environment. The `pip install` below will handle any other\n", - " dependencies for you." + "**Note**: Foundry project endpoints use `responses.create()` API for inference." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup" ] }, { "cell_type": "code", "execution_count": 1, - "id": "74193f85", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Requirement already satisfied: python-dotenv==0.21.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 2)) (0.21.0)\n", - "Requirement already satisfied: pandas in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 5)) (2.3.3)\n", - "Requirement already satisfied: matplotlib in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 6)) (3.10.7)\n", - "Requirement already satisfied: numpy in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 7)) (2.3.5)\n", - "Requirement already satisfied: notebook in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 10)) (7.5.0)\n", - "Requirement already satisfied: openai in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 13)) (2.9.0)\n", - "Requirement already satisfied: azure-identity in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 16)) (1.25.1)\n", - "Requirement already satisfied: azure-mgmt-cognitiveservices in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from -r requirements.txt (line 17)) (14.1.0)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from pandas->-r requirements.txt (line 5)) (2.9.0.post0)\n", - "Requirement already satisfied: pytz>=2020.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from pandas->-r requirements.txt (line 5)) (2025.2)\n", - "Requirement already satisfied: tzdata>=2022.7 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from pandas->-r requirements.txt (line 5)) (2025.2)\n", - "Requirement already satisfied: contourpy>=1.0.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (1.3.3)\n", - "Requirement already satisfied: cycler>=0.10 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (4.61.0)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (1.4.9)\n", - "Requirement already satisfied: packaging>=20.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (25.0)\n", - "Requirement already satisfied: pillow>=8 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (12.0.0)\n", - "Requirement already satisfied: pyparsing>=3 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from matplotlib->-r requirements.txt (line 6)) (3.2.5)\n", - "Requirement already satisfied: jupyter-server<3,>=2.4.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from notebook->-r requirements.txt (line 10)) (2.17.0)\n", - "Requirement already satisfied: jupyterlab-server<3,>=2.28.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from notebook->-r requirements.txt (line 10)) (2.28.0)\n", - "Requirement already satisfied: jupyterlab<4.6,>=4.5.0rc0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from notebook->-r requirements.txt (line 10)) (4.5.0)\n", - "Requirement already satisfied: notebook-shim<0.3,>=0.2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from notebook->-r requirements.txt (line 10)) (0.2.4)\n", - "Requirement already satisfied: tornado>=6.2.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from notebook->-r requirements.txt (line 10)) (6.5.2)\n", - "Requirement already satisfied: anyio>=3.1.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (4.12.0)\n", - "Requirement already satisfied: argon2-cffi>=21.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (25.1.0)\n", - "Requirement already satisfied: jinja2>=3.0.3 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (3.1.6)\n", - "Requirement already satisfied: jupyter-client>=7.4.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (8.7.0)\n", - "Requirement already satisfied: jupyter-core!=5.0.*,>=4.12 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (5.9.1)\n", - "Requirement already satisfied: jupyter-events>=0.11.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.12.0)\n", - "Requirement already satisfied: jupyter-server-terminals>=0.4.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.5.3)\n", - "Requirement already satisfied: nbconvert>=6.4.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (7.16.6)\n", - "Requirement already satisfied: nbformat>=5.3.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (5.10.4)\n", - "Requirement already satisfied: prometheus-client>=0.9 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.23.1)\n", - "Requirement already satisfied: pywinpty>=2.0.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (3.0.2)\n", - "Requirement already satisfied: pyzmq>=24 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (27.1.0)\n", - "Requirement already satisfied: send2trash>=1.8.2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.8.3)\n", - "Requirement already satisfied: terminado>=0.8.3 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.18.1)\n", - "Requirement already satisfied: traitlets>=5.6.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (5.14.3)\n", - "Requirement already satisfied: websocket-client>=1.7 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.9.0)\n", - "Requirement already satisfied: async-lru>=1.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (2.0.5)\n", - "Requirement already satisfied: httpx<1,>=0.25.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.28.1)\n", - "Requirement already satisfied: ipykernel!=6.30.0,>=6.5.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (7.1.0)\n", - "Requirement already satisfied: jupyter-lsp>=2.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (2.3.0)\n", - "Requirement already satisfied: setuptools>=41.1.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (80.9.0)\n", - "Requirement already satisfied: certifi in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from httpx<1,>=0.25.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (2025.11.12)\n", - "Requirement already satisfied: httpcore==1.* in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from httpx<1,>=0.25.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (1.0.9)\n", - "Requirement already satisfied: idna in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from httpx<1,>=0.25.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (3.11)\n", - "Requirement already satisfied: h11>=0.16 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from httpcore==1.*->httpx<1,>=0.25.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.16.0)\n", - "Requirement already satisfied: babel>=2.10 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (2.17.0)\n", - "Requirement already satisfied: json5>=0.9.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (0.12.1)\n", - "Requirement already satisfied: jsonschema>=4.18.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (4.25.1)\n", - "Requirement already satisfied: requests>=2.31 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (2.32.5)\n", - "Requirement already satisfied: distro<2,>=1.7.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from openai->-r requirements.txt (line 13)) (1.9.0)\n", - "Requirement already satisfied: jiter<1,>=0.10.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from openai->-r requirements.txt (line 13)) (0.12.0)\n", - "Requirement already satisfied: pydantic<3,>=1.9.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from openai->-r requirements.txt (line 13)) (2.12.5)\n", - "Requirement already satisfied: sniffio in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from openai->-r requirements.txt (line 13)) (1.3.1)\n", - "Requirement already satisfied: tqdm>4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from openai->-r requirements.txt (line 13)) (4.67.1)\n", - "Requirement already satisfied: typing-extensions<5,>=4.11 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from openai->-r requirements.txt (line 13)) (4.15.0)\n", - "Requirement already satisfied: annotated-types>=0.6.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from pydantic<3,>=1.9.0->openai->-r requirements.txt (line 13)) (0.7.0)\n", - "Requirement already satisfied: pydantic-core==2.41.5 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from pydantic<3,>=1.9.0->openai->-r requirements.txt (line 13)) (2.41.5)\n", - "Requirement already satisfied: typing-inspection>=0.4.2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from pydantic<3,>=1.9.0->openai->-r requirements.txt (line 13)) (0.4.2)\n", - "Requirement already satisfied: azure-core>=1.31.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from azure-identity->-r requirements.txt (line 16)) (1.36.0)\n", - "Requirement already satisfied: cryptography>=2.5 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from azure-identity->-r requirements.txt (line 16)) (46.0.3)\n", - "Requirement already satisfied: msal>=1.30.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from azure-identity->-r requirements.txt (line 16)) (1.34.0)\n", - "Requirement already satisfied: msal-extensions>=1.2.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from azure-identity->-r requirements.txt (line 16)) (1.3.1)\n", - "Requirement already satisfied: msrest>=0.7.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from azure-mgmt-cognitiveservices->-r requirements.txt (line 17)) (0.7.1)\n", - "Requirement already satisfied: azure-mgmt-core>=1.6.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from azure-mgmt-cognitiveservices->-r requirements.txt (line 17)) (1.6.0)\n", - "Requirement already satisfied: argon2-cffi-bindings in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from argon2-cffi>=21.1->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (25.1.0)\n", - "Requirement already satisfied: cffi>=2.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from cryptography>=2.5->azure-identity->-r requirements.txt (line 16)) (2.0.0)\n", - "Requirement already satisfied: pycparser in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from cffi>=2.0.0->cryptography>=2.5->azure-identity->-r requirements.txt (line 16)) (2.23)\n", - "Requirement already satisfied: comm>=0.1.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.2.3)\n", - "Requirement already satisfied: debugpy>=1.6.5 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (1.8.17)\n", - "Requirement already satisfied: ipython>=7.23.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (9.8.0)\n", - "Requirement already satisfied: matplotlib-inline>=0.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.2.1)\n", - "Requirement already satisfied: nest-asyncio>=1.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (1.6.0)\n", - "Requirement already satisfied: psutil>=5.7 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (7.1.3)\n", - "Requirement already satisfied: colorama>=0.4.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.4.6)\n", - "Requirement already satisfied: decorator>=4.3.2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (5.2.1)\n", - "Requirement already satisfied: ipython-pygments-lexers>=1.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (1.1.1)\n", - "Requirement already satisfied: jedi>=0.18.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.19.2)\n", - "Requirement already satisfied: prompt_toolkit<3.1.0,>=3.0.41 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (3.0.52)\n", - "Requirement already satisfied: pygments>=2.11.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (2.19.2)\n", - "Requirement already satisfied: stack_data>=0.6.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.6.3)\n", - "Requirement already satisfied: wcwidth in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from prompt_toolkit<3.1.0,>=3.0.41->ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.2.14)\n", - "Requirement already satisfied: parso<0.9.0,>=0.8.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jedi>=0.18.1->ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.8.5)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jinja2>=3.0.3->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (3.0.3)\n", - "Requirement already satisfied: attrs>=22.2.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (25.4.0)\n", - "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (2025.9.1)\n", - "Requirement already satisfied: referencing>=0.28.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (0.37.0)\n", - "Requirement already satisfied: rpds-py>=0.7.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (0.30.0)\n", - "Requirement already satisfied: platformdirs>=2.5 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-core!=5.0.*,>=4.12->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (4.5.1)\n", - "Requirement already satisfied: python-json-logger>=2.0.4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (4.0.0)\n", - "Requirement already satisfied: pyyaml>=5.3 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (6.0.3)\n", - "Requirement already satisfied: rfc3339-validator in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.1.4)\n", - "Requirement already satisfied: rfc3986-validator>=0.1.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.1.1)\n", - "Requirement already satisfied: fqdn in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.5.1)\n", - "Requirement already satisfied: isoduration in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (20.11.0)\n", - "Requirement already satisfied: jsonpointer>1.13 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (3.0.0)\n", - "Requirement already satisfied: rfc3987-syntax>=1.1.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.1.0)\n", - "Requirement already satisfied: uri-template in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.3.0)\n", - "Requirement already satisfied: webcolors>=24.6.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (25.10.0)\n", - "Requirement already satisfied: PyJWT<3,>=1.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from PyJWT[crypto]<3,>=1.0.0->msal>=1.30.0->azure-identity->-r requirements.txt (line 16)) (2.10.1)\n", - "Requirement already satisfied: charset_normalizer<4,>=2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from requests>=2.31->jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (3.4.4)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from requests>=2.31->jupyterlab-server<3,>=2.28.0->notebook->-r requirements.txt (line 10)) (2.6.1)\n", - "Requirement already satisfied: isodate>=0.6.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from msrest>=0.7.1->azure-mgmt-cognitiveservices->-r requirements.txt (line 17)) (0.7.2)\n", - "Requirement already satisfied: requests-oauthlib>=0.5.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from msrest>=0.7.1->azure-mgmt-cognitiveservices->-r requirements.txt (line 17)) (2.0.0)\n", - "Requirement already satisfied: beautifulsoup4 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (4.14.3)\n", - "Requirement already satisfied: bleach!=5.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from bleach[css]!=5.0.0->nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (6.3.0)\n", - "Requirement already satisfied: defusedxml in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.7.1)\n", - "Requirement already satisfied: jupyterlab-pygments in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.3.0)\n", - "Requirement already satisfied: mistune<4,>=2.0.3 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (3.1.4)\n", - "Requirement already satisfied: nbclient>=0.5.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.10.2)\n", - "Requirement already satisfied: pandocfilters>=1.4.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.5.1)\n", - "Requirement already satisfied: webencodings in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from bleach!=5.0.0->bleach[css]!=5.0.0->nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (0.5.1)\n", - "Requirement already satisfied: tinycss2<1.5,>=1.1.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from bleach[css]!=5.0.0->nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.4.0)\n", - "Requirement already satisfied: fastjsonschema>=2.15 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from nbformat>=5.3.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (2.21.2)\n", - "Requirement already satisfied: six>=1.5 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from python-dateutil>=2.8.2->pandas->-r requirements.txt (line 5)) (1.17.0)\n", - "Requirement already satisfied: oauthlib>=3.0.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from requests-oauthlib>=0.5.0->msrest>=0.7.1->azure-mgmt-cognitiveservices->-r requirements.txt (line 17)) (3.3.1)\n", - "Requirement already satisfied: lark>=1.2.2 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from rfc3987-syntax>=1.1.0->jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.3.1)\n", - "Requirement already satisfied: executing>=1.2.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from stack_data>=0.6.0->ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (2.2.1)\n", - "Requirement already satisfied: asttokens>=2.1.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from stack_data>=0.6.0->ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (3.0.1)\n", - "Requirement already satisfied: pure-eval in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from stack_data>=0.6.0->ipython>=7.23.1->ipykernel!=6.30.0,>=6.5.0->jupyterlab<4.6,>=4.5.0rc0->notebook->-r requirements.txt (line 10)) (0.2.3)\n", - "Requirement already satisfied: soupsieve>=1.6.1 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from beautifulsoup4->nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (2.8)\n", - "Requirement already satisfied: arrow>=0.15.0 in c:\\users\\davevoutila\\src\\fine-tuning\\demos\\distillingsarcasm\\.venv\\lib\\site-packages (from isoduration->jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.11.0->jupyter-server<3,>=2.4.0->notebook->-r requirements.txt (line 10)) (1.4.0)\n", "Note: you may need to restart the kernel to use updated packages.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "[notice] A new release of pip is available: 25.2 -> 25.3\n", - "[notice] To update, run: python.exe -m pip install --upgrade pip\n" - ] } ], "source": [ - "%pip install -r requirements.txt" - ] - }, - { - "cell_type": "markdown", - "id": "ff847b25", - "metadata": {}, - "source": [ - "## Environment Setup\n", - "First things first: we need an **Azure OpenAI** client instance." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4912ccdc", - "metadata": {}, - "outputs": [], - "source": [ - "from openai import OpenAI\n", - "from dotenv import load_dotenv\n", - "import os\n", - "\n", - "load_dotenv(override=True)\n", - "\n", - "client = OpenAI(\n", - " base_url=f\"https://{os.environ.get('FOUNDRY_PARENT_RESOURCE')}.openai.azure.com/openai/v1/\",\n", - " api_key=os.environ.get(\"FOUNDRY_API_KEY\"),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "19bfcc21", - "metadata": {}, - "source": [ - "We also want to keep an entire experiment run easily identifiable. A few bits of\n", - "randomness should be enough, so just generate a UUID and chop off its head 🪓." + "%pip install -r requirements.txt -q" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "53f86c4a", - "metadata": {}, - "outputs": [], - "source": [ - "# We'll create a \"unique enough\" identifier that lets us run this notebook\n", - "# multiple times and easily keep track of things each run creates.\n", - "import uuid\n", - "UNIQUE_ENOUGH_KEY = str(uuid.uuid4()).split(\"-\")[0]" - ] - }, - { - "cell_type": "markdown", - "id": "c3b55aff", - "metadata": {}, - "source": [ - "## 0. Assembling Human Curated Data\n", - "We need a *gold standard* sample, not to train our model on, but to measure\n", - "the efficacy of our grader.\n", - "\n", - "We'll use some pre-canned sarcasm examples from the **Azure OpenAI** tutorial\n", - "on [fine-tuning a GPT model](https://learn.microsoft.com/en-us/azure/ai-services/openai/tutorials/fine-tune?tabs=command-line).\n", - "\n", - "The [baseline.jsonl](./baseline.jsonl) file contains the prompts from that\n", - "tutorial, but decomposed into a simple format of question/answer pairs." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "dd7ffbc9", + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'question': 'Who discovered Antarctica?', 'answer': \"Some chaps named Fabian Gottlieb von Bellingshausen and Mikhail Lazarev, as if they don't teach that in every school!\"}\n", - "{'question': 'What is the biggest ocean?', 'answer': \"The Pacific Ocean. It's not like it's a small pond or anything.\"}\n", - "{'question': 'What is the largest planet?', 'answer': \"It's called Jupiter, you might have heard of it...or not.\"}\n" + "Libraries imported successfully\n" ] } ], "source": [ - "# Peek at our baseline *gold standard* dataset.\n", + "import os\n", "import json\n", + "import uuid\n", + "import time\n", + "from random import shuffle\n", "\n", - "rows = 0\n", - "with open(\"./baseline.jsonl\", \"r\") as f:\n", - " for line in f.readlines():\n", - " print(json.loads(line))\n", - " rows += 1\n", - " if rows >= 3:\n", - " break" - ] - }, - { - "cell_type": "markdown", - "id": "72852df2", - "metadata": {}, - "source": [ - "## 1. Grading the Grader\n", - "The Grader is the lynchpin here, so it *must* be effective. \n", - "\n", - "Specifically, we'll use a **Score Model Grader** (aka `score_model` via the API).\n", - "It's job is to take a *prompt* and use it to derive a numeric *score*. We define\n", - "to decide if the score is \"passing\" or \"failing\", which we'll use as a simple\n", - "signal of quality.\n", - "\n", - "> ℹ️ **Aside: Garbage In, Garbage Out**\n", - "> If you cannot explain to a reasoning model like `o3-mini` how to identify high \n", - "> and low quality responses based on your objective, you have a *shaky foundation*\n", - "> from which to build upon.\n", - ">\n", - "> But keep in mind, `o3-mini` is a *reasoning* model. You do *not* need to give it\n", - "> fine-grained instructions, but you should give it a *clear objective*.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "778440a4", - "metadata": {}, - "source": [ - "### 📃 Preparing our first Evaluation\n", - "We'll start with the definition of the prompt for our grader (`GRADER_PROMPT`).\n", - "\n", - "Things to note about this prompt:\n", - "- We let the grader know how we want it to behave, in this case as a sarcasm\n", - " detector and fact checker.\n", - "- We inform it of what the input data looks like.\n", - "- We give it a rubrik for scoring each input.\n", - "- We give it a clear schema for its output to match what a Score Model Grader\n", - " must output for the Evaluation system to interpret.\n", - "\n", - "And that's it. In this case, we don't need examples, we rely on the reasoning\n", - "model to decide how to interpret sarcasm, etc." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "eb62b687", - "metadata": {}, - "outputs": [], - "source": [ - "# We'll use the most capable reasoning model as our grader.\n", - "GRADER_MODEL = \"o3-mini\"\n", - "\n", - "# A simple score grader that quantifies sarcasm while accounting for accuracy\n", - "# of the model's response. We want the model to answer the question *correctly*\n", - "# while adjusting their tone. Incorrect answers are heavily penalized.\n", - "GRADER_PROMPT = \"\"\"\n", - "You are an expert in sarcasm detection, while also being a good fact checker.\n", - "\n", - "You'll be given a conversation in the form of a question and answer. \n", - "\n", - "## Scoring Criteria\n", - "Judge the answer using two metrics.\n", - "\n", - "### Metric 1: How sarcastic is the response?\n", - "On a scale from 1 to 10 inclusive with 1 being no sarcasm detected and 10 being\n", - "the most sarcastic response ever, assign an integer value within that range based\n", - "on your assessment.\n", - "\n", - "### Metric 2: How accurate is the response?\n", - "Assign a 1 if the response is factually correct. Assign a 0 for this metric if it's\n", - "incorrect or contains innacuracies.\n", - "\n", - "### Final Score\n", - "The final score you must decide should be based on a weighted blend of Metric 1 and\n", - "Metric 2 using the formula: `(Metric 1) * (Metric 2)`\n", - "\n", - "This means that if Metric 2 is zero, the final score must be zero.\n", - "\n", - "## Response Structure\n", - "Your response must be in a JSON format that can be loaded by Python's json.loads()\n", - "function. It must resemble the following:\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "\n", - "```\n", - "{\n", - " \"steps\": [\n", - " { \n", - " \"description\": \", \n", - " \"result\": \n", - " },\n", - " { \n", - " \"description\": \", \n", - " \"result\": \n", - " }\n", - " ],\n", - " \"result\": \n", - "}\n", + "from dotenv import load_dotenv\n", + "from azure.identity import DefaultAzureCredential\n", + "from azure.ai.projects import AIProjectClient\n", "\n", - "## General Guidance\n", - "The questions should be simple factual questions with clear answers. Deep research is\n", - "not required.\n", - "```\n", - "\"\"\"" + "print(\"Libraries imported successfully\")" ] }, { "cell_type": "markdown", - "id": "da8ae533", "metadata": {}, "source": [ - "Now we need to stage our baseline data in the Azure OpenAI service so the grader can\n", - "access and score each input.\n", - "\n", - "Using the SDK, it's a simple file upload, but with a purpose of `evals`.\n", - "\n", - "A file used for `evals` ideally is in JSONL format, but does **not** need to be in a\n", - "chat completions format. We can just use that `{ \"question\": \"?\", \"answer\": \"...\" }`\n", - "format from our baseline file without any further data engineering.\n" + "## 2. Connect to Microsoft Foundry" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "7f6b9289", + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Created eval file:\n", - "{\n", - " \"id\": \"file-8ce13f288b2d444eaed9fb0ff8ac15da\",\n", - " \"bytes\": 2510,\n", - " \"created_at\": 1765377018,\n", - " \"filename\": \"baseline.jsonl\",\n", - " \"object\": \"file\",\n", - " \"purpose\": \"evals\",\n", - " \"status\": \"processed\"\n", - "}\n" + "Run identifier: 4aa88349\n", + "Project: https://omi-ignite-demo-resource.services.ai.azure.com/api/projects/omi-ignite-demo\n" ] } ], "source": [ - "# We're going to first evaluate our grader using a human-curated dataset.\n", - "# In this case, these are the examples from our fine-tuning tutorial. Let's pretend\n", - "# we know what the scores for these _should_ be.\n", - "grader_eval_file = None\n", - "with open(\"./baseline.jsonl\", \"rb\") as f:\n", - " grader_eval_file = client.files.create(purpose=\"evals\", file=f)\n", - " grader_eval_file = client.files.wait_for_processing(grader_eval_file.id)\n", - "\n", - "print(f\"Created eval file:\\n{grader_eval_file.to_json(indent=2)}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "4f9d3404", - "metadata": {}, - "source": [ - "### 🏗️ Constructing the Grader\n", - "For evaluating the grader, we'll be giving it pre-canned prompts for it to score.\n", - "\n", - "To do this, we have to provide some templating:\n", - "\n", - "1. We give the system a template (`INPUT`) to plug in data from our baseline\n", - " jsonl to construct a ficticious prompt from a model.\n", - "2. We provide a schema to describe the shape of our test data (the baseline file)\n", - " in `SCHEMA`.\n", - "3. Lastly, we define the testing criteria (`TESTING_CRITERIA`) which takes our\n", - " prompt template (`INPUT`), the name of our grader model (in Azure OpenAI, this\n", - " is the _deployment name_ of the model to use), and the scoring details.\n", - "\n", - "This is a lot of data, so it's important to take a moment and wrap your head around\n", - "this stuff. Remember, this is the _simple_ version of a Score Model Grader! Simple\n", - "being we're not generating prompts, we're just using a data file to populate a\n", - "template.\n", - "\n", - "So, for example, if we have a row from `baseline.jsonl` that looks like:\n", - "\n", - "```json\n", - "{ \"question\": \"Who spilled coffee on their desk today?\", \"answer\": \"Dave\" }\n", - "```\n", - "\n", - "The _actual_ prompt that will be shown to the _grader_ will be:\n", - "\n", - "```json\n", - "[\n", - " { \"role\": \"system\", \"content\": \"You are an expert in sarcasm detection,...\" },\n", - " { \"role\": \"user\", \"content\": \"\\nQ: Who spilled coffee on their desk today?\\nA: Dave\\n\" }\n", - "]\n", - "```\n", - "\n", - "> ℹ️ Once you know how to reason about this yourself, you can use something like the\n", - "> Azure OpenAI Chat Playground to manually test your grader! Just set the system\n", - "> prompt to your grader prompt and then provide the _user_ content like in the\n", - "> example above." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "03a6cbf7", - "metadata": {}, - "outputs": [], - "source": [ - "# Now we define our Evaluation for validating our choice in grader prompt and model.\n", - "\n", - "# The entire user prompt is data driven from the file. No generation is done using\n", - "# a model in this case, just simple string substitution using this pattern. This\n", - "# means we directly reference the two fields in our baseline.jsonl file.\n", - "USER_PROMPT = \"\"\"\n", - "Q: {{item.question}}\n", - "A: {{item.answer}}\n", - "\"\"\"\n", - "INPUT = [\n", - " {\n", - " \"type\": \"message\",\n", - " \"role\": \"system\",\n", - " \"content\": { \"type\": \"input_text\", \"text\": GRADER_PROMPT }\n", - " },\n", - " {\n", - " \"type\": \"message\",\n", - " \"role\": \"user\",\n", - " \"content\": { \"type\": \"input_text\", \"text\": USER_PROMPT }\n", - " }\n", - "]\n", + "load_dotenv(override=True)\n", "\n", - "# We need to describe what our evaluation dataset looks like.\n", - "SCHEMA = {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"question\": { \"type\": \"string\" },\n", - " \"answer\": { \"type\": \"string\" },\n", - " }\n", - "}\n", - "DATA_SOURCE = {\n", - " \"item_schema\": SCHEMA,\n", - " \"include_sample_schema\": False,\n", - " \"type\": \"custom\",\n", - "}\n", + "# Required for Azure OpenAI client\n", + "os.environ.setdefault(\"OPENAI_API_VERSION\", \"2025-03-01-preview\")\n", "\n", - "# Lastly, we define test criteria that combines all the above.\n", - "TESTING_CRITERIA = {\n", - " \"name\": \"Auto Sarcasm Grader\",\n", - " \"type\": \"score_model\",\n", - " \"model\": GRADER_MODEL,\n", - " \"input\": INPUT,\n", - " \"range\": [1.0, 10.0], # Our grader scores in a range from 1 to 10\n", - " \"pass_threshold\": 4.0, # Let's say a 4 is \"passing\" for now.\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "19368669", - "metadata": {}, - "source": [ - "### 👨‍🔬 Putting it together into an Evaluation\n", - "We have our data source defined (`DATA_SOURCE`) and our testing criteria that defines\n", - "our grader (`TESTING_CRITERIA`). Now we have what we need to construct an Evaluation.\n", + "project_endpoint = os.environ.get(\"MICROSOFT_FOUNDRY_PROJECT_ENDPOINT\")\n", + "model_deployment = os.environ.get(\"AZURE_OPENAI_DEPLOYMENT\", \"gpt-4.1\")\n", + "base_model = os.environ.get(\"BASE_MODEL\", \"gpt-4.1-mini\")\n", + "teacher_model = os.environ.get(\"TEACHER_MODEL\", \"gpt-4.1\")\n", "\n", - "> An evaluation can contain multiple testing criteria (i.e. graders), but in our case\n", - "> we just use the one above. Just a heads up on why we're giving it a list here.\n" + "UNIQUE_KEY = str(uuid.uuid4()).split(\"-\")[0]\n", + "print(f\"Run identifier: {UNIQUE_KEY}\")\n", + "print(f\"Project: {project_endpoint}\")" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "2d0a7eb6", + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "⚖️ Submitted grader evaluation eval_693983fb81d08191b12b619b470c8b19.\n" + "✓ Connected to Microsoft Foundry\n" ] } ], "source": [ - "# We've set up the parameters for our Eval, now we create it via the API.\n", - "grader_eval = client.evals.create(\n", - " name=f\"sarcasm-grader-{UNIQUE_ENOUGH_KEY}\",\n", - " data_source_config=DATA_SOURCE,\n", - " testing_criteria=[TESTING_CRITERIA],\n", - ")\n", + "# Create clients - this is the KEY difference from original demo\n", + "credential = DefaultAzureCredential()\n", + "project_client = AIProjectClient(endpoint=project_endpoint, credential=credential)\n", + "openai_client = project_client.get_openai_client()\n", "\n", - "print(f\"⚖️ Submitted grader evaluation {grader_eval.id}.\")\n" + "print(\"✓ Connected to Microsoft Foundry\")" ] }, { "cell_type": "markdown", - "id": "48ef0227", "metadata": {}, "source": [ - "Oddly, we're **not done!** \n", - "\n", - "We defined the Evaluation, but each Evaluation needs a test Run. The Evaluation defines\n", - "the general terms, testing criteria, etc., but since we might want to vary some test\n", - "parameters, we actually need a **Run** to get anything done.\n", - "\n", - "Astute readers may have noticed that _we never specified we want to use baseline.jsonl._\n", - "\n", - "At the Run-level, we provide the specific test file. This lets you separate out the\n", - "schema definition of a test file from the data itself, so if you had multiple files\n", - "you wanted to test, you could create multiple runs.\n", - "\n", - "We define `RUN_DATA_SOURCE` below to specify, by _file id_ which file we want this Run\n", - "to use for data driving our test." + "## 3. Load Baseline Data" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "a0b6954a", + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🏃‍➡️ Submitted run evalrun_693983fc25c08191a6718033cc66a6d7 for eval_693983fb81d08191b12b619b470c8b19.\n" + "Loaded 20 baseline examples\n", + "\n", + "Sample:\n", + "Q: Who discovered Antarctica?\n", + "A: Some chaps named Fabian Gottlieb von Bellingshausen and Mikhail Lazarev, as if they don't teach that in every school!\n" ] } ], "source": [ - "# Our evaluation needs a test run. This is where we let it know to use our\n", - "# \"gold standard\" file (baseline.jsonl) to test our grader.\n", - "RUN_DATA_SOURCE = {\n", - " \"type\": \"jsonl\",\n", - " \"source\": { \"type\": \"file_id\", \"id\": grader_eval_file.id }\n", - "}\n", - "grader_run = client.evals.runs.create(\n", - " name=GRADER_MODEL,\n", - " eval_id=grader_eval.id,\n", - " data_source=RUN_DATA_SOURCE,\n", - ")\n", - "print(f\"🏃‍➡️ Submitted run {grader_run.id} for {grader_eval.id}.\")" + "baseline_data = []\n", + "with open(\"baseline.jsonl\", \"r\") as f:\n", + " for line in f:\n", + " baseline_data.append(json.loads(line))\n", + "\n", + "print(f\"Loaded {len(baseline_data)} baseline examples\")\n", + "print(f\"\\nSample:\")\n", + "print(f\"Q: {baseline_data[0]['question']}\")\n", + "print(f\"A: {baseline_data[0]['answer']}\")" ] }, { "cell_type": "markdown", - "id": "5018b01b", "metadata": {}, "source": [ - "Nothing is instaneous in life, including Evals. Let's wait for our Run to complete.\n", - "\n", - "We can do this by polling the status of the Run itself. (Note: we don't poll the Eval.)" + "## 4. Define Sarcasm Grader" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "080dd428", + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "⏱️ Elapsed time: 0 minutes 23 seconds\n", - "🏁 Run evalrun_693983fc25c08191a6718033cc66a6d7: completed!\n" + "Grader prompt defined\n" ] } ], "source": [ - "# An Eval Run takes time to complete. Let's actively wait for it to finish before continuing.\n", - "from IPython.display import clear_output\n", - "import time\n", - "\n", - "start_time = time.time()\n", - "\n", - "grader_run = client.evals.runs.retrieve(eval_id=grader_eval.id, run_id=grader_run.id)\n", - "while grader_run.status not in [\"completed\", \"failed\"]:\n", - " time.sleep(5)\n", - " clear_output(wait=True)\n", + "GRADER_PROMPT = \"\"\"\n", + "You are a connoisseur of finely crafted sarcasm. Your job is to evaluate a\n", + "question and answer pair and score it based on how sarcastic the answer is.\n", + "\n", + "# Guidelines\n", + " * Output ONLY a score.\n", + " * A score of 0 means the answer is not sarcastic at all.\n", + " * A score of 5 means the answer is moderately sarcastic.\n", + " * A score of 10 means the answer is dripping with sarcasm.\n", + "\n", + "# Scoring Features\n", + " * Exaggeration or overstatement of the obvious\n", + " * Rhetorical questions that mock the original question\n", + " * Use of phrases like \"Oh really?\", \"Shocking!\", \"Who knew?\"\n", + " * Intentional understatement for comedic effect\n", + " * Irony where literal meaning differs from intended meaning\n", + " * The answer must still be factually correct\n", + "\n", + "# Output Format\n", + "Provide ONLY a single decimal number between 0 and 1.\n", + "\"\"\"\n", "\n", - " grader_run = client.evals.runs.retrieve(eval_id=grader_eval.id, run_id=grader_run.id)\n", - " now = time.time()\n", - " mins, secs = int((now - start_time) // 60), int((now - start_time) % 60)\n", - " print(f\"⏱️ Elapsed time: {mins} minutes {secs} seconds\")\n", + "USER_PROMPT = \"\"\"\n", + "Q: {{item.question}}\n", + "A: {{item.answer}}\n", + "\"\"\"\n", "\n", - "print(f\"🏁 Run {grader_run.id}: {grader_run.status}!\")" + "print(\"Grader prompt defined\")" ] }, { "cell_type": "markdown", - "id": "08693c42", "metadata": {}, "source": [ - "### 📊 Viewing and Interpreting Results\n", - "Our Run completed...so now what?\n", - "\n", - "You can view the results in Azure AI Foundry, or stay in the comfort of this\n", - "notebook 😉. Let's stay in the notebook.\n", - "\n", - "There's a help script provided for rendering the results of all Runs for a given\n", - "list of Evaluations. It will render two things:\n", - "\n", - "1. The pass percentage of each Run (i.e. % of prompts scoring above our provided\n", - " pass threshold).\n", - "2. A histogram of individual scores from a Run letting us see how the score\n", - " distribution looks to see if we're generating excellent (well-above passing)\n", - " results or just barely passing. (_\"C's get degrees,\"_ as they say! 😜)" + "## 5. Create Evaluation (Same API as Original!)" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "bd72521a", + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Get Evaluation Runs: eval_693983fb81d08191b12b619b470c8b19\n", - "\n", - "==================================================\n", - "Combined Evaluation Summary\n", - "==================================================\n", - " Run ID Run Name Model Status Pass Percentage (%) Error Percentage (%) Evaluation ID Evaluation Name\n", - "evalrun_693983fc25c08191a6718033cc66a6d7 o3-mini None completed 90.0 0.0 eval_693983fb81d08191b12b619b470c8b19 sarcasm-grader-90f2f57b\n", - "==================================================\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==================================================\n", - "Fetching scores...\n", - "==================================================\n", - "\n", - "==================================================\n", - "Score Summary Table:\n", - "Model Evaluation Name Average Score Min Score Max Score 10th Percentile 25th Percentile 50th Percentile 75th Percentile 90th Percentile\n", - " None sarcasm-grader-90f2f57b 6.25 3.00 8.00 3.90 4.75 7.00 8.00 8.00\n", - "==================================================\n" + "✓ Eval file: file-185f7d1d42464c4f91996a2442505ccb\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "# We've got a handy script for rendering the results from an Evaluations Runs. Let's\n", - "# eyeball this stuff. It uses the Evals API to retrieve the scores and plot them.\n", - "from scripts.eval_utils import display_evaluation_summary\n", + "# Upload baseline for evaluation\n", + "with open(\"baseline.jsonl\", \"rb\") as f:\n", + " grader_eval_file = openai_client.files.create(purpose=\"evals\", file=f)\n", + " grader_eval_file = openai_client.files.wait_for_processing(grader_eval_file.id)\n", "\n", - "display_evaluation_summary(client, [grader_eval.id], x_range=(0, 10))\n", - "\n", - "# We should see that our grader generally thinks our \"gold standard\" is pretty\n", - "# sarcastic. This is where we'd iterate on tuning the grader, making sure we\n", - "# clearly capture features for it to score, etc. We're keeping it simple for now." - ] - }, - { - "cell_type": "markdown", - "id": "457d1a5f", - "metadata": {}, - "source": [ - "### 🤔 So how's it looking?\n", - "Ok! Not bad if we consider our *gold standard* data as generally \"good\" quality\n", - "sarcasm. The Grader thinks these are decent examples with nothing below a `2.0` in\n", - "this case and with the *p90* score being `6.0` (this varies with each run of the\n", - "notebook, but it tends to land around here)." - ] - }, - { - "cell_type": "markdown", - "id": "1b84f91b", - "metadata": {}, - "source": [ - "## 2. Baseline Testing of our Base Models\n", - "At this point we've done two things (hopefully!):\n", - "\n", - "1. Developed a Grader we feel is fit for our task.\n", - "2. Learned how to construct and submit an Eval and Run.\n", - "\n", - "> ℹ️ If you aren't confident in (2), this is a good time to go re-read the above.\n", - "\n", - "### Generating our Dataset\n", - "The real beauty of this type of distillation is we don't have to kill ourselves\n", - "to create a dataset! We really only need to generate the end-user's side of the\n", - "prompt and not the model's side, making this _so much simpler._\n", - "\n", - "Since our agent usecase here is 📎Clippy, we just need some simple questions a\n", - "user of our application might ask. A model like `GPT-4.1` can do this for us with\n", - "a prompt like:\n", - "\n", - "```\n", - "Generate 100 question and answer pairs that might be used in a quiz game. Output\n", - "the pairs in JSONL with the following schema:\n", - "\n", - "{ \"question\": , \"answer\": }\n", - "\n", - "Try not to create duplicates!\n", - "```\n", - "\n", - "> Seriously, this is how I created `qa.jsonl`. You can use Github Copilot right\n", - "> inside Visual Studio Code to generate it and also detect/remove duplicates\n", - "> until you have 500 rows.\n", - "\n", - "Let's take a peek at the data in [qa.jsonl](./qa.jsonl):\n" + "print(f\"✓ Eval file: {grader_eval_file.id}\")" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "ccfec9be", + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of Q/A pairs: 500\n", - "{'question': 'What is the freezing point of water in Fahrenheit?', 'answer': '32.'}\n", - "{'question': 'Which famous physicist developed the theory of relativity?', 'answer': 'Albert Einstein.'}\n", - "{'question': \"Who wrote the novel '1984'?\", 'answer': 'George Orwell'}\n" + "Evaluation criteria defined\n" ] } ], "source": [ - "# We've previously generated 500 Question/Answer pairs. Note that they are only\n", - "# focused on factual answers. We're not trying to provide any sarcasm here, just\n", - "# facts...and honestly we're not going to use the answers anyways...but you might\n", - "# use them if you had another grader that checked for gold standard answers.\n", - "import json\n", - "\n", - "qa = []\n", - "with open(\"./qa.jsonl\", \"r\") as f:\n", - " for line in f.readlines():\n", - " qa.append(json.loads(line))\n", - "\n", - "print(f\"Number of Q/A pairs: {len(qa)}\")\n", - "for i in range(3):\n", - " print(qa[i])" - ] - }, - { - "cell_type": "markdown", - "id": "3277e523", - "metadata": {}, - "source": [ - "We now need to split this into two sets:\n", + "# Define evaluation schema\n", + "data_source_config = {\n", + " \"type\": \"custom\",\n", + " \"item_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"question\": {\"type\": \"string\"},\n", + " \"answer\": {\"type\": \"string\"}\n", + " },\n", + " \"required\": [\"question\", \"answer\"]\n", + " }\n", + "}\n", "\n", - "1. A set for **baseline** testing (`qa_baseline`)\n", - "2. A set for **validation** after fine-tuning (`qa_validation`)\n", + "# Define grader as testing criteria\n", + "testing_criteria = [\n", + " {\n", + " \"type\": \"score_model\",\n", + " \"name\": \"sarcasm_score\",\n", + " \"model\": model_deployment,\n", + " \"input\": [\n", + " {\"role\": \"system\", \"content\": GRADER_PROMPT},\n", + " {\"role\": \"user\", \"content\": USER_PROMPT}\n", + " ],\n", + " \"pass_threshold\": 0.5\n", + " }\n", + "]\n", "\n", - "A simple 80/20 split here is good because the point of the validation set here is to have\n", - "a totally _different_ test to use post-training that has _zero overlap_ with what we'll\n", - "be using to train our student." + "print(\"Evaluation criteria defined\")" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "7d3e8982", + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "400 pairs for baseline testing, 100 for validation.\n" + "✓ Evaluation: eval_d341bcecf17245e48c9131906b3b73fc\n" ] } ], "source": [ - "# Now let's split these into two sets: our baseline set and our validation set. We'll just split\n", - "# them in half for now. \n", - "\n", - "# First we'll randomize it to maybe prove a point that this isn't totally staged 😜\n", - "from random import shuffle\n", - "shuffle(qa)\n", - "\n", - "# Now we split 80/20.\n", - "split_at = int(len(qa) * 0.8)\n", - "qa_baseline = qa[:split_at]\n", - "qa_validation = qa[split_at:]\n", - "\n", - "# Check it.\n", - "print(f\"{len(qa_baseline)} pairs for baseline testing, {len(qa_validation)} for validation.\")" - ] - }, - { - "cell_type": "markdown", - "id": "f11cc4b1", - "metadata": {}, - "source": [ - "Let's upload our baseline dataset.\n", - "\n", - "First, we'll write it to disk both to let you inspect it, but also because the OpenAI SDK\n", - "really prefers to upload data file files. 🙃\n", + "# Create evaluation\n", + "grader_eval = openai_client.evals.create(\n", + " name=f\"sarcasm-grader-{UNIQUE_KEY}\",\n", + " data_source_config=data_source_config,\n", + " testing_criteria=testing_criteria\n", + ")\n", "\n", - "> Yeah, if you're a Python dev and know how to make Files-like objects from data in-memory,\n", - "> _sorry_, but the SDK will barf." + "print(f\"✓ Evaluation: {grader_eval.id}\")" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "b73f399e", + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Created baseline file:\n", - "{\n", - " \"id\": \"file-ec72c2ec38dc4bf08937ee2d69cf5a80\",\n", - " \"bytes\": 33245,\n", - " \"created_at\": 1765377055,\n", - " \"filename\": \"sarcasm-baseline-90f2f57b.jsonl\",\n", - " \"object\": \"file\",\n", - " \"purpose\": \"evals\",\n", - " \"status\": \"processed\"\n", - "}\n" + "✓ Eval run: evalrun_730150a66c8343c8a62edbbf95b75a4d\n" ] } ], "source": [ - "# Now we'll upload our baseline dataset and prepare our Evaluation. We need to save the data\n", - "# to disk first for...reasons...because of the OpenAI SDK. That's fine.\n", - "filename = f\"./sarcasm-baseline-{UNIQUE_ENOUGH_KEY}.jsonl\"\n", - "\n", - "with open(filename, \"w\") as f:\n", - " for row in qa_baseline:\n", - " json.dump(row, f)\n", - " f.write(\"\\n\")\n", - "\n", - "baseline_file = None\n", - "with open(filename, \"rb\") as f:\n", - " baseline_file = client.files.create(purpose=\"evals\", file=f)\n", - " baseline_file = client.files.wait_for_processing(baseline_file.id)\n", + "# Run evaluation on baseline\n", + "grader_run = openai_client.evals.runs.create(\n", + " eval_id=grader_eval.id,\n", + " name=f\"baseline-{UNIQUE_KEY}\",\n", + " data_source={\n", + " \"type\": \"jsonl\",\n", + " \"source\": {\"type\": \"file_id\", \"id\": grader_eval_file.id}\n", + " }\n", + ")\n", "\n", - "print(f\"Created baseline file:\\n{baseline_file.to_json(indent=2)}\")" + "print(f\"✓ Eval run: {grader_run.id}\")" ] }, { - "cell_type": "markdown", - "id": "ae9d2b91", + "cell_type": "code", + "execution_count": 16, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Waiting for evaluation...\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: in_progress\n", + " Status: completed\n", + "\n", + "✓ completed!\n", + " Passed: 19/20\n" + ] + } + ], "source": [ - "### Defining our Baseline Evaluation\n", - "Most of this will look similar to above from section 1 where we evaluated our Grader.\n", - "\n", - "There are some key differences:\n", - "\n", - "1. The prompt template now uses `{{sample.output_text}}` because we'll be using the\n", - " base model (the model under test) to generate the answer to the user's question.\n", - "2. Because we're mixing _both_ the provided dataset file with generated responses,\n", - " we have to make some slight tweaks to our data source definition (`DATA_SOURCE`).\n", + "# Wait for completion\n", + "print(\"Waiting for evaluation...\")\n", + "while True:\n", + " run = openai_client.evals.runs.retrieve(run_id=grader_run.id, eval_id=grader_eval.id)\n", + " print(f\" Status: {run.status}\")\n", + " if run.status in [\"completed\", \"failed\"]:\n", + " break\n", + " time.sleep(5)\n", "\n", - "Other than that, this is pretty similar." + "print(f\"\\n✓ {run.status}!\")\n", + "if run.result_counts:\n", + " print(f\" Passed: {run.result_counts.passed}/{run.result_counts.total}\")" ] }, { "cell_type": "code", - "execution_count": 15, - "id": "69774305", + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "⚖️ Created baseline eval eval_693984204a7c8191b08abdc67b5d5e23\n" + "Baseline Sarcasm Scores:\n", + " Average: 0.59\n", + " Std Dev: 0.15\n" ] } ], "source": [ - "# We'll now build out the Evaluation details. In this case, we'll *generate* responses\n", - "# using a base model, unlike before where we used the pre-canned results just to test\n", - "# the grader.\n", - "\n", - "# We'll use a simple system prompt to show how distillation and fine-tuning let us\n", - "# get away without overly complex prompt engineering.\n", - "SYSTEM_PROMPT = \"Clippy is a factual chatbot that is also sarcastic.\"\n", - "\n", - "# We'll use a flee of base models as our baseline, including `o3` (our grader).\n", - "BASE_MODELS = [\n", - " \"DeepSeek-V3.1\",\n", - " \"gpt-4.1\",\n", - " \"gpt-4.1-mini\",\n", - " \"gpt-4.1-nano\",\n", - " \"gpt-4o\",\n", - " \"gpt-4o-mini\",\n", - " \"Ministral-3B\",\n", - "]\n", - "\n", - "# The prompt we'll grade will look like this pattern. Similar to before, but now we're\n", - "# going to use {{sample.output_text}} to substitute what the model under test generates.\n", - "USER_PROMPT = \"\"\"\n", - "Q: {{item.question}}\n", - "A: {{sample.output_text}}\n", - "\"\"\"\n", - "\n", - "# Input to our grader remains the same as before, but we reproduce it here for context.\n", - "INPUT = [\n", - " {\n", - " \"type\": \"message\",\n", - " \"role\": \"system\",\n", - " \"content\": { \"type\": \"input_text\", \"text\": GRADER_PROMPT }\n", - " },\n", - " {\n", - " \"type\": \"message\",\n", - " \"role\": \"user\",\n", - " \"content\": { \"type\": \"input_text\", \"text\": USER_PROMPT }\n", - " }\n", - "]\n", - "\n", - "# The schema and data source are similar, but with one major difference noted below.\n", - "SCHEMA = {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"question\": { \"type\": \"string\" },\n", - " \"answer\": { \"type\": \"string\" },\n", - " },\n", - "}\n", - "DATA_SOURCE = {\n", - " \"item_schema\": SCHEMA, \n", - " \"include_sample_schema\": True, # Note this change! Needed for data gen.\n", - " \"type\": \"custom\"\n", - "}\n", - "\n", - "# Same testing criteria, reproduced again for context.\n", - "TESTING_CRITERIA = {\n", - " \"name\": \"Auto Sarcasm Grader\",\n", - " \"type\": \"score_model\",\n", - " \"model\": GRADER_MODEL,\n", - " \"input\": INPUT,\n", - " \"range\": [1.0, 10.0],\n", - " \"pass_threshold\": 4.0,\n", - "}\n", + "# Get scores\n", + "output_items = list(openai_client.evals.runs.output_items.list(run_id=grader_run.id, eval_id=grader_eval.id))\n", + "baseline_scores = [r.score for item in output_items for r in item.results if r.score is not None]\n", "\n", - "# We create one Evaluation for *all* our base models. Each model is tested in a\n", - "# distinct Run that we'll define next.\n", - "baseline_eval = client.evals.create(\n", - " name=f\"sacarsm-baseline-{UNIQUE_ENOUGH_KEY}\",\n", - " data_source_config=DATA_SOURCE,\n", - " testing_criteria=[TESTING_CRITERIA]\n", - ")\n", - "print(f\"⚖️ Created baseline eval {baseline_eval.id}\")\n", - "\n" + "print(f\"Baseline Sarcasm Scores:\")\n", + "print(f\" Average: {np.mean(baseline_scores):.2f}\")\n", + "print(f\" Std Dev: {np.std(baseline_scores):.2f}\")" ] }, { "cell_type": "markdown", - "id": "1a7640fb", "metadata": {}, "source": [ - "Now instead of a single Run, we submit _one Run per base model_.\n", - "\n", - "This part is **new**, so let's look at it closely.\n", - "\n", - "Each Run has its own data source defined. Like with the Grader evaluation where\n", - "we finally said _which_ file to use for a test dataset, we're not providing both\n", - "a prompt template _and_ a reference to the test dataset.\n", - "\n", - "1. `source` -- looks like what we did previously, referencing our test data by\n", - " file id.\n", - "2. `input_messages` -- provides our prompt template, looking similar to how we\n", - " defined the Grader prompt previously. Note, however, we're now using our\n", - " `SYSTEM_PROMPT` (the simple 1-liner Clippy one) and wiring in the test data\n", - " as the user's input.\n", - "\n", - "> ℹ️ An astute reader will notice _we're not using the `answer` field_ from our\n", - "> test data. Yup! In this demo, we don't. You _could_ extend the grader to use\n", - "> that as \"ground truth\" for scoring the accuracy. Exercise left to you, my\n", - "> friend!\n", - "\n", - "> ⚠️ Attention!\n", - "> There's one thing to call out and that's the `sampling_params`. This lets us\n", - "> provide tuning of the chat completion parameters to the model under test. In\n", - "> this case, we're tuning the max completion tokens.\n", - "> \n", - "> However, there are two things to note:\n", - "> 1. We use a different value depending on if it's a reasoning model being tested\n", - "> or if it's a GPT model. (I'm not sure if this matters?)\n", - "> 2. More importantly, Azure OpenAI has a 🐛bug where we need to specificy it as\n", - "> `max_completions_tokens` and not `max_completion_tokens`. Note the lack of\n", - "> the `s`." + "## 6. Test Inference" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "85308636", + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🏃‍➡️ Created run evalrun_69398420f92081919db1b05086cd59ce for eval eval_693984204a7c8191b08abdc67b5d5e23\n", - "🏃‍➡️ Created run evalrun_69398421b4308191bc33dfac7567f082 for eval eval_693984204a7c8191b08abdc67b5d5e23\n", - "🏃‍➡️ Created run evalrun_6939842251f08191b1c8a9e4c5d0b2b1 for eval eval_693984204a7c8191b08abdc67b5d5e23\n", - "🏃‍➡️ Created run evalrun_69398422f7508191a52bfb35d10a2542 for eval eval_693984204a7c8191b08abdc67b5d5e23\n", - "🏃‍➡️ Created run evalrun_69398423c1008191b859c069dbce521e for eval eval_693984204a7c8191b08abdc67b5d5e23\n", - "🏃‍➡️ Created run evalrun_693984246064819180e8989ca09c597a for eval eval_693984204a7c8191b08abdc67b5d5e23\n", - "🏃‍➡️ Created run evalrun_6939842511a48191a67a392e04471fc1 for eval eval_693984204a7c8191b08abdc67b5d5e23\n" + "Q: What is the capital of France?\n", + "A: Oh, what a stumper! The capital of France? Let me consult my ancient scrolls... Oh wait, it’s Paris. You know, the city with the Eiffel Tower, baguettes, and a population of people who perfected the art of looking unimpressed. Paris is the answer you’re searching for, unless France has pulled a fast one overnight.\n" ] } ], "source": [ - "# Each run gets its own data source definition as it needs to specify a different\n", - "# model deployment to use for generation. The template is the prompt template\n", - "# sent to the model under test. It uses the simple Clippy system prompt and for\n", - "# the user input, we use the \"question\" from the baseline Q&A data file.\n", - "baseline_runs = []\n", - "for model in BASE_MODELS:\n", - " RUN_DATA_SOURCE = {\n", - " \"type\": \"completions\",\n", - " \"model\": model,\n", - " \"source\": { \"type\": \"file_id\", \"id\": baseline_file.id },\n", - " \"input_messages\": {\n", - " \"type\": \"template\",\n", - " \"template\": [\n", - " { \n", - " \"type\": \"message\", \n", - " \"role\": \"system\", \n", - " \"content\": { \"type\": \"input_text\", \"text\": SYSTEM_PROMPT },\n", - " },\n", - " { \n", - " \"type\": \"message\", \n", - " \"role\": \"user\", \n", - " \"content\": { \"type\": \"input_text\", \"text\": \"{{item.question}}\" },\n", - " },\n", - " ],\n", - " },\n", - " }\n", - " run = client.evals.runs.create(\n", - " name=f\"{model}-{UNIQUE_ENOUGH_KEY}\", \n", - " eval_id=baseline_eval.id,\n", - " data_source=RUN_DATA_SOURCE, \n", + "SARCASM_SYSTEM_PROMPT = \"\"\"You are a sarcastically witty assistant. Answer questions with \n", + "biting wit while remaining factually correct. Channel your inner comedian who's \n", + "slightly annoyed at obvious questions.\"\"\"\n", + "\n", + "def generate_response(question: str, model: str = None) -> str:\n", + " \"\"\"Generate a sarcastic response using responses API.\"\"\"\n", + " response = openai_client.responses.create(\n", + " model=model or teacher_model,\n", + " instructions=SARCASM_SYSTEM_PROMPT,\n", + " input=question,\n", + " temperature=0.7,\n", + " max_output_tokens=150\n", " )\n", - " print(f\"🏃‍➡️ Created run {run.id} for eval {baseline_eval.id}\")\n", - " baseline_runs.append(run)" + " return response.output_text\n", + "\n", + "# Test\n", + "test_q = \"What is the capital of France?\"\n", + "print(f\"Q: {test_q}\")\n", + "print(f\"A: {generate_response(test_q)}\")" ] }, { "cell_type": "markdown", - "id": "daaa0f77", "metadata": {}, "source": [ - "Waiting is always the hardest part. What can I say?\n", - "\n", - "This can take 15-20 minutes depending on your TPM limits. Maybe more. Maybe less." + "## 7. Load Q&A Data" ] }, { "cell_type": "code", - "execution_count": 17, - "id": "2d83696a", + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🏃‍➡️ Run DeepSeek-V3.1-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4.1-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4.1-mini-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4.1-nano-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4o-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4o-mini-90f2f57b: completed\n", - "🏃‍➡️ Run Ministral-3B-90f2f57b: completed\n", - "⏱️ Elapsed time: 8 minutes 1 seconds\n", - "🏁 All 7 runs completed!\n" + "Training: 250, Validation: 250\n" ] } ], "source": [ - "# We now have to wait for our half-dozen or so Runs to finish. Twiddle your thumbs a bit!\n", - "from IPython.display import clear_output\n", - "import time\n", - "\n", - "start_time = time.time()\n", - "\n", - "while any([r.status not in [\"completed\", \"failed\"] for r in baseline_runs]):\n", - " time.sleep(10)\n", - " clear_output(wait=True)\n", + "qa_data = []\n", + "with open(\"qa.jsonl\", \"r\") as f:\n", + " for line in f:\n", + " qa_data.append(json.loads(line))\n", "\n", - " for i in range(len(baseline_runs)):\n", - " baseline_runs[i] = client.evals.runs.retrieve(eval_id=baseline_eval.id, run_id=baseline_runs[i].id)\n", - " print(f\"🏃‍➡️ Run {baseline_runs[i].name}: {baseline_runs[i].status}\")\n", - " \n", - " now = time.time()\n", - " print(\"⏱️ Elapsed time: {} minutes {} seconds\".format(int((now - start_time) // 60), int((now - start_time) % 60)))\n", + "shuffle(qa_data)\n", + "split_idx = len(qa_data) // 2\n", + "training_questions = qa_data[:split_idx]\n", + "validation_questions = qa_data[split_idx:]\n", "\n", - "print(f\"🏁 All {len(baseline_runs)} runs completed!\")" + "print(f\"Training: {len(training_questions)}, Validation: {len(validation_questions)}\")" ] }, { "cell_type": "markdown", - "id": "3c425e6f", "metadata": {}, "source": [ - "### Interpreting our Baseline Results\n", - "Now we get to see our winner and loser!\n", - "\n", - "We'll use the same plotting function as before to look at _pass percentage_ and the\n", - "individual score distributions for each model.\n", - "\n", - "What we want to do here is:\n", - "1. Identify the clear winner to designat our *teacher*.\n", - "2. Identify the clear loser to designate our *student*.\n", - "\n", - "Recall our general hypothesis here is:\n", - "\n", - "> A larger, more robust model will excel at our task out of the box at the cost of\n", - "> typically more $'s per token and often higher latency (time-to-first-token).\n", - ">\n", - "> A smaller, less robust model will perform poorly out of the box, but will provide\n", - "> a better $/token price-point and often much lower latency.\n", - ">\n", - "> The ideal model for our agent will have the lowest $/token and latency, while\n", - "> achieving acceptable scores.\n", - "\n", - "Our goal, as a reminder, is to take that fast, cheap model and make it perform\n", - "**as well as the slower, more expensive model**.\n", - "\n", - "> 😜 Better, Faster, Cheaper: Pick 3!" + "## 8. Generate Training Data" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "5acc0dcd", + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Get Evaluation Runs: eval_693984204a7c8191b08abdc67b5d5e23\n", + "Generating 50 training examples...\n", + " 10/50...\n", + " 20/50...\n", + " 30/50...\n", + " 40/50...\n", + " 50/50...\n", "\n", - "==================================================\n", - "Combined Evaluation Summary\n", - "==================================================\n", - " Run ID Run Name Model Status Pass Percentage (%) Error Percentage (%) Evaluation ID Evaluation Name\n", - "evalrun_69398420f92081919db1b05086cd59ce DeepSeek-V3.1-90f2f57b DeepSeek-V3.1 completed 93.750000 3.00 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_69398421b4308191bc33dfac7567f082 gpt-4.1-90f2f57b gpt-4.1 completed 84.750000 5.25 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_693984246064819180e8989ca09c597a gpt-4o-mini-90f2f57b gpt-4o-mini completed 80.000000 2.75 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_6939842251f08191b1c8a9e4c5d0b2b1 gpt-4.1-mini-90f2f57b gpt-4.1-mini completed 74.686717 4.00 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_69398423c1008191b859c069dbce521e gpt-4o-90f2f57b gpt-4o completed 74.500000 3.50 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_6939842511a48191a67a392e04471fc1 Ministral-3B-90f2f57b Ministral-3B completed 29.500000 1.50 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_69398422f7508191a52bfb35d10a2542 gpt-4.1-nano-90f2f57b gpt-4.1-nano completed 27.000000 2.75 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "==================================================\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==================================================\n", - "Fetching scores...\n", - "==================================================\n", + "Generating 25 validation examples...\n", "\n", - "==================================================\n", - "Score Summary Table:\n", - " Model Evaluation Name Average Score Min Score Max Score 10th Percentile 25th Percentile 50th Percentile 75th Percentile 90th Percentile\n", - "DeepSeek-V3.1 sacarsm-baseline-90f2f57b 7.07 0.00 10.00 5.00 7.00 8.00 8.00 8.00\n", - " gpt-4.1 sacarsm-baseline-90f2f57b 5.80 0.00 9.00 3.00 5.00 6.00 7.00 8.00\n", - " gpt-4o-mini sacarsm-baseline-90f2f57b 5.54 0.00 9.00 3.00 4.00 6.00 7.00 8.00\n", - " gpt-4o sacarsm-baseline-90f2f57b 5.26 0.00 9.00 3.00 3.00 6.00 7.00 8.00\n", - " gpt-4.1-mini sacarsm-baseline-90f2f57b 5.18 0.00 9.00 3.00 3.00 6.00 7.00 8.00\n", - " gpt-4.1-nano sacarsm-baseline-90f2f57b 2.85 0.00 8.00 1.00 1.00 2.00 4.00 6.00\n", - " Ministral-3B sacarsm-baseline-90f2f57b 2.70 0.00 8.00 1.00 1.00 1.00 5.00 7.00\n", - "==================================================\n" + "✓ Generated 50 training, 25 validation\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "# Let's visualize our evaluation and identify the best and worst performers.\n", - "display_evaluation_summary(client, [baseline_eval.id], x_range=(1, 10))\n" - ] - }, - { - "cell_type": "markdown", - "id": "780e5d56", - "metadata": {}, - "source": [ - "You'll notice we have a very clear winner and a very clear loser.\n", - "\n", - "- `DeepSeek-V3.1` -- consistently scores the highest both in terms of passing scores,\n", - " but also generates generates a lot of high scores.\n", - "- `Ministral-3B` -- higher average score than `gpt-4.1-nano`, but has the most scores\n", - " of `1`. Just an embarassment!\n", - "\n", - "But let's hold that thought for a moment. Visually we can see this, but remember what\n", - "we want to do here is find not just the _best performing model_, but we need it's best\n", - "_example responses_.\n" - ] - }, - { - "cell_type": "markdown", - "id": "a729010c", - "metadata": {}, - "source": [ - "\n", - "## 4. 🧪 Distilling from the Teacher\n", - "Let's look at all our models again, this time via code, and find just the _excellent_\n", - "responses that scored `6.0` or higher.\n", - "\n", - "> ℹ️ This part gets a bit technical! We'll be doing some data engineering on the fly\n", - "> as we analyze the excellent responses. This is maybe the more complex Python in this\n", - "> entire notebook as it works around some limitations with the Evaluations API, but\n", - "> buckle up and I promise it's worth it.\n", - "\n", - "What we're going to do is query each Run, look at the Run's _individual results_,\n", - "collect just the \"excellent\" ones, and while we're doing so we'll be\n", - "_transforming them into chat completions_.\n", - "\n", - "Then it's as simple as seeing which model had the most \"excellent\" scores and\n", - "declaring our winner." + "MAX_TRAINING = 50\n", + "MAX_VALIDATION = 25\n", + "\n", + "print(f\"Generating {MAX_TRAINING} training examples...\")\n", + "training_data = []\n", + "for i, item in enumerate(training_questions[:MAX_TRAINING]):\n", + " response = generate_response(item['question'])\n", + " training_data.append({\n", + " \"messages\": [\n", + " {\"role\": \"system\", \"content\": SARCASM_SYSTEM_PROMPT},\n", + " {\"role\": \"user\", \"content\": item['question']},\n", + " {\"role\": \"assistant\", \"content\": response}\n", + " ]\n", + " })\n", + " if (i + 1) % 10 == 0:\n", + " print(f\" {i + 1}/{MAX_TRAINING}...\")\n", + "\n", + "print(f\"\\nGenerating {MAX_VALIDATION} validation examples...\")\n", + "validation_data = []\n", + "for item in validation_questions[:MAX_VALIDATION]:\n", + " response = generate_response(item['question'])\n", + " validation_data.append({\n", + " \"messages\": [\n", + " {\"role\": \"system\", \"content\": SARCASM_SYSTEM_PROMPT},\n", + " {\"role\": \"user\", \"content\": item['question']},\n", + " {\"role\": \"assistant\", \"content\": response}\n", + " ]\n", + " })\n", + "\n", + "print(f\"\\n✓ Generated {len(training_data)} training, {len(validation_data)} validation\")" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "2ab5fae6", + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "😜 Ok! Let's use DeepSeek-V3.1. It had 357 excellent responses.\n" + "✓ training_sarcasm_4aa88349.jsonl\n", + "✓ validation_sarcasm_4aa88349.jsonl\n" ] } ], "source": [ - "# We'll find the model that generated the most \"excellent\" (>= 6.0) examples of sarcasm.\n", - "CUTOFF = 6.0\n", - "HIGH_SCORES = dict([(m, []) for m in BASE_MODELS])\n", + "# Save files\n", + "training_file_path = f\"training_sarcasm_{UNIQUE_KEY}.jsonl\"\n", + "validation_file_path = f\"validation_sarcasm_{UNIQUE_KEY}.jsonl\"\n", + "\n", + "with open(training_file_path, \"w\") as f:\n", + " for item in training_data:\n", + " f.write(json.dumps(item) + \"\\n\")\n", "\n", - "# Let's find our responses that were Excellent (at or above CUTOFF). We'll collect them\n", - "# and pre-format them into chat completions format to save time later.\n", - "#\n", - "# This part is honestly a bit tricky...we're extracting the prompts and responses for the\n", - "# model under test and *not* the prompts to the grader, so we have to do surgery. 🔪\n", - "for run in baseline_runs:\n", - " pages = client.evals.runs.output_items.list(run.id, eval_id=baseline_eval.id).iter_pages()\n", - " for page in pages:\n", - " for item in page.data:\n", - " # We only used 1 grader. If you use multiple, you should look for which ones you want.\n", - " if not item.results:\n", - " continue\n", - " result = item.results[0]\n", - " if result.score >= CUTOFF:\n", - " generated = result.sample[\"input\"][-1][\"content\"].strip().split(\"\\nA: \")\n", - " question = generated[0][3:] # drops the \"Q: \"\n", - " answer = generated[-1]\n", - " messages = [\n", - " { \"role\": \"system\", \"content\": SYSTEM_PROMPT },\n", - " { \"role\": \"user\", \"content\": question },\n", - " { \"role\": \"assistant\", \"content\": answer },\n", - " ]\n", - " HIGH_SCORES[run.model].append({ \"messages\": messages })\n", + "with open(validation_file_path, \"w\") as f:\n", + " for item in validation_data:\n", + " f.write(json.dumps(item) + \"\\n\")\n", "\n", - "# Time to find the winner! Obviously, this is probably o3...\n", - "winning_model = \"\"\n", - "winning_cnt = 0\n", - "for key in HIGH_SCORES.keys():\n", - " if len(HIGH_SCORES[key]) > winning_cnt:\n", - " winning_model = key\n", - " winning_cnt = len(HIGH_SCORES[key])\n", - " \n", - "print(f\"😜 Ok! Let's use {winning_model}. It had {winning_cnt} excellent responses.\")" + "print(f\"✓ {training_file_path}\")\n", + "print(f\"✓ {validation_file_path}\")" ] }, { "cell_type": "markdown", - "id": "f3bbdd48", "metadata": {}, "source": [ - "We now take _just the Teacher's excellent responses_ and construct our training data.\n", - "\n", - "We should well over 100 examples if all goes well (based on previous testing of this notebook),\n", - "so let's give it a train/test split:\n", - "\n", - "1. Split the data in-memory.\n", - "2. Write the training and validation data out as JSONL to disk.\n", - "3. Upload them via the Files API." + "## 9. Fine-Tune Model" ] }, { "cell_type": "code", - "execution_count": 20, - "id": "f70963f8", + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Split into 285 training / 72 validation rows.\n", - "🏋️‍♂️ Created training file:\n", - "{\n", - " \"id\": \"file-8289de70b4af4de98f2136dcd694e0ec\",\n", - " \"bytes\": 120909,\n", - " \"created_at\": 1765377614,\n", - " \"filename\": \"sarcasm-training-90f2f57b.jsonl\",\n", - " \"object\": \"file\",\n", - " \"purpose\": \"fine-tune\",\n", - " \"status\": \"processed\"\n", - "}\n", - "📋 Created validation file:\n", - "{\n", - " \"id\": \"file-8d808872611d45b1b1d38221d4e777ae\",\n", - " \"bytes\": 30810,\n", - " \"created_at\": 1765377620,\n", - " \"filename\": \"sarcasm-validation-90f2f57b.jsonl\",\n", - " \"object\": \"file\",\n", - " \"purpose\": \"fine-tune\",\n", - " \"status\": \"processed\"\n", - "}\n" + "Training: file-e457cb500c77408db3a563f2dcfa986f\n", + "Validation: file-b7d2cf189fb9422eb9e57a5c454d7531\n", + "✓ Files ready\n" ] } ], "source": [ - "# Before we go any further, let's turn our collected excellent responses into our\n", - "# training and validation fine-tuning datasets. Like before, we have to write these\n", - "# to disk and then upload them via the Files API.\n", - "training_filename = f\"sarcasm-training-{UNIQUE_ENOUGH_KEY}.jsonl\"\n", - "validation_filename = f\"sarcasm-validation-{UNIQUE_ENOUGH_KEY}.jsonl\"\n", - "\n", - "# Make an 80/20 split to form our training/validation data.\n", - "split_at = int(len(HIGH_SCORES[winning_model]) * 0.80)\n", - "training_data = HIGH_SCORES[winning_model][:split_at]\n", - "validation_data = HIGH_SCORES[winning_model][split_at:]\n", - "print(f\"Split into {len(training_data)} training / {len(validation_data)} validation rows.\")\n", - "\n", - "# Create and upload the training data.\n", - "with open(training_filename, \"w\") as f:\n", - " for message in training_data:\n", - " json.dump(message, f)\n", - " f.write(\"\\n\")\n", - "with open(training_filename, \"rb\") as f:\n", - " training_file = client.files.create(file=f, purpose=\"fine-tune\")\n", - " training_file = client.files.wait_for_processing(training_file.id)\n", - "print(f\"🏋️‍♂️ Created training file:\\n{training_file.to_json(indent=2)}\")\n", - "\n", - "# Create and upload the validation data.\n", - "with open(validation_filename, \"w\") as f:\n", - " for message in validation_data:\n", - " json.dump(message, f)\n", - " f.write(\"\\n\")\n", - "with open(validation_filename, \"rb\") as f:\n", - " validation_file = client.files.create(file=f, purpose=\"fine-tune\")\n", - " validation_file = client.files.wait_for_processing(validation_file.id)\n", - "print(f\"📋 Created validation file:\\n{validation_file.to_json(indent=2)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "ce255aed", - "metadata": {}, - "source": [ - "## 5. 🏋️‍♂️ Training the Students\n", - "We've got our training dataset, so let's get to fine-tuning!\n", - "\n", - "We've chosen `Ministral-3B` and `gpt-4.1-nano` as the students because they are desperately\n", - "in the need of some help as shown by its benchmarking.\n", + "# Upload files\n", + "with open(training_file_path, \"rb\") as f:\n", + " train_file = openai_client.files.create(file=f, purpose=\"fine-tune\")\n", "\n", - "We'll create a job _suffix_ that identifies our teacher model for posterity and include that\n", - "unique-enough key from before so if you want to run this notebook again you can have two\n", - "different fine-tuning jobs to compare.\n", + "with open(validation_file_path, \"rb\") as f:\n", + " val_file = openai_client.files.create(file=f, purpose=\"fine-tune\")\n", "\n", - "> ℹ️ Look at the use of `extra_body` as a parameter! We're telling Azure OpenAI to try\n", - "> using Global Training for our job. If you want to learn more about Global Training, check\n", - "> out the orginal [announcement](https://aka.ms/Build25/FTGlobalAndDev) from **Build 2025**.\n", + "print(f\"Training: {train_file.id}\")\n", + "print(f\"Validation: {val_file.id}\")\n", "\n", - "Note that we're not tuning hyper-parameters here for our job and just using defaults. That\n", - "is an exercise left for you, dear reader!" + "openai_client.files.wait_for_processing(train_file.id)\n", + "openai_client.files.wait_for_processing(val_file.id)\n", + "print(\"✓ Files ready\")" ] }, { "cell_type": "code", - "execution_count": 21, - "id": "e7e8b7a4", + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "👨‍🔬 Created fine-tuning job:\n", - "{\n", - " \"id\": \"ftjob-22fdc4d28e9e4b80b78b30daeb76cc00\",\n", - " \"created_at\": 1765377627,\n", - " \"hyperparameters\": {\n", - " \"batch_size\": -1,\n", - " \"learning_rate_multiplier\": 1.0,\n", - " \"n_epochs\": 50\n", - " },\n", - " \"model\": \"Ministral-3B\",\n", - " \"object\": \"fine_tuning.job\",\n", - " \"seed\": 170999531,\n", - " \"status\": \"pending\",\n", - " \"training_file\": \"file-8289de70b4af4de98f2136dcd694e0ec\",\n", - " \"validation_file\": \"file-8d808872611d45b1b1d38221d4e777ae\",\n", - " \"estimated_finish\": 1765468527,\n", - " \"method\": {\n", - " \"type\": \"supervised\",\n", - " \"supervised\": {\n", - " \"hyperparameters\": {\n", - " \"batch_size\": -1,\n", - " \"learning_rate_multiplier\": 1.0,\n", - " \"n_epochs\": 50\n", - " }\n", - " }\n", - " },\n", - " \"suffix\": \"sarcasm-DeepSeek-V31-90f2f57b\",\n", - " \"trainingType\": \"globalStandard\"\n", - "}\n" + "✓ Job: ftjob-cbccca9eb73d4da991b925d045133219\n", + " Status: pending\n" ] } ], "source": [ - "# Submit our Ministral-3B training job.\n", - "TEACHER_MODEL = winning_model\n", - "STUDENT_MODEL = \"ministral-3b\"\n", - "SUFFIX = f\"sarcasm-{TEACHER_MODEL}-{UNIQUE_ENOUGH_KEY}\".replace(\".\", \"\") # '.' is a reserved character 😜\n", - "\n", - "ministral_job = client.fine_tuning.jobs.create(\n", - " model=STUDENT_MODEL,\n", - " suffix=SUFFIX,\n", - " training_file=training_file.id,\n", - " validation_file=validation_file.id,\n", - " extra_body={ \"trainingType\": \"globalstandard\" },\n", + "# Create fine-tuning job\n", + "fine_tune_job = openai_client.fine_tuning.jobs.create(\n", + " model=base_model,\n", + " training_file=train_file.id,\n", + " validation_file=val_file.id,\n", " method={\n", " \"type\": \"supervised\",\n", " \"supervised\": {\n", " \"hyperparameters\": {\n", - " \"n_epochs\": 50, # Ministral-3B benefits from a high epochs value.\n", + " \"n_epochs\": 3,\n", + " \"batch_size\": 1,\n", + " \"learning_rate_multiplier\": 1.0\n", " }\n", " }\n", - " }\n", + " },\n", + " extra_body={\"trainingType\": \"Standard\"},\n", + " suffix=f\"sarcasm-{UNIQUE_KEY}\"\n", ")\n", - "print(f\"👨‍🔬 Created fine-tuning job:\\n{ministral_job.to_json(indent=2)}\")" + "\n", + "print(f\"✓ Job: {fine_tune_job.id}\")\n", + "print(f\" Status: {fine_tune_job.status}\")" ] }, { "cell_type": "markdown", - "id": "63eb381d", "metadata": {}, "source": [ - "For `gpt-4.1-nano`, we can take advantage of the new *Developer* training tier\n", - "that schedules our job on spot capacity at a 50% discount!" + "## 10. Monitor Training" ] }, { "cell_type": "code", - "execution_count": 22, - "id": "ec8f986e", + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "👨‍🔬 Created fine-tuning job:\n", - "{\n", - " \"id\": \"ftjob-3c27f78ad2c141719573c550300bb791\",\n", - " \"created_at\": 1765377628,\n", - " \"hyperparameters\": {\n", - " \"batch_size\": -1,\n", - " \"learning_rate_multiplier\": 0.1,\n", - " \"n_epochs\": -1\n", - " },\n", - " \"model\": \"gpt-4.1-nano-2025-04-14\",\n", - " \"object\": \"fine_tuning.job\",\n", - " \"seed\": 1003399446,\n", - " \"status\": \"pending\",\n", - " \"training_file\": \"file-8289de70b4af4de98f2136dcd694e0ec\",\n", - " \"validation_file\": \"file-8d808872611d45b1b1d38221d4e777ae\",\n", - " \"estimated_finish\": 1765471227,\n", - " \"suffix\": \"sarcasm-DeepSeek-V31-90f2f57b\",\n", - " \"trainingType\": \"developerTier\"\n", - "}\n" + "Job: ftjob-71e2eea33ecd4d4e990c54ed09ada149\n", + "Status: succeeded\n", + "Model: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n" ] } ], "source": [ - "# Now we start training! Submit our fine-tuning job to teach 4.1-nano new tricks.\n", - "TEACHER_MODEL = winning_model\n", - "STUDENT_MODEL = \"gpt-4.1-nano-2025-04-14\"\n", - "SUFFIX = f\"sarcasm-{TEACHER_MODEL}-{UNIQUE_ENOUGH_KEY}\".replace(\".\", \"\") # '.' is a reserved character 😜\n", - "\n", - "nano_job = client.fine_tuning.jobs.create(\n", - " model=STUDENT_MODEL,\n", - " suffix=SUFFIX,\n", - " training_file=training_file.id,\n", - " validation_file=validation_file.id,\n", - " extra_body={ \"trainingType\": \"developerTier\" },\n", - " # We will use default hyperparameters for this job.\n", - ")\n", - "print(f\"👨‍🔬 Created fine-tuning job:\\n{nano_job.to_json(indent=2)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "a85e5e6a", - "metadata": {}, - "source": [ - "Fine-tuning, like Evaluations, take time. Now's a good time to go catch up on emails ✉️,\n", - "walk your dog 🐕, or take a nap 😴. We can poll the training status to know when we can\n", - "proceed further in the notebook." + "# Check status\n", + "job_id = fine_tune_job.id\n", + "job = openai_client.fine_tuning.jobs.retrieve(job_id)\n", + "print(f\"Job: {job.id}\")\n", + "print(f\"Status: {job.status}\")\n", + "if job.fine_tuned_model:\n", + " print(f\"Model: {job.fine_tuned_model}\")" ] }, { "cell_type": "code", - "execution_count": 23, - "id": "88aa266f", + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "👨‍🔬 gpt-4.1-nano job ftjob-3c27f78ad2c141719573c550300bb791: succeeded\n", - "👨‍🔬 Ministral-3B job ftjob-22fdc4d28e9e4b80b78b30daeb76cc00: succeeded\n", - "⏱️ Elapsed time: 57 minutes 53 seconds\n", - "🏁 Fine-tuning finished!\n" + "Waiting for fine-tuning...\n", + " [00:00] succeeded\n", + "\n", + "✓ Model: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n" ] } ], "source": [ - "# Wait for our FT job to complete. You may want to go work on some other tasks for now 😜\n", - "from IPython.display import clear_output\n", - "import time\n", - "\n", + "# Wait for completion (can take 10-30 min)\n", + "print(\"Waiting for fine-tuning...\")\n", "start_time = time.time()\n", "\n", - "while any([j.status not in [\"succeeded\", \"failed\", \"cancelled\"] for j in [nano_job, ministral_job]]):\n", - " time.sleep(10)\n", - " nano_job = client.fine_tuning.jobs.retrieve(nano_job.id)\n", - " ministral_job = client.fine_tuning.jobs.retrieve(ministral_job.id)\n", - " clear_output(wait=True)\n", - " print(f\"👨‍🔬 gpt-4.1-nano job {nano_job.id}: {nano_job.status}\")\n", - " print(f\"👨‍🔬 Ministral-3B job {ministral_job.id}: {ministral_job.status}\")\n", - " print(\"⏱️ Elapsed time: {} minutes {} seconds\".format(int((time.time() - start_time) // 60), int((time.time() - start_time) % 60)))\n", + "while True:\n", + " job = openai_client.fine_tuning.jobs.retrieve(job_id)\n", + " elapsed = int(time.time() - start_time)\n", + " print(f\" [{elapsed//60:02d}:{elapsed%60:02d}] {job.status}\")\n", + " \n", + " if job.status in [\"succeeded\", \"failed\", \"cancelled\"]:\n", + " break\n", + " time.sleep(30)\n", "\n", - "if nano_job.status == \"succeeded\" and ministral_job.status == \"succeeded\":\n", - " print(f\"🏁 Fine-tuning finished!\")\n", + "if job.status == \"succeeded\":\n", + " fine_tuned_model_id = job.fine_tuned_model\n", + " print(f\"\\n✓ Model: {fine_tuned_model_id}\")\n", "else:\n", - " raise RuntimeError(f\"Fine-tuning job did not complete successfully (status={status})\")" - ] - }, - { - "cell_type": "markdown", - "id": "91fc761d", - "metadata": {}, - "source": [ - "Once the jobs complete, we should eyeball the metrics. Here's what an example\n", - "should look like:\n", - "\n", - "`TODO: INSERT IMAGE`\n", - "\n", - "If our models are learning, you should see the _training loss_ decreasing.\n", - "This gives us a sense of if the model learned something, but it **doesn't** tell us\n", - "if the model is fit for production!" + " print(f\"\\n✗ {job.status}\")" ] }, { "cell_type": "markdown", - "id": "92f0660a", "metadata": {}, "source": [ - "## 6. 🧑‍⚖️ Judging our Students against their Peers\n", - "Shipping a new model to production right now would be truly a YOLO moment and I\n", - "cannot recommend it.\n", - "\n", - "What we really need to do now is go back and benchmark it against the original\n", - "`Ministral-3B` and `gpt-4.1-nano` base models.\n", - "\n", - "Remember how we split that initial Q&A dataset into two parts? The `qa_validation`\n", - "file contains unseen questions for our models that could not possible appear in the\n", - "training data, so it's the perfect check to answer the question if we actually\n", - "moved the needle.\n", - "\n", - "### 🚢 Deploying our New Models\n", - "Foundry requires you to \"deploy\" a model in order to have an endpoint to call it,\n", - "so let's do that.\n", - "\n", - "We need to reach for a different SDK, though, but no worries! The Azure Cognitive\n", - "Services SDK let's us talk to the Azure OpenAI control plane to deploy things\n", - "without having to leave this comfy notebook.\n", - "\n", - "> ⚠️ The code below uses a `DefaultAzureCredential`. The easiest way to make sure\n", - "> one exists is to have installed and authenticated the Azure CLI tooling.\n", - ">\n", - "> See: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest\n", - "\n", - "For `gpt-4.1-nano`, we'll use the `Developer` tier available for Azure OpenAI\n", - "Fine-Tuned models as it's purpose built for model candidate evaluation: you only pay\n", - "per token at the same base model rates! ([Learn more](https://aka.ms/Build25/FTGlobalAndDev)!)\n", - "\n", - "For Ministral-3B, we'll use `Global Standard` as `Developer` isn't yet ready while\n", - "the model is in Public Preview." + "## 11. Deploy Model" ] }, { "cell_type": "code", - "execution_count": 24, - "id": "6dee6381", + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🛳️ Submitted deployment ministral-3b-distilled-90f2f57b\n", - "🛳️ Submitted deployment gpt-4.1-nano-distilled-90f2f57b\n" + "Deploying: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n", + "✓ Deployed: sarcasm-ft-4aa88349\n" ] } ], "source": [ - "# Now we need to deploy our fine-tuned model. We'll use Developer Tier to keep\n", - "# costs under control for evaluation.\n", - "\n", - "# We can't do this with the OpenAI SDK, so we need to reach for the Azure SDK.\n", - "from azure.identity import DefaultAzureCredential\n", "from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient\n", - "from azure.mgmt.cognitiveservices.models import Deployment, DeploymentProperties, DeploymentModel\n", + "from azure.mgmt.cognitiveservices.models import Deployment, DeploymentProperties, DeploymentModel, Sku\n", "\n", - "cogsvc_client = CognitiveServicesManagementClient(\n", - " credential=DefaultAzureCredential(),\n", - " subscription_id=os.environ.get(\"AZURE_SUBSCRIPTION_ID\"),\n", - ")\n", + "subscription_id = os.environ.get(\"AZURE_SUBSCRIPTION_ID\")\n", + "resource_group = os.environ.get(\"AZURE_RESOURCE_GROUP\")\n", + "account_name = os.environ.get(\"AZURE_AOAI_ACCOUNT\")\n", "\n", - "# Define our Deployments. Note the use of SKU for specificy capacity and\n", - "# the name of the deployment tier.\n", - "DEPLOYMENT_CONFIGURATION = [\n", - " {\n", - " \"name\": f\"ministral-3b-distilled-{UNIQUE_ENOUGH_KEY}\",\n", - " \"format\": \"Ministral AI\",\n", - " \"model\": ministral_job.fine_tuned_model,\n", - " \"sku\": \"GlobalStandard\",\n", - " },\n", - " {\n", - " \"name\": f\"gpt-4.1-nano-distilled-{UNIQUE_ENOUGH_KEY}\",\n", - " \"format\": \"OpenAI\",\n", - " \"model\": nano_job.fine_tuned_model,\n", - " \"sku\": \"DeveloperTier\",\n", - " },\n", - "]\n", + "deployment_name = f\"sarcasm-ft-{UNIQUE_KEY}\"\n", "\n", - "DEPLOYMENTS = []\n", - "for d in DEPLOYMENT_CONFIGURATION:\n", - " deployment = cogsvc_client.deployments.begin_create_or_update(\n", - " resource_group_name=os.environ.get(\"AZURE_RESOURCE_GROUP\"),\n", - " account_name=os.environ.get(\"FOUNDRY_PARENT_RESOURCE\"),\n", - " deployment_name=d[\"name\"],\n", - " deployment={\n", - " \"properties\": {\n", - " \"model\": {\n", - " \"format\": d[\"format\"],\n", - " \"name\": d[\"model\"],\n", - " \"version\": \"1\",\n", - " },\n", - " },\n", - " \"sku\": {\"capacity\": 100, \"name\": d[\"sku\"]},\n", - " },\n", + "with CognitiveServicesManagementClient(credential=credential, subscription_id=subscription_id) as mgmt:\n", + " deployment_model = DeploymentModel(format=\"OpenAI\", name=fine_tuned_model_id, version=\"1\")\n", + " deployment_properties = DeploymentProperties(model=deployment_model)\n", + " deployment_sku = Sku(name=\"GlobalStandard\", capacity=50)\n", + " deployment_config = Deployment(properties=deployment_properties, sku=deployment_sku)\n", + " \n", + " print(f\"Deploying: {fine_tuned_model_id}\")\n", + " deployment = mgmt.deployments.begin_create_or_update(\n", + " resource_group_name=resource_group,\n", + " account_name=account_name,\n", + " deployment_name=deployment_name,\n", + " deployment=deployment_config,\n", " )\n", - " print(f\"🛳️ Submitted deployment {d['name']}\")\n", - " DEPLOYMENTS.append(deployment)" + " deployment.result()\n", + "\n", + "print(f\"✓ Deployed: {deployment_name}\")" ] }, { "cell_type": "markdown", - "id": "3c9affa8", "metadata": {}, "source": [ - "Deployments, like Evaluations and Training, are not instaneous, but they are typically\n", - "a lot faster! `Ministral-3B` typically will deploy in 3-5 minutes, so maybe don't walk\n", - "away from your desk just yet 😜." + "## 12. Compare Models" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "02c4168a", + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🏁 Provisioning finished!\n" + "Generating comparison data...\n", + "✓ 20 comparisons\n" ] } ], "source": [ - "# Wait for our deployment to finish provisioning.\n", - "start_time = time.time()\n", - "\n", - "STATUS = [d.status() for d in DEPLOYMENTS]\n", - "while any([s not in [\"Succeeded\", \"Failed\"] for s in STATUS]):\n", - " print(f\"🛳️ Provisioning {STATUS}\")\n", - " print(\"⏱️Elapsed time: {} minutes {} seconds\".format(int((time.time() - start_time) // 60), int((time.time() - start_time) % 60)))\n", - " STATUS = [d.status() for d in DEPLOYMENTS]\n", - " time.sleep(5)\n", - " clear_output(wait=True)\n", - " \n", - "print(f\"🏁 Provisioning finished!\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "88fdda88", - "metadata": {}, - "source": [ - "### ⬆️ Uploading the Validation Data\n", - "This should be old-hat by now! We'll take the in-memory validatation data (`qa_validation`)\n", - "and create a dataset via the Files API." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "5788bf4d", - "metadata": {}, - "outputs": [], - "source": [ - "# Now we'll upload our post-training validation dataset and prepare our final Evaluation.\n", - "# We need to save the data to disk first, again for...reasons.\n", - "filename = f\"./sarcasm-posttraining-{UNIQUE_ENOUGH_KEY}.jsonl\"\n", + "# Generate comparison data\n", + "print(\"Generating comparison data...\")\n", + "comparison_data = []\n", + "test_questions = validation_questions[MAX_VALIDATION:MAX_VALIDATION+20]\n", "\n", - "with open(filename, \"w\") as f:\n", - " for row in qa_validation:\n", - " json.dump(row, f)\n", - " f.write(\"\\n\")\n", + "for item in test_questions:\n", + " q = item['question']\n", + " base_response = generate_response(q, model=base_model)\n", + " ft_response = generate_response(q, model=deployment_name)\n", + " comparison_data.append({\n", + " \"question\": q,\n", + " \"base_answer\": base_response,\n", + " \"ft_answer\": ft_response\n", + " })\n", "\n", - "posttraining_file = None\n", - "with open(filename, \"rb\") as f:\n", - " posttraining_file = client.files.create(purpose=\"evals\", file=f)\n", - " posttraining_file = client.files.wait_for_processing(posttraining_file.id)\n" + "print(f\"✓ {len(comparison_data)} comparisons\")" ] }, { - "cell_type": "markdown", - "id": "35180760", + "cell_type": "code", + "execution_count": 33, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Evaluation files saved\n" + ] + } + ], "source": [ - "### 🏃 Creating Runs to make our Students Compete with the Base Models\n", - "Here's where Evaluations really shine ✨!\n", - "\n", - "We _could_ reuse our baseline evaluation from before and just add new Runs so all the\n", - "results are in one place and easily viewable.\n", - "\n", - "In this case, we'll keep it simple and create a new Evaluation primarily because the\n", - "visualization code already has color-coding based on Eval, not Run and I'm too lazy\n", - "to rewrite it further 😜.\n", + "# Save for evaluation\n", + "base_eval_file = f\"base_eval_{UNIQUE_KEY}.jsonl\"\n", + "ft_eval_file = f\"ft_eval_{UNIQUE_KEY}.jsonl\"\n", "\n", - "Most of this is repeat, in fact we could have reused thigns like `DATA_SOURCE`,\n", - "`TESTING_CRITERIA`, etc. but restate them below for completeness. Same can be said\n", - "for the Runs.\n", + "with open(base_eval_file, \"w\") as f:\n", + " for item in comparison_data:\n", + " f.write(json.dumps({\"question\": item[\"question\"], \"answer\": item[\"base_answer\"]}) + \"\\n\")\n", "\n", - "*However*, we'll focus on just comparing our new models to their base models and also add\n", - "in the teacher as sort of a control. We're testing with totally new data here, unseen by\n", - "any of our models, so what we expect to see is:\n", + "with open(ft_eval_file, \"w\") as f:\n", + " for item in comparison_data:\n", + " f.write(json.dumps({\"question\": item[\"question\"], \"answer\": item[\"ft_answer\"]}) + \"\\n\")\n", "\n", - "1. The base `Ministral-3B` and `gpt-4.1-nano` perform poorly again.\n", - "2. The teacher performs well and on-par with the previous baseline.\n", - "3. The new student models outperform their respective base models.\n" + "print(\"✓ Evaluation files saved\")" ] }, { "cell_type": "code", - "execution_count": 31, - "id": "c125c08c", + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Created eval eval_693996f5adac8191a606b12700d6118f\n", - "🏃‍➡️ Created run evalrun_693996f640588191a6d2723f8d53adb5 for eval_693996f5adac8191a606b12700d6118f\n", - "🏃‍➡️ Created run evalrun_693996f706ec8191b0096ec9a8305ffd for eval_693996f5adac8191a606b12700d6118f\n", - "🏃‍➡️ Created run evalrun_693996f7a04881918725f5a01dfc964b for eval_693996f5adac8191a606b12700d6118f\n", - "🏃‍➡️ Created run evalrun_693996f83c488191b358c15ae875ec33 for eval_693996f5adac8191a606b12700d6118f\n", - "🏃‍➡️ Created run evalrun_693996f95cb081918c16ae9f8926f64c for eval_693996f5adac8191a606b12700d6118f\n" + "Base run: evalrun_a716d715fdc24e0facffc8b9a90ce170\n", + "Fine-tuned run: evalrun_5180d075fd104d3e962db18db418176c\n" ] } ], "source": [ - "# Now we create a final Eval using our post-training dataset that doesn't overlap with the\n", - "# original distillation and training dataset. This lets us judge our new model based on\n", - "# data it hasn't seen before. We'll also through in one of our better performing base\n", - "# models as a control.\n", - "POST_EVAL_MODELS = [d[\"name\"] for d in DEPLOYMENT_CONFIGURATION] + [\"gpt-4.1-nano\", \"Ministral-3B\", TEACHER_MODEL]\n", + "# Upload and run evaluations\n", + "with open(base_eval_file, \"rb\") as f:\n", + " base_file = openai_client.files.create(purpose=\"evals\", file=f)\n", + " base_file = openai_client.files.wait_for_processing(base_file.id)\n", "\n", - "# SCHEMA, GRADER_MODEL, and INPUT are re-used from our previous Evaluation definition,\n", - "# but let's restate the source and testing criteria again.\n", - "DATA_SOURCE = {\n", - " \"item_schema\": SCHEMA, \n", - " \"include_sample_schema\": True, # Note this change! Needed for data gen.\n", - " \"type\": \"custom\"\n", - "}\n", - "TESTING_CRITERIA = {\n", - " \"name\": \"Auto Sarcasm Grader\",\n", - " \"type\": \"score_model\",\n", - " \"model\": GRADER_MODEL,\n", - " \"input\": INPUT,\n", - " \"range\": [1.0, 10.0],\n", - " \"pass_threshold\": 4.0,\n", - "}\n", - "posttraining_eval = client.evals.create(\n", - " name=f\"sarcasm-posttrain-evaluation-{UNIQUE_ENOUGH_KEY}\",\n", - " data_source_config=DATA_SOURCE,\n", - " testing_criteria=[TESTING_CRITERIA]\n", + "with open(ft_eval_file, \"rb\") as f:\n", + " ft_file = openai_client.files.create(purpose=\"evals\", file=f)\n", + " ft_file = openai_client.files.wait_for_processing(ft_file.id)\n", + "\n", + "base_run = openai_client.evals.runs.create(\n", + " eval_id=grader_eval.id,\n", + " name=f\"base-{UNIQUE_KEY}\",\n", + " data_source={\"type\": \"jsonl\", \"source\": {\"type\": \"file_id\", \"id\": base_file.id}}\n", ")\n", - "print(f\"Created eval {posttraining_eval.id}\")\n", "\n", - "# Now add our runs.\n", - "postraining_runs = []\n", - "for model in POST_EVAL_MODELS:\n", - " RUN_DATA_SOURCE = {\n", - " \"type\": \"completions\",\n", - " \"model\": model,\n", - " \"source\": { \"type\": \"file_id\", \"id\": posttraining_file.id },\n", - " \"input_messages\": {\n", - " \"type\": \"template\",\n", - " \"template\": [\n", - " { \n", - " \"type\": \"message\", \n", - " \"role\": \"system\", \n", - " \"content\": { \"type\": \"input_text\", \"text\": SYSTEM_PROMPT },\n", - " },\n", - " { \n", - " \"type\": \"message\", \n", - " \"role\": \"user\", \n", - " \"content\": { \"type\": \"input_text\", \"text\": \"{{item.question}}\" },\n", - " },\n", - " ],\n", - " },\n", - " }\n", - " run = client.evals.runs.create(\n", - " name=f\"{model}\", \n", - " eval_id=posttraining_eval.id,\n", - " data_source=RUN_DATA_SOURCE, \n", - " )\n", - " print(f\"🏃‍➡️ Created run {run.id} for {posttraining_eval.id}\")\n", - " postraining_runs.append(run)\n" - ] - }, - { - "cell_type": "markdown", - "id": "4de42c84", - "metadata": {}, - "source": [ - "Again, we wait! ⏱️" + "ft_run = openai_client.evals.runs.create(\n", + " eval_id=grader_eval.id,\n", + " name=f\"finetuned-{UNIQUE_KEY}\",\n", + " data_source={\"type\": \"jsonl\", \"source\": {\"type\": \"file_id\", \"id\": ft_file.id}}\n", + ")\n", + "\n", + "print(f\"Base run: {base_run.id}\")\n", + "print(f\"Fine-tuned run: {ft_run.id}\")" ] }, { "cell_type": "code", - "execution_count": 32, - "id": "67769d7d", + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🏃‍➡️ Run ministral-3b-distilled-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4.1-nano-distilled-90f2f57b: completed\n", - "🏃‍➡️ Run gpt-4.1-nano: completed\n", - "🏃‍➡️ Run Ministral-3B: completed\n", - "🏃‍➡️ Run DeepSeek-V3.1: completed\n", - "⏱️ Elapsed time: 1 minutes 44 seconds\n", - "🏁 All 5 runs completed!\n" + "Base: completed\n", + "Fine-tuned: completed\n", + "✓ Evaluations complete\n" ] } ], "source": [ - "# Again, we wait for our runs to finish.\n", - "start_time = time.time()\n", + "# Wait for both\n", + "for run_id, name in [(base_run.id, \"Base\"), (ft_run.id, \"Fine-tuned\")]:\n", + " while True:\n", + " run = openai_client.evals.runs.retrieve(run_id=run_id, eval_id=grader_eval.id)\n", + " if run.status in [\"completed\", \"failed\"]:\n", + " print(f\"{name}: {run.status}\")\n", + " break\n", + " time.sleep(5)\n", "\n", - "while any([r.status not in [\"completed\", \"failed\"] for r in postraining_runs]):\n", - " time.sleep(10)\n", - " clear_output(wait=True)\n", - "\n", - " for i in range(len(postraining_runs)):\n", - " postraining_runs[i] = client.evals.runs.retrieve(eval_id=posttraining_eval.id, run_id=postraining_runs[i].id)\n", - " print(f\"🏃‍➡️ Run {postraining_runs[i].name}: {postraining_runs[i].status}\")\n", - " \n", - " now = time.time()\n", - " print(\"⏱️ Elapsed time: {} minutes {} seconds\".format(int((now - start_time) // 60), int((now - start_time) % 60)))\n", - "\n", - "print(f\"🏁 All {len(postraining_runs)} runs completed!\")" + "print(\"✓ Evaluations complete\")" ] }, { "cell_type": "markdown", - "id": "e482042a", "metadata": {}, "source": [ - "### 📊 Interpreting the Post-Training Results\n", - "Let's first look at _just the new Evaluation_ to see if our new model outperforms its\n", - "competition (`4.1-nano` and `4.1`)." + "## 13. Results" ] }, { "cell_type": "code", - "execution_count": 33, - "id": "ae06ec92", + "execution_count": 36, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Get Evaluation Runs: eval_693996f5adac8191a606b12700d6118f\n", - "\n", - "==================================================\n", - "Combined Evaluation Summary\n", - "==================================================\n", - " Run ID Run Name Model Status Pass Percentage (%) Error Percentage (%) Evaluation ID Evaluation Name\n", - "evalrun_693996f95cb081918c16ae9f8926f64c DeepSeek-V3.1 DeepSeek-V3.1 completed 97.000000 0.0 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_693996f706ec8191b0096ec9a8305ffd gpt-4.1-nano-distilled-90f2f57b gpt-4.1-nano-di completed 83.838384 1.0 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_693996f640588191a6d2723f8d53adb5 ministral-3b-distilled-90f2f57b ministral-3b-di completed 74.000000 0.0 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_693996f83c488191b358c15ae875ec33 Ministral-3B Ministral-3B completed 31.000000 0.0 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_693996f7a04881918725f5a01dfc964b gpt-4.1-nano gpt-4.1-nano completed 26.000000 0.0 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "==================================================\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", - "Fetching scores...\n", + "RESULTS\n", "==================================================\n", + "Baseline (gold): 0.59\n", + "Base model: 0.82 (±0.21)\n", + "Fine-tuned: 0.94 (±0.06)\n", "\n", - "==================================================\n", - "Score Summary Table:\n", - " Model Evaluation Name Average Score Min Score Max Score 10th Percentile 25th Percentile 50th Percentile 75th Percentile 90th Percentile\n", - " DeepSeek-V3.1 sarcasm-posttrain-evaluation-90f2f57b 7.30 1.00 9.00 6.90 7.00 7.50 8.00 8.00\n", - "gpt-4.1-nano-di sarcasm-posttrain-evaluation-90f2f57b 6.26 1.00 8.00 1.00 6.00 7.00 8.00 8.00\n", - "ministral-3b-di sarcasm-posttrain-evaluation-90f2f57b 5.38 1.00 9.00 1.00 3.00 6.00 7.00 8.00\n", - " gpt-4.1-nano sarcasm-posttrain-evaluation-90f2f57b 2.81 1.00 8.00 1.00 1.00 3.00 4.00 6.00\n", - " Ministral-3B sarcasm-posttrain-evaluation-90f2f57b 2.74 1.00 8.00 1.00 1.00 1.00 5.00 7.00\n", - "==================================================\n" + "Improvement: +0.12\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "# Let's visualize our post-training evaluation. Fingers crossed!\n", - "display_evaluation_summary(client, [posttraining_eval.id], x_range=(1, 10))" + "def get_scores(eval_id, run_id):\n", + " items = list(openai_client.evals.runs.output_items.list(run_id=run_id, eval_id=eval_id))\n", + " return [r.score for item in items for r in item.results if r.score is not None]\n", + "\n", + "base_scores = get_scores(grader_eval.id, base_run.id)\n", + "ft_scores = get_scores(grader_eval.id, ft_run.id)\n", + "\n", + "print(\"=\" * 50)\n", + "print(\"RESULTS\")\n", + "print(\"=\" * 50)\n", + "print(f\"Baseline (gold): {np.mean(baseline_scores):.2f}\")\n", + "print(f\"Base model: {np.mean(base_scores):.2f} (±{np.std(base_scores):.2f})\")\n", + "print(f\"Fine-tuned: {np.mean(ft_scores):.2f} (±{np.std(ft_scores):.2f})\")\n", + "print(f\"\\nImprovement: {np.mean(ft_scores) - np.mean(base_scores):+.2f}\")" ] }, { "cell_type": "code", - "execution_count": 34, - "id": "b0bfe89e", + "execution_count": 38, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Get Evaluation Runs: eval_693984204a7c8191b08abdc67b5d5e23\n", - "Get Evaluation Runs: eval_693996f5adac8191a606b12700d6118f\n", - "\n", - "==================================================\n", - "Combined Evaluation Summary\n", - "==================================================\n", - " Run ID Run Name Model Status Pass Percentage (%) Error Percentage (%) Evaluation ID Evaluation Name\n", - "evalrun_693996f95cb081918c16ae9f8926f64c DeepSeek-V3.1 DeepSeek-V3.1 completed 97.000000 0.00 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_69398420f92081919db1b05086cd59ce DeepSeek-V3.1-90f2f57b DeepSeek-V3.1 completed 93.750000 3.00 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_69398421b4308191bc33dfac7567f082 gpt-4.1-90f2f57b gpt-4.1 completed 84.750000 5.25 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_693996f706ec8191b0096ec9a8305ffd gpt-4.1-nano-distilled-90f2f57b gpt-4.1-nano-di completed 83.838384 1.00 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_693984246064819180e8989ca09c597a gpt-4o-mini-90f2f57b gpt-4o-mini completed 80.000000 2.75 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_6939842251f08191b1c8a9e4c5d0b2b1 gpt-4.1-mini-90f2f57b gpt-4.1-mini completed 74.686717 4.00 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_69398423c1008191b859c069dbce521e gpt-4o-90f2f57b gpt-4o completed 74.500000 3.50 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_693996f640588191a6d2723f8d53adb5 ministral-3b-distilled-90f2f57b ministral-3b-di completed 74.000000 0.00 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_693996f83c488191b358c15ae875ec33 Ministral-3B Ministral-3B completed 31.000000 0.00 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "evalrun_6939842511a48191a67a392e04471fc1 Ministral-3B-90f2f57b Ministral-3B completed 29.500000 1.50 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_69398422f7508191a52bfb35d10a2542 gpt-4.1-nano-90f2f57b gpt-4.1-nano completed 27.000000 2.75 eval_693984204a7c8191b08abdc67b5d5e23 sacarsm-baseline-90f2f57b\n", - "evalrun_693996f7a04881918725f5a01dfc964b gpt-4.1-nano gpt-4.1-nano completed 26.000000 0.00 eval_693996f5adac8191a606b12700d6118f sarcasm-posttrain-evaluation-90f2f57b\n", - "==================================================\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==================================================\n", - "Fetching scores...\n", - "==================================================\n", - "\n", - "==================================================\n", - "Score Summary Table:\n", - " Model Evaluation Name Average Score Min Score Max Score 10th Percentile 25th Percentile 50th Percentile 75th Percentile 90th Percentile\n", - " DeepSeek-V3.1 sacarsm-baseline-90f2f57b 7.07 0.00 10.00 5.00 7.00 8.00 8.00 8.00\n", - " gpt-4.1 sacarsm-baseline-90f2f57b 5.80 0.00 9.00 3.00 5.00 6.00 7.00 8.00\n", - " gpt-4o-mini sacarsm-baseline-90f2f57b 5.54 0.00 9.00 3.00 4.00 6.00 7.00 8.00\n", - " gpt-4o sacarsm-baseline-90f2f57b 5.26 0.00 9.00 3.00 3.00 6.00 7.00 8.00\n", - " gpt-4.1-mini sacarsm-baseline-90f2f57b 5.18 0.00 9.00 3.00 3.00 6.00 7.00 8.00\n", - " gpt-4.1-nano sacarsm-baseline-90f2f57b 2.85 0.00 8.00 1.00 1.00 2.00 4.00 6.00\n", - " Ministral-3B sacarsm-baseline-90f2f57b 2.70 0.00 8.00 1.00 1.00 1.00 5.00 7.00\n", - " DeepSeek-V3.1 sarcasm-posttrain-evaluation-90f2f57b 7.30 1.00 9.00 6.90 7.00 7.50 8.00 8.00\n", - "gpt-4.1-nano-di sarcasm-posttrain-evaluation-90f2f57b 6.26 1.00 8.00 1.00 6.00 7.00 8.00 8.00\n", - "ministral-3b-di sarcasm-posttrain-evaluation-90f2f57b 5.38 1.00 9.00 1.00 3.00 6.00 7.00 8.00\n", - " gpt-4.1-nano sarcasm-posttrain-evaluation-90f2f57b 2.81 1.00 8.00 1.00 1.00 3.00 4.00 6.00\n", - " Ministral-3B sarcasm-posttrain-evaluation-90f2f57b 2.74 1.00 8.00 1.00 1.00 1.00 5.00 7.00\n", - "==================================================\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2183,107 +977,64 @@ } ], "source": [ - "# And now let's put it all together.\n", - "# Let's visualize our post-training evaluation. Fingers crossed!\n", - "display_evaluation_summary(client, [baseline_eval.id, posttraining_eval.id], x_range=(1, 10))" - ] - }, - { - "cell_type": "markdown", - "id": "d3af014a", - "metadata": {}, - "source": [ - "## 🥳 7. Celebrate or Cry\n", - "It _should_ be time to celebrate if all went well!\n", - "\n", - "We can clearly see our new models not only outperforming their base models, but\n", - "also competing with larger OpenAI models and DeepSeek!\n" - ] - }, - { - "cell_type": "markdown", - "id": "ea99b11c", - "metadata": {}, - "source": [ - "## 🔚 8. Conclusion\n", - "In this notebook we demonstrated **distillation** using Azure OpenAI *Evaluations*\n", - "and *Fine Tuning* features.\n", - "\n", - "We used an objective of *adjusting the tone* of a model to meet our needs, in this\n", - "case making its responses sarcastic, while preserving accuracy in results, and\n", - "*distilled* the native capabilities of a state-of-the-art reasoning model (`o3`)\n", - "into a much smaller, non-reasoning model (`4.1-nano`) to let our agent or app\n", - "use the smallest model possible while:\n", + "# Visualize\n", + "fig, ax = plt.subplots(figsize=(8, 5))\n", "\n", - "- 🤑 minimizing per-token costs\n", - "- 🏎️ improve performance (latency)\n", + "models = ['Baseline', 'Base Model', 'Fine-Tuned']\n", + "avgs = [np.mean(baseline_scores), np.mean(base_scores), np.mean(ft_scores)]\n", + "colors = ['#e74c3c', '#3498db', '#2ecc71']\n", "\n", - "We did all this:\n", + "bars = ax.bar(models, avgs, color=colors)\n", + "ax.set_ylabel('Sarcasm Score')\n", + "ax.set_title('Model Comparison')\n", + "ax.set_ylim(0, 1)\n", "\n", - "- without creating training data directly\n", - "- without knowing the ideal student model\n", - "- only by knowing how to define our Grader\n", + "for bar, v in zip(bars, avgs):\n", + " ax.text(bar.get_x() + bar.get_width()/2, v + 0.2, f'{v:.1f}', ha='center', fontweight='bold')\n", "\n", - "So to wrap it all up:\n", - "\n", - "1. We described the ideal state to our complex reasoning model in the form of\n", - " a few samples we feel are ideal.\n", - "2. We described to the reasoning model (grader) how to judge those examples\n", - " to measure their quality.\n", - "3. We let Evaluations and Fine Tuning do the rest!\n", - "\n", - "\n" + "plt.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "080fdd24", "metadata": {}, "source": [ - "## 🧹 9. Cleanup\n", - "If you want to clean up everthing from this notebook, set `cleanup = True` below." + "## 14. Cleanup" ] }, { "cell_type": "code", - "execution_count": null, - "id": "fad63a77", + "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "deleting ministral-3b-distilled-90f2f57b...\n", - "deleted!\n", - "deleting gpt-4.1-nano-distilled-90f2f57b...\n", - "deleted!\n" + "Deleted: training_sarcasm_4aa88349.jsonl\n", + "Deleted: validation_sarcasm_4aa88349.jsonl\n", + "Deleted: base_eval_4aa88349.jsonl\n", + "Deleted: ft_eval_4aa88349.jsonl\n", + "\n", + "✓ Cleanup complete\n" ] } ], "source": [ - "# Want to clean up your mess? \n", - "cleanup = True\n", + "# Clean up local files\n", + "for f in [training_file_path, validation_file_path, base_eval_file, ft_eval_file]:\n", + " if os.path.exists(f):\n", + " os.remove(f)\n", + " print(f\"Deleted: {f}\")\n", "\n", - "if cleanup:\n", - " # for now, we delete the model deployments as they may incur charges\n", - " for name in [d[\"name\"] for d in DEPLOYMENT_CONFIGURATION]:\n", - " print(f\"deleting {name}...\")\n", - " poller = cogsvc_client.deployments.begin_delete(\n", - " resource_group_name=os.environ.get(\"AZURE_RESOURCE_GROUP\"),\n", - " account_name=os.environ.get(\"FOUNDRY_PARENT_RESOURCE\"),\n", - " deployment_name=name,\n", - " )\n", - " while not poller.done():\n", - " time.sleep(5)\n", - " print(f\"deleted!\")\n", - " # todo: delete training data files" + "print(\"\\n✓ Cleanup complete\")" ] } ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": ".venv (3.12.3)", "language": "python", "name": "python3" }, @@ -2297,9 +1048,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.12.3" } }, "nbformat": 4, - "nbformat_minor": 5 + "nbformat_minor": 4 } diff --git a/Demos/DistillingSarcasm/scripts/eval_utils.py b/Demos/DistillingSarcasm/scripts/eval_utils.py deleted file mode 100644 index 14e32f9..0000000 --- a/Demos/DistillingSarcasm/scripts/eval_utils.py +++ /dev/null @@ -1,254 +0,0 @@ -# Original version from: -# https://raw.githubusercontent.com/azure-ai-foundry/build-2025-demos/refs/heads/main/Azure%20AI%20Model%20Customization/DistillationDemo/scripts/eval_utils.py -import openai -import pandas as pd -import matplotlib.pyplot as plt -import numpy as np # Import numpy for percentile calculations - -from concurrent.futures import ThreadPoolExecutor, as_completed - -def get_eval_runs_list(client: openai.Client, eval_id: str) -> list: - """ - Fetch the list of evaluation runs for a given evaluation ID. - - Args: - eval_id (str): The evaluation ID. - - Returns: - list: A list of evaluation runs with their details. - """ - runs = client.evals.runs.list(eval_id) - - print(f"Get Evaluation Runs: {eval_id}") - list_runs = [] - - if runs: - for run in runs: - r = { - 'id': run.id, - 'name': run.name, - 'status': run.status, - 'model': run.model, - 'pass_percentage': 0, - 'error_percentage': 0, - } - result = run.result_counts - if result: - pass_percentage = (result.passed * 100) / (result.passed + result.failed) if (result.passed + result.failed) > 0 else 0 - error_percentage = (result.errored * 100) / result.total if result.total > 0 else 0 - r['pass_percentage'] = pass_percentage - r['error_percentage'] = error_percentage - - list_runs.append(r) - - return list_runs - - -def get_eval_details(client: openai.Client, eval_id: str) -> dict: - """ - Fetch the details of a specific evaluation. - - Args: - eval_id (str): The evaluation ID. - - Returns: - dict: A dictionary containing evaluation details, including the name. - """ - try: - eval = client.evals.retrieve(eval_id) - return eval.to_dict() - except Exception as e: - print(f"Failed to fetch evaluation details for ID: {eval_id}. Error: {e}") - return {"name": f"Unknown Evaluation ({eval_id})"} - - -def display_evaluation_summary(client: openai.Client, eval_ids: list, x_range = (0, 7)): - """ - Fetch and display a summary of evaluation runs for a list of evaluation IDs, including a horizontal bar chart, - average score, and score distribution for all runs in a single chart with a maximum of 4 graphs per row. - - Args: - eval_ids (list): A list of evaluation IDs. - """ - all_eval_runs = [] - eval_id_to_name = {} - eval_id_to_color = {} - - # Assign unique colors for each evaluation ID - colors = plt.cm.tab10.colors # Use a colormap for distinct colors - for i, eval_id in enumerate(eval_ids): - eval_id_to_color[eval_id] = colors[i % len(colors)] - - # Fetch evaluation runs and details for each evaluation ID - for eval_id in eval_ids: - eval_runs = get_eval_runs_list(client, eval_id) - - # Fetch evaluation details using the helper method - eval_details = get_eval_details(client, eval_id) - eval_name = eval_details.get('name', f'Unknown Evaluation ({eval_id})') - eval_id_to_name[eval_id] = eval_name - - # Add evaluation ID to each run for color coding - for run in eval_runs: - run['eval_id'] = eval_id - all_eval_runs.append(run) - - # Combine all evaluation runs into a single DataFrame - if all_eval_runs: - df = pd.DataFrame(all_eval_runs) - df = df[['id', 'name', 'model', 'status', 'pass_percentage', 'error_percentage', 'eval_id']] # Select relevant columns - df['eval_name'] = df['eval_id'].map(eval_id_to_name) # Map eval_id to eval_name - df['model'] = df['model'].str[:15] # Truncate model names to 15 characters - df = df.sort_values(by=['pass_percentage'], ascending=[False]) # Sort by pass_percentage descending - - print("\n" + "=" * 50) - print("Combined Evaluation Summary") - print("=" * 50) - print(df.to_string(index=False, header=["Run ID", "Run Name", "Model", "Status", "Pass Percentage (%)", "Error Percentage (%)", "Evaluation ID", "Evaluation Name"])) - print("=" * 50) - - # Dynamically adjust the figure height based on the number of rows - num_rows = len(df) - fig_height = max(3, num_rows * 0.5) # Set a minimum height of 6 and scale with 0.5 per row - - - # Create a horizontal bar chart with rows sorted by pass percentage across all eval_ids - plt.figure(figsize=(12, fig_height)) - - df['display_label'] = df['model'].where( - (df['model'].str.strip() != '') & (df['model'] != 'None') & (df['model'].notna()), - df['name'] - ) - - plt.barh( - df['display_label'], - df['pass_percentage'], - color=[eval_id_to_color[eval_id] for eval_id in df['eval_id']], - edgecolor='black' - ) - plt.xlabel('Pass Percentage (%)') - plt.ylabel('Model') - plt.title("Pass Percentage by Model Across Evaluations") - plt.xlim(0, 100) # Set x-axis scale explicitly to 0-100 - plt.gca().invert_yaxis() # Invert y-axis to show the highest percentage at the top - plt.grid(axis='x', linestyle='--', alpha=0.7) - plt.tight_layout() - plt.show() - - # Process each run to calculate and collect scores for distribution - # (This part can be slow as we have to page over results for each run, so we parallelize this.) - all_scores = [] - run_labels = [] - score_summary = [] # To store data for the summary table - - print("=" * 50) - print("Fetching scores...") - print("=" * 50) - - futures = {} # dict of "future: (model, eval_id)" so we can easily access which model powered the run. - with ThreadPoolExecutor(thread_name_prefix="eval-run-fetcher") as pool: - for _, row in df.iterrows(): - run_id = row['id'] - eval_id = row['eval_id'] - future = pool.submit(get_eval_run_output_items, client, eval_id, run_id) - futures.update({ future: (row['model'] , eval_id)}) - - for f in as_completed(futures.keys()): - try: - model, eval_id = futures[f] - scores = f.result() - except Exception as e: - print(f"exception fetching future result: {e}") - scores = None - if scores: - avg_score = sum(scores) / len(scores) - min_score = min(scores) - max_score = max(scores) - p10 = np.percentile(scores, 10) # 10th percentile - p25 = np.percentile(scores, 25) # 25th percentile - p50 = np.percentile(scores, 50) # 50th percentile (median) - p75 = np.percentile(scores, 75) # 75th percentile - p90 = np.percentile(scores, 90) # 90th percentile - - # Collect scores and labels for the combined chart - all_scores.append((scores, eval_id_to_color[eval_id])) # Include color for the subplot - run_labels.append(f"{model} ({eval_id_to_name[eval_id]})") # Include eval name in the label - - # Add data to the summary table - score_summary.append({ - "Model": model, - "Evaluation Name": eval_id_to_name[eval_id], - "Average Score": f"{avg_score:.2f}", - "Min Score": f"{min_score:.2f}", - "Max Score": f"{max_score:.2f}", - "10th Percentile": f"{p10:.2f}", - "25th Percentile": f"{p25:.2f}", - "50th Percentile": f"{p50:.2f}", - "75th Percentile": f"{p75:.2f}", - "90th Percentile": f"{p90:.2f}" - }) - - # Display the score summary as a table - if score_summary: - score_df = pd.DataFrame(score_summary) - score_df = score_df.sort_values(by=['Evaluation Name', 'Average Score'], ascending=[True, False]) # Sort by eval_name and avg_score - print("\n" + "=" * 50) - print("Score Summary Table:") - print(score_df.to_string(index=False)) - print("=" * 50) - - # Plot all score distributions in a single chart with a maximum of 4 graphs per row - if all_scores: - num_runs = len(all_scores) - max_cols = 4 # Maximum number of graphs per row - num_rows = (num_runs + max_cols - 1) // max_cols # Calculate the number of rows - - _, axes = plt.subplots(num_rows, max_cols, figsize=(5 * max_cols, 4 * num_rows), sharey=True) - axes = axes.flatten() # Flatten the axes array for easier indexing - - for i, ((scores, color), label) in enumerate(zip(all_scores, run_labels)): - ax = axes[i] - ax.hist(scores, bins=10, color=color, edgecolor='black') # Use color for the histogram - ax.set_title(label, fontsize=10) # Include model and evaluation name - ax.set_xlabel("Score") - ax.set_ylabel("Frequency") - ax.set_xlim(x_range[0], x_range[1]) # Fix the x-axis range between 0 and 7 - ax.grid(axis='y', linestyle='--', alpha=0.7) - - # Hide any unused subplots - for j in range(len(all_scores), len(axes)): - axes[j].axis('off') - - plt.tight_layout() - plt.suptitle("Score Distributions for each Model", fontsize=16, y=1.02) - plt.show() - else: - print("\n" + "=" * 50) - print("No evaluation runs found for the provided Evaluation IDs.") - print("=" * 50) - - -def get_eval_run_output_items(client: openai.Client, eval_id: str, run_id: str) -> list: - """ - Fetch the output items for a specific evaluation run and extract the result scores. - - Args: - eval_id (str): The evaluation ID. - run_id (str): The run ID. - - Returns: - list: A list of scores for the output items. - """ - scores = [] - - try: - response = client.evals.runs.output_items.list(run_id=run_id, eval_id=eval_id) - for page in response.iter_pages(): - for item in page.data: - for result in item.results: - if result.score is not None: - scores.append(result.score) - except Exception as e: - print(f"Failed to fetch output items for run {run_id}. Error: {e}") - - return scores diff --git a/Demos/DistillingSarcasm_Foundry/.gitignore b/Demos/DistillingSarcasm_Foundry/.gitignore deleted file mode 100644 index b9a371e..0000000 --- a/Demos/DistillingSarcasm_Foundry/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -.env -.venv/ -__pycache__/ -*.pyc -.ipynb_checkpoints/ diff --git a/Demos/DistillingSarcasm_Foundry/README.md b/Demos/DistillingSarcasm_Foundry/README.md deleted file mode 100644 index cf0d904..0000000 --- a/Demos/DistillingSarcasm_Foundry/README.md +++ /dev/null @@ -1,152 +0,0 @@ -# Distilling Sarcasm - Foundry SDK Version - -This is an alternative implementation of the Sarcasm distillation demo using the **Azure AI Foundry SDK** instead of raw API keys. - -## Overview - -This demo teaches language models to generate sarcastic responses through distillation: -1. A **teacher model** (gpt-4.1) generates sarcastic training data -2. A **student model** (gpt-4.1-mini) is fine-tuned on this data -3. Evaluators measure sarcasm quality before and after training - -## SDK Comparison - -| Aspect | Original (API Key) | This Version (Foundry SDK) | -|--------|-------------------|---------------------------| -| **Package** | `openai` | `azure-ai-projects` + `openai` | -| **Auth** | API Key | `DefaultAzureCredential` | -| **Inference** | `client.chat.completions.create()` | `openai_client.chat.completions.create()` | -| **Evaluations** | `client.evals.*` | `openai_client.evals.*` (same!) | -| **Fine-tuning** | `client.fine_tuning.jobs.*` | `openai_client.fine_tuning.jobs.*` (same!) | - -**Key Insight**: The APIs are nearly identical! The main difference is how you get the client: - -```python -# Original (API Key) -client = OpenAI(base_url=..., api_key=...) - -# Foundry SDK -project_client = AIProjectClient(endpoint=..., credential=DefaultAzureCredential()) -openai_client = project_client.get_openai_client() # Same API from here! -``` - -## Prerequisites - -1. **Azure Subscription** with access to Azure AI Foundry -2. **Python 3.10+** -3. **Azure CLI** logged in (`az login`) - -## Setup - -1. Create and activate a virtual environment: - ```bash - python -m venv .venv - source .venv/bin/activate # Linux/Mac - # or: .venv\Scripts\activate # Windows - ``` - -2. Install dependencies: - ```bash - pip install -r requirements.txt - ``` - -3. Copy the environment template and fill in your values: - ```bash - cp .env.template .env - ``` - -4. Configure `.env`: - ``` - MICROSOFT_FOUNDRY_PROJECT_ENDPOINT=https://.services.ai.azure.com/api/projects/ - AZURE_INFERENCE_ENDPOINT=https://..models.ai.azure.com - AZURE_OPENAI_DEPLOYMENT=gpt-4.1 - AZURE_SUBSCRIPTION_ID= - AZURE_RESOURCE_GROUP= - AZURE_AOAI_ACCOUNT= - BASE_MODEL=gpt-4.1-mini - TEACHER_MODEL=gpt-4.1 - ``` - -## Running the Demo - -Open `sarcasm_foundry.ipynb` in Jupyter and execute cells in order: - -```bash -jupyter notebook sarcasm_foundry.ipynb -``` - -## Key Differences from Original - -### Authentication -```python -# Original (API Key) -client = OpenAI( - base_url=f"https://{resource}.openai.azure.com/openai/v1/", - api_key=os.environ.get("FOUNDRY_API_KEY"), -) - -# Foundry SDK (Azure Credential) -credential = DefaultAzureCredential() -project_client = AIProjectClient(endpoint=endpoint, credential=credential) -openai_client = project_client.get_openai_client() -``` - -### Inference -```python -# Original (OpenAI SDK) -response = client.chat.completions.create( - model="gpt-4.1", - messages=[{"role": "user", "content": "Hello"}] -) - -# Foundry SDK (azure-ai-inference) -from azure.ai.inference import ChatCompletionsClient -from azure.ai.inference.models import UserMessage - -client = ChatCompletionsClient(endpoint=..., credential=credential) -response = client.complete(messages=[UserMessage(content="Hello")]) -``` - -### Evaluations (Same API!) -```python -# Both demos use identical evals API -eval = openai_client.evals.create(name="sarcasm-grader", ...) -run = openai_client.evals.runs.create(eval_id=eval.id, ...) -``` - -### Trade-offs - -**Foundry SDK Advantages:** -- ✅ No API keys to manage (uses Azure managed identity) -- ✅ Better security with DefaultAzureCredential -- ✅ Consistent with other Azure AI services -- ✅ Unified project management - -**Original (API Key) Advantages:** -- ✅ Simpler setup (just one API key) -- ✅ Works outside Azure environments -- ✅ Familiar OpenAI SDK patterns - -## Troubleshooting - -### Authentication Issues -- Ensure you're logged in: `az login` -- Check your role assignments include "Azure AI User" on the Foundry resource - -### Model Not Found -- Verify the model deployment names in your `.env` match your Azure deployments - -### Rate Limiting -- Reduce `sample_size` in evaluation cells if hitting rate limits - -## Files - -- `sarcasm_foundry.ipynb` - Main notebook -- `requirements.txt` - Python dependencies -- `.env.template` - Environment variable template -- `README.md` - This file - -## Related - -- [Original Sarcasm Demo](../DistillingSarcasm/) - Uses OpenAI SDK with API keys -- [CNN DailyMail Demo](../SFT_CNN_DailyMail/) - SFT example using Foundry SDK diff --git a/Demos/DistillingSarcasm_Foundry/requirements.txt b/Demos/DistillingSarcasm_Foundry/requirements.txt deleted file mode 100644 index 677bc62..0000000 --- a/Demos/DistillingSarcasm_Foundry/requirements.txt +++ /dev/null @@ -1,19 +0,0 @@ -# Azure AI Foundry SDK -azure-ai-projects>=2.0.0b1 - -# Azure Authentication -azure-identity - -# Azure Cognitive Services for model deployment -azure-mgmt-cognitiveservices - -# OpenAI SDK (obtained via Foundry client) -openai - -# Data manipulation and visualization -pandas -matplotlib -numpy - -# Core utilities -python-dotenv diff --git a/Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb b/Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb deleted file mode 100644 index 027a3a7..0000000 --- a/Demos/DistillingSarcasm_Foundry/sarcasm_foundry.ipynb +++ /dev/null @@ -1,1056 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Distilling Sarcasm (Foundry SDK Version)\n", - "\n", - "This notebook demonstrates fine-tuning language models to generate sarcastic responses using the **Azure AI Foundry SDK**.\n", - "\n", - "## Comparison with Original Demo\n", - "\n", - "| Aspect | Original | Foundry SDK |\n", - "|--------|----------|-------------|\n", - "| Auth | API Key | DefaultAzureCredential |\n", - "| Inference | `client.chat.completions` | `openai_client.responses` |\n", - "| Evaluations | `client.evals.*` | `openai_client.evals.*` (same!) |\n", - "| Fine-tuning | `client.fine_tuning.jobs.*` | `openai_client.fine_tuning.jobs.*` (same!) |\n", - "\n", - "**Key Insight**: The APIs are nearly identical! The main difference is authentication:\n", - "- Original: `OpenAI(base_url=..., api_key=...)`\n", - "- Foundry: `AIProjectClient(endpoint, credential).get_openai_client()`\n", - "\n", - "**Note**: Foundry project endpoints use `responses.create()` API for inference." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Setup" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install -r requirements.txt -q" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Libraries imported successfully\n" - ] - } - ], - "source": [ - "import os\n", - "import json\n", - "import uuid\n", - "import time\n", - "from random import shuffle\n", - "\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "from dotenv import load_dotenv\n", - "from azure.identity import DefaultAzureCredential\n", - "from azure.ai.projects import AIProjectClient\n", - "\n", - "print(\"Libraries imported successfully\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Connect to Microsoft Foundry" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run identifier: 4aa88349\n", - "Project: https://omi-ignite-demo-resource.services.ai.azure.com/api/projects/omi-ignite-demo\n" - ] - } - ], - "source": [ - "load_dotenv(override=True)\n", - "\n", - "# Required for Azure OpenAI client\n", - "os.environ.setdefault(\"OPENAI_API_VERSION\", \"2025-03-01-preview\")\n", - "\n", - "project_endpoint = os.environ.get(\"MICROSOFT_FOUNDRY_PROJECT_ENDPOINT\")\n", - "model_deployment = os.environ.get(\"AZURE_OPENAI_DEPLOYMENT\", \"gpt-4.1\")\n", - "base_model = os.environ.get(\"BASE_MODEL\", \"gpt-4.1-mini\")\n", - "teacher_model = os.environ.get(\"TEACHER_MODEL\", \"gpt-4.1\")\n", - "\n", - "UNIQUE_KEY = str(uuid.uuid4()).split(\"-\")[0]\n", - "print(f\"Run identifier: {UNIQUE_KEY}\")\n", - "print(f\"Project: {project_endpoint}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Connected to Microsoft Foundry\n" - ] - } - ], - "source": [ - "# Create clients - this is the KEY difference from original demo\n", - "credential = DefaultAzureCredential()\n", - "project_client = AIProjectClient(endpoint=project_endpoint, credential=credential)\n", - "openai_client = project_client.get_openai_client()\n", - "\n", - "print(\"✓ Connected to Microsoft Foundry\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Load Baseline Data" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded 20 baseline examples\n", - "\n", - "Sample:\n", - "Q: Who discovered Antarctica?\n", - "A: Some chaps named Fabian Gottlieb von Bellingshausen and Mikhail Lazarev, as if they don't teach that in every school!\n" - ] - } - ], - "source": [ - "baseline_data = []\n", - "with open(\"../DistillingSarcasm/baseline.jsonl\", \"r\") as f:\n", - " for line in f:\n", - " baseline_data.append(json.loads(line))\n", - "\n", - "print(f\"Loaded {len(baseline_data)} baseline examples\")\n", - "print(f\"\\nSample:\")\n", - "print(f\"Q: {baseline_data[0]['question']}\")\n", - "print(f\"A: {baseline_data[0]['answer']}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Define Sarcasm Grader" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Grader prompt defined\n" - ] - } - ], - "source": [ - "GRADER_PROMPT = \"\"\"\n", - "You are a connoisseur of finely crafted sarcasm. Your job is to evaluate a\n", - "question and answer pair and score it based on how sarcastic the answer is.\n", - "\n", - "# Guidelines\n", - " * Output ONLY a score.\n", - " * A score of 0 means the answer is not sarcastic at all.\n", - " * A score of 5 means the answer is moderately sarcastic.\n", - " * A score of 10 means the answer is dripping with sarcasm.\n", - "\n", - "# Scoring Features\n", - " * Exaggeration or overstatement of the obvious\n", - " * Rhetorical questions that mock the original question\n", - " * Use of phrases like \"Oh really?\", \"Shocking!\", \"Who knew?\"\n", - " * Intentional understatement for comedic effect\n", - " * Irony where literal meaning differs from intended meaning\n", - " * The answer must still be factually correct\n", - "\n", - "# Output Format\n", - "Provide ONLY a single decimal number between 0 and 1.\n", - "\"\"\"\n", - "\n", - "USER_PROMPT = \"\"\"\n", - "Q: {{item.question}}\n", - "A: {{item.answer}}\n", - "\"\"\"\n", - "\n", - "print(\"Grader prompt defined\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Create Evaluation (Same API as Original!)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Eval file: file-185f7d1d42464c4f91996a2442505ccb\n" - ] - } - ], - "source": [ - "# Upload baseline for evaluation\n", - "with open(\"../DistillingSarcasm/baseline.jsonl\", \"rb\") as f:\n", - " grader_eval_file = openai_client.files.create(purpose=\"evals\", file=f)\n", - " grader_eval_file = openai_client.files.wait_for_processing(grader_eval_file.id)\n", - "\n", - "print(f\"✓ Eval file: {grader_eval_file.id}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluation criteria defined\n" - ] - } - ], - "source": [ - "# Define evaluation schema\n", - "data_source_config = {\n", - " \"type\": \"custom\",\n", - " \"item_schema\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"question\": {\"type\": \"string\"},\n", - " \"answer\": {\"type\": \"string\"}\n", - " },\n", - " \"required\": [\"question\", \"answer\"]\n", - " }\n", - "}\n", - "\n", - "# Define grader as testing criteria\n", - "testing_criteria = [\n", - " {\n", - " \"type\": \"score_model\",\n", - " \"name\": \"sarcasm_score\",\n", - " \"model\": model_deployment,\n", - " \"input\": [\n", - " {\"role\": \"system\", \"content\": GRADER_PROMPT},\n", - " {\"role\": \"user\", \"content\": USER_PROMPT}\n", - " ],\n", - " \"pass_threshold\": 0.5\n", - " }\n", - "]\n", - "\n", - "print(\"Evaluation criteria defined\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Evaluation: eval_d341bcecf17245e48c9131906b3b73fc\n" - ] - } - ], - "source": [ - "# Create evaluation\n", - "grader_eval = openai_client.evals.create(\n", - " name=f\"sarcasm-grader-{UNIQUE_KEY}\",\n", - " data_source_config=data_source_config,\n", - " testing_criteria=testing_criteria\n", - ")\n", - "\n", - "print(f\"✓ Evaluation: {grader_eval.id}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Eval run: evalrun_730150a66c8343c8a62edbbf95b75a4d\n" - ] - } - ], - "source": [ - "# Run evaluation on baseline\n", - "grader_run = openai_client.evals.runs.create(\n", - " eval_id=grader_eval.id,\n", - " name=f\"baseline-{UNIQUE_KEY}\",\n", - " data_source={\n", - " \"type\": \"jsonl\",\n", - " \"source\": {\"type\": \"file_id\", \"id\": grader_eval_file.id}\n", - " }\n", - ")\n", - "\n", - "print(f\"✓ Eval run: {grader_run.id}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Waiting for evaluation...\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: in_progress\n", - " Status: completed\n", - "\n", - "✓ completed!\n", - " Passed: 19/20\n" - ] - } - ], - "source": [ - "# Wait for completion\n", - "print(\"Waiting for evaluation...\")\n", - "while True:\n", - " run = openai_client.evals.runs.retrieve(run_id=grader_run.id, eval_id=grader_eval.id)\n", - " print(f\" Status: {run.status}\")\n", - " if run.status in [\"completed\", \"failed\"]:\n", - " break\n", - " time.sleep(5)\n", - "\n", - "print(f\"\\n✓ {run.status}!\")\n", - "if run.result_counts:\n", - " print(f\" Passed: {run.result_counts.passed}/{run.result_counts.total}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Baseline Sarcasm Scores:\n", - " Average: 0.59\n", - " Std Dev: 0.15\n" - ] - } - ], - "source": [ - "# Get scores\n", - "output_items = list(openai_client.evals.runs.output_items.list(run_id=grader_run.id, eval_id=grader_eval.id))\n", - "baseline_scores = [r.score for item in output_items for r in item.results if r.score is not None]\n", - "\n", - "print(f\"Baseline Sarcasm Scores:\")\n", - "print(f\" Average: {np.mean(baseline_scores):.2f}\")\n", - "print(f\" Std Dev: {np.std(baseline_scores):.2f}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 6. Test Inference" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Q: What is the capital of France?\n", - "A: Oh, what a stumper! The capital of France? Let me consult my ancient scrolls... Oh wait, it’s Paris. You know, the city with the Eiffel Tower, baguettes, and a population of people who perfected the art of looking unimpressed. Paris is the answer you’re searching for, unless France has pulled a fast one overnight.\n" - ] - } - ], - "source": [ - "SARCASM_SYSTEM_PROMPT = \"\"\"You are a sarcastically witty assistant. Answer questions with \n", - "biting wit while remaining factually correct. Channel your inner comedian who's \n", - "slightly annoyed at obvious questions.\"\"\"\n", - "\n", - "def generate_response(question: str, model: str = None) -> str:\n", - " \"\"\"Generate a sarcastic response using responses API.\"\"\"\n", - " response = openai_client.responses.create(\n", - " model=model or teacher_model,\n", - " instructions=SARCASM_SYSTEM_PROMPT,\n", - " input=question,\n", - " temperature=0.7,\n", - " max_output_tokens=150\n", - " )\n", - " return response.output_text\n", - "\n", - "# Test\n", - "test_q = \"What is the capital of France?\"\n", - "print(f\"Q: {test_q}\")\n", - "print(f\"A: {generate_response(test_q)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 7. Load Q&A Data" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training: 250, Validation: 250\n" - ] - } - ], - "source": [ - "qa_data = []\n", - "with open(\"../DistillingSarcasm/qa.jsonl\", \"r\") as f:\n", - " for line in f:\n", - " qa_data.append(json.loads(line))\n", - "\n", - "shuffle(qa_data)\n", - "split_idx = len(qa_data) // 2\n", - "training_questions = qa_data[:split_idx]\n", - "validation_questions = qa_data[split_idx:]\n", - "\n", - "print(f\"Training: {len(training_questions)}, Validation: {len(validation_questions)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 8. Generate Training Data" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating 50 training examples...\n", - " 10/50...\n", - " 20/50...\n", - " 30/50...\n", - " 40/50...\n", - " 50/50...\n", - "\n", - "Generating 25 validation examples...\n", - "\n", - "✓ Generated 50 training, 25 validation\n" - ] - } - ], - "source": [ - "MAX_TRAINING = 50\n", - "MAX_VALIDATION = 25\n", - "\n", - "print(f\"Generating {MAX_TRAINING} training examples...\")\n", - "training_data = []\n", - "for i, item in enumerate(training_questions[:MAX_TRAINING]):\n", - " response = generate_response(item['question'])\n", - " training_data.append({\n", - " \"messages\": [\n", - " {\"role\": \"system\", \"content\": SARCASM_SYSTEM_PROMPT},\n", - " {\"role\": \"user\", \"content\": item['question']},\n", - " {\"role\": \"assistant\", \"content\": response}\n", - " ]\n", - " })\n", - " if (i + 1) % 10 == 0:\n", - " print(f\" {i + 1}/{MAX_TRAINING}...\")\n", - "\n", - "print(f\"\\nGenerating {MAX_VALIDATION} validation examples...\")\n", - "validation_data = []\n", - "for item in validation_questions[:MAX_VALIDATION]:\n", - " response = generate_response(item['question'])\n", - " validation_data.append({\n", - " \"messages\": [\n", - " {\"role\": \"system\", \"content\": SARCASM_SYSTEM_PROMPT},\n", - " {\"role\": \"user\", \"content\": item['question']},\n", - " {\"role\": \"assistant\", \"content\": response}\n", - " ]\n", - " })\n", - "\n", - "print(f\"\\n✓ Generated {len(training_data)} training, {len(validation_data)} validation\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ training_sarcasm_4aa88349.jsonl\n", - "✓ validation_sarcasm_4aa88349.jsonl\n" - ] - } - ], - "source": [ - "# Save files\n", - "training_file_path = f\"training_sarcasm_{UNIQUE_KEY}.jsonl\"\n", - "validation_file_path = f\"validation_sarcasm_{UNIQUE_KEY}.jsonl\"\n", - "\n", - "with open(training_file_path, \"w\") as f:\n", - " for item in training_data:\n", - " f.write(json.dumps(item) + \"\\n\")\n", - "\n", - "with open(validation_file_path, \"w\") as f:\n", - " for item in validation_data:\n", - " f.write(json.dumps(item) + \"\\n\")\n", - "\n", - "print(f\"✓ {training_file_path}\")\n", - "print(f\"✓ {validation_file_path}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 9. Fine-Tune Model" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training: file-e457cb500c77408db3a563f2dcfa986f\n", - "Validation: file-b7d2cf189fb9422eb9e57a5c454d7531\n", - "✓ Files ready\n" - ] - } - ], - "source": [ - "# Upload files\n", - "with open(training_file_path, \"rb\") as f:\n", - " train_file = openai_client.files.create(file=f, purpose=\"fine-tune\")\n", - "\n", - "with open(validation_file_path, \"rb\") as f:\n", - " val_file = openai_client.files.create(file=f, purpose=\"fine-tune\")\n", - "\n", - "print(f\"Training: {train_file.id}\")\n", - "print(f\"Validation: {val_file.id}\")\n", - "\n", - "openai_client.files.wait_for_processing(train_file.id)\n", - "openai_client.files.wait_for_processing(val_file.id)\n", - "print(\"✓ Files ready\")" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Job: ftjob-cbccca9eb73d4da991b925d045133219\n", - " Status: pending\n" - ] - } - ], - "source": [ - "# Create fine-tuning job\n", - "fine_tune_job = openai_client.fine_tuning.jobs.create(\n", - " model=base_model,\n", - " training_file=train_file.id,\n", - " validation_file=val_file.id,\n", - " method={\n", - " \"type\": \"supervised\",\n", - " \"supervised\": {\n", - " \"hyperparameters\": {\n", - " \"n_epochs\": 3,\n", - " \"batch_size\": 1,\n", - " \"learning_rate_multiplier\": 1.0\n", - " }\n", - " }\n", - " },\n", - " extra_body={\"trainingType\": \"Standard\"},\n", - " suffix=f\"sarcasm-{UNIQUE_KEY}\"\n", - ")\n", - "\n", - "print(f\"✓ Job: {fine_tune_job.id}\")\n", - "print(f\" Status: {fine_tune_job.status}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 10. Monitor Training" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job: ftjob-71e2eea33ecd4d4e990c54ed09ada149\n", - "Status: succeeded\n", - "Model: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n" - ] - } - ], - "source": [ - "# Check status\n", - "job_id = fine_tune_job.id\n", - "job = openai_client.fine_tuning.jobs.retrieve(job_id)\n", - "print(f\"Job: {job.id}\")\n", - "print(f\"Status: {job.status}\")\n", - "if job.fine_tuned_model:\n", - " print(f\"Model: {job.fine_tuned_model}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Waiting for fine-tuning...\n", - " [00:00] succeeded\n", - "\n", - "✓ Model: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n" - ] - } - ], - "source": [ - "# Wait for completion (can take 10-30 min)\n", - "print(\"Waiting for fine-tuning...\")\n", - "start_time = time.time()\n", - "\n", - "while True:\n", - " job = openai_client.fine_tuning.jobs.retrieve(job_id)\n", - " elapsed = int(time.time() - start_time)\n", - " print(f\" [{elapsed//60:02d}:{elapsed%60:02d}] {job.status}\")\n", - " \n", - " if job.status in [\"succeeded\", \"failed\", \"cancelled\"]:\n", - " break\n", - " time.sleep(30)\n", - "\n", - "if job.status == \"succeeded\":\n", - " fine_tuned_model_id = job.fine_tuned_model\n", - " print(f\"\\n✓ Model: {fine_tuned_model_id}\")\n", - "else:\n", - " print(f\"\\n✗ {job.status}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 11. Deploy Model" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Deploying: gpt-4.1-mini-2025-04-14.ft-71e2eea33ecd4d4e990c54ed09ada149-sarcasm-bc6d797e\n", - "✓ Deployed: sarcasm-ft-4aa88349\n" - ] - } - ], - "source": [ - "from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient\n", - "from azure.mgmt.cognitiveservices.models import Deployment, DeploymentProperties, DeploymentModel, Sku\n", - "\n", - "subscription_id = os.environ.get(\"AZURE_SUBSCRIPTION_ID\")\n", - "resource_group = os.environ.get(\"AZURE_RESOURCE_GROUP\")\n", - "account_name = os.environ.get(\"AZURE_AOAI_ACCOUNT\")\n", - "\n", - "deployment_name = f\"sarcasm-ft-{UNIQUE_KEY}\"\n", - "\n", - "with CognitiveServicesManagementClient(credential=credential, subscription_id=subscription_id) as mgmt:\n", - " deployment_model = DeploymentModel(format=\"OpenAI\", name=fine_tuned_model_id, version=\"1\")\n", - " deployment_properties = DeploymentProperties(model=deployment_model)\n", - " deployment_sku = Sku(name=\"GlobalStandard\", capacity=50)\n", - " deployment_config = Deployment(properties=deployment_properties, sku=deployment_sku)\n", - " \n", - " print(f\"Deploying: {fine_tuned_model_id}\")\n", - " deployment = mgmt.deployments.begin_create_or_update(\n", - " resource_group_name=resource_group,\n", - " account_name=account_name,\n", - " deployment_name=deployment_name,\n", - " deployment=deployment_config,\n", - " )\n", - " deployment.result()\n", - "\n", - "print(f\"✓ Deployed: {deployment_name}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 12. Compare Models" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating comparison data...\n", - "✓ 20 comparisons\n" - ] - } - ], - "source": [ - "# Generate comparison data\n", - "print(\"Generating comparison data...\")\n", - "comparison_data = []\n", - "test_questions = validation_questions[MAX_VALIDATION:MAX_VALIDATION+20]\n", - "\n", - "for item in test_questions:\n", - " q = item['question']\n", - " base_response = generate_response(q, model=base_model)\n", - " ft_response = generate_response(q, model=deployment_name)\n", - " comparison_data.append({\n", - " \"question\": q,\n", - " \"base_answer\": base_response,\n", - " \"ft_answer\": ft_response\n", - " })\n", - "\n", - "print(f\"✓ {len(comparison_data)} comparisons\")" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Evaluation files saved\n" - ] - } - ], - "source": [ - "# Save for evaluation\n", - "base_eval_file = f\"base_eval_{UNIQUE_KEY}.jsonl\"\n", - "ft_eval_file = f\"ft_eval_{UNIQUE_KEY}.jsonl\"\n", - "\n", - "with open(base_eval_file, \"w\") as f:\n", - " for item in comparison_data:\n", - " f.write(json.dumps({\"question\": item[\"question\"], \"answer\": item[\"base_answer\"]}) + \"\\n\")\n", - "\n", - "with open(ft_eval_file, \"w\") as f:\n", - " for item in comparison_data:\n", - " f.write(json.dumps({\"question\": item[\"question\"], \"answer\": item[\"ft_answer\"]}) + \"\\n\")\n", - "\n", - "print(\"✓ Evaluation files saved\")" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Base run: evalrun_a716d715fdc24e0facffc8b9a90ce170\n", - "Fine-tuned run: evalrun_5180d075fd104d3e962db18db418176c\n" - ] - } - ], - "source": [ - "# Upload and run evaluations\n", - "with open(base_eval_file, \"rb\") as f:\n", - " base_file = openai_client.files.create(purpose=\"evals\", file=f)\n", - " base_file = openai_client.files.wait_for_processing(base_file.id)\n", - "\n", - "with open(ft_eval_file, \"rb\") as f:\n", - " ft_file = openai_client.files.create(purpose=\"evals\", file=f)\n", - " ft_file = openai_client.files.wait_for_processing(ft_file.id)\n", - "\n", - "base_run = openai_client.evals.runs.create(\n", - " eval_id=grader_eval.id,\n", - " name=f\"base-{UNIQUE_KEY}\",\n", - " data_source={\"type\": \"jsonl\", \"source\": {\"type\": \"file_id\", \"id\": base_file.id}}\n", - ")\n", - "\n", - "ft_run = openai_client.evals.runs.create(\n", - " eval_id=grader_eval.id,\n", - " name=f\"finetuned-{UNIQUE_KEY}\",\n", - " data_source={\"type\": \"jsonl\", \"source\": {\"type\": \"file_id\", \"id\": ft_file.id}}\n", - ")\n", - "\n", - "print(f\"Base run: {base_run.id}\")\n", - "print(f\"Fine-tuned run: {ft_run.id}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Base: completed\n", - "Fine-tuned: completed\n", - "✓ Evaluations complete\n" - ] - } - ], - "source": [ - "# Wait for both\n", - "for run_id, name in [(base_run.id, \"Base\"), (ft_run.id, \"Fine-tuned\")]:\n", - " while True:\n", - " run = openai_client.evals.runs.retrieve(run_id=run_id, eval_id=grader_eval.id)\n", - " if run.status in [\"completed\", \"failed\"]:\n", - " print(f\"{name}: {run.status}\")\n", - " break\n", - " time.sleep(5)\n", - "\n", - "print(\"✓ Evaluations complete\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 13. Results" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==================================================\n", - "RESULTS\n", - "==================================================\n", - "Baseline (gold): 0.59\n", - "Base model: 0.82 (±0.21)\n", - "Fine-tuned: 0.94 (±0.06)\n", - "\n", - "Improvement: +0.12\n" - ] - } - ], - "source": [ - "def get_scores(eval_id, run_id):\n", - " items = list(openai_client.evals.runs.output_items.list(run_id=run_id, eval_id=eval_id))\n", - " return [r.score for item in items for r in item.results if r.score is not None]\n", - "\n", - "base_scores = get_scores(grader_eval.id, base_run.id)\n", - "ft_scores = get_scores(grader_eval.id, ft_run.id)\n", - "\n", - "print(\"=\" * 50)\n", - "print(\"RESULTS\")\n", - "print(\"=\" * 50)\n", - "print(f\"Baseline (gold): {np.mean(baseline_scores):.2f}\")\n", - "print(f\"Base model: {np.mean(base_scores):.2f} (±{np.std(base_scores):.2f})\")\n", - "print(f\"Fine-tuned: {np.mean(ft_scores):.2f} (±{np.std(ft_scores):.2f})\")\n", - "print(f\"\\nImprovement: {np.mean(ft_scores) - np.mean(base_scores):+.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize\n", - "fig, ax = plt.subplots(figsize=(8, 5))\n", - "\n", - "models = ['Baseline', 'Base Model', 'Fine-Tuned']\n", - "avgs = [np.mean(baseline_scores), np.mean(base_scores), np.mean(ft_scores)]\n", - "colors = ['#e74c3c', '#3498db', '#2ecc71']\n", - "\n", - "bars = ax.bar(models, avgs, color=colors)\n", - "ax.set_ylabel('Sarcasm Score')\n", - "ax.set_title('Model Comparison')\n", - "ax.set_ylim(0, 1)\n", - "\n", - "for bar, v in zip(bars, avgs):\n", - " ax.text(bar.get_x() + bar.get_width()/2, v + 0.2, f'{v:.1f}', ha='center', fontweight='bold')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 14. Cleanup" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Deleted: training_sarcasm_4aa88349.jsonl\n", - "Deleted: validation_sarcasm_4aa88349.jsonl\n", - "Deleted: base_eval_4aa88349.jsonl\n", - "Deleted: ft_eval_4aa88349.jsonl\n", - "\n", - "✓ Cleanup complete\n" - ] - } - ], - "source": [ - "# Clean up local files\n", - "for f in [training_file_path, validation_file_path, base_eval_file, ft_eval_file]:\n", - " if os.path.exists(f):\n", - " os.remove(f)\n", - " print(f\"Deleted: {f}\")\n", - "\n", - "print(\"\\n✓ Cleanup complete\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv (3.12.3)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}