> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monostate.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Distilação de Prompts
> Treine modelos menores para imitar modelos maiores
# Distilação de Conhecimento
Treine modelos menores e mais rápidos que imitam o comportamento de modelos professor maiores.
## O que é Distilação?
A distilação de conhecimento transfere conhecimento de um modelo "professor" grande para um modelo "aluno" menor. O aluno aprende a produzir saídas semelhantes ao professor, ganhando capacidades além do que poderia aprender apenas com dados.
## Início Rápido
```bash theme={null}
aitraining llm --train \
--model google/gemma-3-270m \
--teacher-model google/gemma-2-2b \
--data-path ./prompts.jsonl \
--project-name distilled-model \
--use-distillation \
--distill-temperature 3.0
```
## Python API
```python theme={null}
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.project import AutoTrainProject
params = LLMTrainingParams(
# Student model (smaller)
model="google/gemma-3-270m",
# Teacher model (larger)
teacher_model="google/gemma-2-2b",
# Data
data_path="./prompts.jsonl",
project_name="distilled-gemma",
# Enable distillation
use_distillation=True,
distill_temperature=3.0, # Default: 3.0
distill_alpha=0.7, # Default: 0.7
distill_max_teacher_length=512, # Default: 512
# Training
trainer="sft",
epochs=5,
batch_size=4,
lr=1e-4,
)
project = AutoTrainProject(params=params, backend="local", process=True)
project.create()
```
## Parâmetros
| Parâmetro | Descrição | Padrão |
| ---------------------------- | -------------------------------------------- | ------------------------------------------ |
| `use_distillation` | Habilitar distilação | `False` |
| `teacher_model` | Caminho para o modelo professor | Obrigatório quando `use_distillation=True` |
| `distill_temperature` | Temperatura do softmax (2.0-4.0 recomendado) | `3.0` |
| `distill_alpha` | Peso da perda de distilação | `0.7` |
| `distill_max_teacher_length` | Máximo de tokens para o professor | `512` |
| `teacher_prompt_template` | Template para prompts do professor | `None` |
| `student_prompt_template` | Template para prompts do aluno | `"{input}"` |
### Temperatura
Temperaturas mais altas tornam a distribuição de probabilidade do professor mais suave, facilitando o aprendizado do aluno:
* `1.0`: Probabilidades normais
* `2.0-4.0`: Mais suave, mais ensinável (recomendado)
* `>4.0`: Muito suave, pode perder precisão
### Alpha
Controla o equilíbrio entre distilação e perda padrão:
* `0.0`: Apenas perda padrão (sem distilação)
* `0.5`: Equilíbrio igual
* `0.7`: Padrão (mais peso na distilação)
* `1.0`: Apenas perda de distilação
### Templates de Prompts
Personalize como os prompts são formatados para modelos professor e aluno:
```python theme={null}
params = LLMTrainingParams(
...
use_distillation=True,
teacher_prompt_template="<|system|>You are helpful.<|user|>{input}<|assistant|>",
student_prompt_template="{input}",
)
```
Use `{input}` como o placeholder para o texto real do prompt.
## Formato dos Dados
Prompts simples funcionam bem para distilação:
```json theme={null}
{"text": "What is machine learning?"}
{"text": "Explain how neural networks work."}
{"text": "Write a function to sort a list in Python."}
```
Ou com saídas esperadas:
```json theme={null}
{"prompt": "What is AI?", "response": "..."}
```
## Melhores Práticas
### Escolha os Modelos com Sabedoria
* O professor deve ser significativamente maior (4x+ parâmetros)
* A mesma família de arquitetura geralmente funciona melhor
* O professor deve ser capaz na tarefa alvo
### Ajuste de Temperatura
```python theme={null}
# Conservador (professor é incerto)
distill_temperature=2.0
# Padrão (maioria dos casos, padrão)
distill_temperature=3.0
# Agressivo (professor é confiante) - no limite superior recomendado
distill_temperature=4.0
```
A faixa de temperatura recomendada é 2.0-4.0. Valores acima de 4.0 podem perder precisão.
### Duração do Treinamento
A distilação geralmente se beneficia de treinamento mais longo:
```python theme={null}
params = LLMTrainingParams(
...
epochs=5, # Mais épocas que fine-tuning padrão
lr=1e-4, # Taxa de aprendizado ligeiramente maior
)
```
## Exemplo: Assistente de API
Distilar conhecimento de API de um modelo grande:
```python theme={null}
params = LLMTrainingParams(
model="google/gemma-3-270m",
teacher_model="meta-llama/Llama-3.2-8B",
data_path="./api_prompts.jsonl",
project_name="api-assistant-small",
use_distillation=True,
distill_temperature=3.0,
distill_alpha=0.7,
epochs=10,
batch_size=8,
lr=5e-5,
peft=True,
lora_r=32,
)
```
## Comparação
### Sem Distilação
```bash theme={null}
# Fine-tuning padrão em modelo 270M
aitraining llm --train \
--model google/gemma-3-270m \
--data-path ./data.jsonl \
--project-name standard-model
```
### Com Distilação
```bash theme={null}
# Distilação do modelo 2B
aitraining llm --train \
--model google/gemma-3-270m \
--teacher-model google/gemma-2-2b \
--data-path ./data.jsonl \
--project-name distilled-model \
--use-distillation
```
O modelo destilado geralmente tem melhor desempenho, especialmente em tarefas complexas.
## Casos de Uso
* **Implantação**: Criar modelos rápidos para produção
* **Dispositivos de borda**: Executar em sistemas móveis/embarcados
* **Redução de custos**: Reduzir custos de inferência
* **Especialização**: Focar conhecimento de modelo grande em domínio específico
## Próximos Passos
Otimização de preferências
Fine-tuning eficiente