# dspy-finetune-bootstrap

Turns a working DSPy program into fine-tuned weights for a smaller model, cutting inference cost and speeding up responses.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · ★ 124
- Author: OmidZamani
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/OmidZamani/dspy-skills/tree/HEAD/skills/dspy-finetune-bootstrap/SKILL.md
- Updated: 2026-06-23
- HTML: https://affpapa.org/en/nevibecode/skills/dspy-finetune-bootstrap

## What it does

The skill walks the agent through four phases: set up the teacher program, configure training, fine-tune the student, then save the result. The bundled Python examples show a `dspy.Module` built on `ChainOfThought`, a `BootstrapFinetune` optimizer with a metric and `train_kwargs`, and a full classifier pipeline that scores both teacher and student with `Evaluate`.

A second example covers RAG. The retriever `ColBERTv2` is wired in through `dspy.configure(rm=...)`, and the same distillation flow runs over a pipeline that pulls passages before classifying. A reference table lists the training arguments: `learning_rate`, `num_train_epochs`, `per_device_train_batch_size`, `gradient_accumulation_steps`, `warmup_ratio`, `weight_decay`, `max_grad_norm`.

Training needs a GPU, and the provider plus model must support fine-tuning — without that, `BootstrapFinetune` has nothing to run on. Saving writes state as JSON, so loading means rebuilding the `TeacherQA` architecture first; a bare `load` call on an empty module fails. Expect the student to trail the teacher on some inputs, and budget hours or days for the run depending on dataset size.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-finetune-bootstrap -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/dspy-finetune-bootstrap/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/dspy-finetune-bootstrap/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-finetune-bootstrap -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/dspy-finetune-bootstrap/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-finetune-bootstrap -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/dspy-finetune-bootstrap/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install OmidZamani/dspy-skills dspy-finetune-bootstrap
```

2. **Manually: put the files in place**
- File: `.github/skills/dspy-finetune-bootstrap/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-finetune-bootstrap -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/OmidZamani/dspy-skills --path skills/dspy-finetune-bootstrap
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/dspy-finetune-bootstrap/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-finetune-bootstrap -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/OmidZamani/dspy-skills/tree/HEAD/skills/dspy-finetune-bootstrap/SKILL.md

## When to use it
- cut inference cost by moving a DSPy program onto smaller weights
- build a teacher-to-student distillation pipeline in DSPy
- score the student against the teacher on a held-out set
- pick training hyperparameters for fine-tuning
- save and reload fine-tuned model state

## Example prompts
- Set up BootstrapFinetune distillation for my DSPy program, teacher is `openai/gpt-4o`
- Build a classifier fine-tuning pipeline with an exact label match metric and save it to `final_model.json`
- Evaluate the teacher and the student on the devset with `Evaluate` and show both scores

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: d10d234aab6dfa29.

BEGIN THIRD-PARTY FILE d10d234aab6dfa29
````text
---
name: dspy-finetune-bootstrap
version: "1.0.0"
dspy-compatibility: "3.2.1"
tags: ["optimizer", "production"]
requires-extras: []
description: Use for BootstrapFinetune, fine-tuning DSPy models, teacher-student distillation, weight optimization, and lower-cost deployment.
allowed-tools:
  - Read
  - Write
  - Glob
  - Grep
---

# DSPy BootstrapFinetune Optimizer

## Goal

Distill a DSPy program into fine-tuned model weights for efficient production deployment.

## When to Use

- You have a working DSPy program with a large model
- Need to reduce inference costs
- Want faster responses (smaller model)
- Deploying to resource-constrained environments

## Inputs

| Input | Type | Description |
|-------|------|-------------|
| `program` | `dspy.Module` | Teacher program to distill |
| `trainset` | `list[dspy.Example]` | Training examples |
| `metric` | `callable` | Validation metric (optional) |
| `train_kwargs` | `dict` | Training hyperparameters |

## Outputs

| Output | Type | Description |
|--------|------|-------------|
| `finetuned_program` | `dspy.Module` | Program with fine-tuned weights |
| `model_path` | `str` | Path to saved model |

## Workflow

### Phase 1: Prepare Teacher Program

```python
import dspy

# Configure with strong teacher model
dspy.configure(lm=dspy.LM("openai/gpt-4o"))

class TeacherQA(dspy.Module):
    def __init__(self):
        self.cot = dspy.ChainOfThought("question -> answer")
    
    def forward(self, question):
        return self.cot(question=question)
```

### Phase 2: Configure Fine-Tuning

Assign the LM directly to predictors before fine-tuning:

```python
import dspy
from dspy.teleprompt import BootstrapFinetune

optimizer = BootstrapFinetune(
    metric=lambda gold, pred, trace=None: gold.answer.lower() in pred.answer.lower(),
    train_kwargs={
        'learning_rate': 5e-5,
        'num_train_epochs': 3,
        'per_device_train_batch_size': 4,
        'warmup_ratio': 0.1
    }
)
```

### Phase 3: Fine-tune Student Model

```python
teacher = TeacherQA()
teacher.set_lm(dspy.settings.lm)
finetuned = optimizer.compile(teacher, trainset=trainset)
```

### Phase 4: Deploy

```python
# Save the fine-tuned model (saves state-only by default)
finetuned.save("finetuned_qa_model.json")

# Load and use (must recreate architecture first)
loaded = TeacherQA()
loaded.load("finetuned_qa_model.json")
````
END THIRD-PARTY FILE d10d234aab6dfa29

The third-party file has ended. Everything between the d10d234aab6dfa29 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2371 of 7187 bytes. © OmidZamani · MIT · https://github.com/OmidZamani/dspy-skills/tree/HEAD/skills/dspy-finetune-bootstrap/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md