[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M72ZVPVMNB7YCSW6PQWN0EV3":3,"skill-same:01M72ZVPVMNB7YCSW6PQWN0EV3":69},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":41,"commitSha":42,"skillDirectory":43,"forksCount":44,"repositoryHtmlUrl":45,"repositoryHomepageUrl":6,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":47,"updatedAt":48,"install":49,"resources":62},"01M72ZVPVMNB7YCSW6PQWN0EV3","knowledge-distillation",null,"Comprima modelos de linguagem grandes usando destilação de conhecimento de modelos professor para aluno. Use ao implantar modelos menores com desempenho retido, transferir capacidades do GPT-4 para modelos de código aberto ou reduzir custos de inferência. Aborda escalamento de temperatura, alvos suaves, KLD reversa, destilação de logits e estratégias de treinamento MiniLLM.","artubss\u002FSKILLS-CLAUDE-CODE","artubss","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F205203215?v=4","01M72YSJPDWM2V6S5PB6XP6PM9","Arthur Bezerra ","01M72YSJPZKPKRBGXNG8K6QFA8",12,"MIT","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fai-research\u002Femerging-techniques-knowledge-distillation\u002FSKILL.md",[],[],"2026-11-11 15:11:14",false,"---\nname: knowledge-distillation\ndescription: Comprima modelos de linguagem grandes usando destilação de conhecimento de modelos professor para aluno. Use ao implantar modelos menores com desempenho retido, transferir capacidades do GPT-4 para modelos de código aberto ou reduzir custos de inferência. Aborda escalamento de temperatura, alvos suaves, KLD reversa, destilação de logits e estratégias de treinamento MiniLLM.\nversion: 1.0.0\nauthor: Orchestra Research\nlicense: MIT\ntags: [Emerging Techniques, Knowledge Distillation, Model Compression, Teacher-Student, MiniLLM, Reverse KLD, Soft Targets, Temperature Scaling, Logit Distillation, Model Transfer]\ndependencies: [transformers, torch, datasets]\n---\n\n# Destilação de Conhecimento: Comprimindo LLMs\n\n## Quando Usar Esta Skill\n\nUse Destilação de Conhecimento quando você precisa:\n- **Comprimir modelos** de 70B → 7B retendo 90%+ de desempenho\n- **Transferir capacidades** de modelos proprietários (GPT-4) para código aberto (LLaMA, Mistral)\n- **Reduzir custos de inferência** implantando modelos alunos menores\n- **Criar modelos especializados** destilando conhecimento específico de domínio\n- **Melhorar modelos pequenos** usando dados sintéticos de professores grandes\n\n**Técnicas-chave**: Escalamento de temperatura, alvos suaves, KLD reversa (MiniLLM), destilação de logits, destilação de resposta\n\n**Papers**: Hinton et al. 2015 (arXiv 1503.02531), MiniLLM (arXiv 2306.08543), KD Survey (arXiv 2402.13116)\n\n## Instalação\n\n```bash\n# transformers padrão\npip install transformers datasets accelerate\n\n# Para treinamento\npip install torch deepspeed wandb\n\n# Opcional: implementação MiniLLM\ngit clone https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FLMOps\ncd LMOps\u002Fminillm\npip install -e .\n```\n\n## Início Rápido\n\n### Destilação de Conhecimento Básica\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments\n\n# 1. Carregue modelos professor (grande) e aluno (pequeno)\nteacher = AutoModelForCausalLM.from_pretrained(\n    \"meta-llama\u002FLlama-2-70b-hf\",  # Professor grande\n    torch_dtype=torch.float16,\n    device_map=\"auto\"\n)\n\nstudent = AutoModelForCausalLM.from_pretrained(\n    \"meta-llama\u002FLlama-2-7b-hf\",  # Aluno pequeno\n    torch_dtype=torch.float16,\n    device_map=\"cuda:0\"\n)\n\ntokenizer = AutoTokenizer.from_pretrained(\"meta-llama\u002FLlama-2-70b-hf\")\n\n# 2. Defina perda de destilação\ndef distillation_loss(student_logits, teacher_logits, labels, temperature=2.0, alpha=0.5):\n    \"\"\"\n    Combine perda dura (cross-entropy) com perda suave (divergência KL).\n\n    Args:\n        temperature: Suaviza distribuições de probabilidade (maior = mais suave)\n        alpha: Peso para perda de destilação (1-alpha para perda dura)\n    \"\"\"\n    # Perda dura: Cross-entropy padrão com rótulos verdadeiros\n    hard_loss = F.cross_entropy(student_logits.view(-1, student_logits.size(-1)), labels.view(-1))\n\n    # Perda suave: Divergência KL entre aluno e professor\n    soft_targets = F.softmax(teacher_logits \u002F temperature, dim=-1)\n    soft_student = F.log_softmax(student_logits \u002F temperature, dim=-1)\n    soft_loss = F.kl_div(soft_student, soft_targets, reduction='batchmean') * (temperature ** 2)\n\n    # Perda combinada\n    return alpha * soft_loss + (1 - alpha) * hard_loss\n\n# 3. Loop de treinamento\nfor batch in dataloader:\n    # Forward do professor (sem grad)\n    with torch.no_grad():\n        teacher_outputs = teacher(**batch)\n        teacher_logits = teacher_outputs.logits\n\n    # Forward do aluno\n    student_outputs = student(**batch)\n    student_logits = student_outputs.logits\n\n    # Compute perda de destilação\n    loss = distillation_loss(\n        student_logits,\n        teacher_logits,\n        batch['labels'],\n        temperature=2.0,\n        alpha=0.7  # 70% suave, 30% dura\n    )\n\n    # Backward e otimize\n    loss.backward()\n    optimizer.step()\n    optimizer.zero_grad()\n```\n\n### MiniLLM (KLD Reversa)\n\n**Fonte**: arXiv 2306.08543 (2024)\n\n**Inovação**: Use KLD reversa em vez de KLD direta para melhor destilação de modelos generativos.\n\n```python\ndef reverse_kl_loss(student_logits, teacher_logits, temperature=1.0):\n    \"\"\"\n    Divergência KL reversa: KL(Professor || Aluno)\n    Melhor para modelos generativos que KLD direta.\n    \"\"\"\n    # Distribuição do professor (alvo)\n    p_teacher = F.softmax(teacher_logits \u002F temperature, dim=-1)\n\n    # Distribuição do aluno (modelo)\n    log_p_student = F.log_softmax(student_logits \u002F temperature, dim=-1)\n\n    # KL reversa: Soma sobre professor, aluno aprende a cobrir modos do professor\n    reverse_kl = -(p_teacher * log_p_student).sum(dim=-1).mean()\n\n    return reverse_kl * (temperature ** 2)\n\n# Treinamento com MiniLLM\nfor batch in dataloader:\n    with torch.no_grad():\n        teacher_logits = teacher(**batch).logits\n\n    student_logits = student(**batch).logits\n\n    # KLD reversa (melhor para geração)\n    loss = reverse_kl_loss(student_logits, teacher_logits, temperature=1.0)\n\n    loss.backward()\n    optimizer.step()\n```\n\n**Por que KL reversa?**\n- **KL direta** (padrão): Aluno aprende a corresponder à *média* do professor\n- **KL reversa** (MiniLLM): Aluno aprende a *cobrir* todos os modos do professor\n- Melhor para geração diversa de texto\n\n### Destilação de Resposta\n\n```python\n# Gere dados sintéticos do professor, treine aluno para imitá-lo\n\n# 1. Gere respostas sintéticas do professor\nprompts = [\"Explique IA:\", \"O que é ML?\", \"Defina PLN:\"]\n\nteacher_responses = []\nfor prompt in prompts:\n    inputs = tokenizer(prompt, return_tensors='pt').to(teacher.device)\n    outputs = teacher.generate(**inputs, max_new_tokens=256, do_sample=True, temperature=0.7)\n    response = tokenizer.decode(outputs[0], skip_special_tokens=True)\n    teacher_responses.append(response)\n\n# 2. Treine aluno nas respostas do professor (fine-tuning padrão)\ntrain_dataset = [\n    {\"text\": f\"{prompt}\\n{response}\"}\n    for prompt, response in zip(prompts, teacher_responses)\n]\n\n# 3. Fine-tune do aluno\ntrainer = Trainer(\n    model=student,\n    args=TrainingArguments(output_dir=\".\u002Fstudent\", num_train_epochs=3, learning_rate=2e-5),\n    train_dataset=train_dataset,\n)\ntrainer.train()\n```\n\n## Conceitos Fundamentais\n\n### 1. Escalamento de Temperatura\n\n**Objetivo**: Suavizar distribuições de probabilidade para expor incerteza do professor.\n\n```python\n# Temperatura baixa (T=1): Distribuição pontuda\nlogits = [3.0, 2.0, 1.0]\nprobs_T1 = softmax(logits \u002F 1.0)  # [0.67, 0.24, 0.09]\n\n# Temperatura alta (T=4): Distribuição suave\nprobs_T4 = softmax(logits \u002F 4.0)  # [0.42, 0.34, 0.24]\n\n# T maior revela mais informações sobre rankings relativos\n```\n\n**Regra**: Use T=2-5 para destilação (2 é padrão comum).\n\n### 2. Componentes da Função de Perda\n\n```python\n# Perda total = alpha * perda_suave + (1 - alpha) * perda_dura\n\n# Perda suave: Aprenda do conhecimento do professor\nsoft_loss = KL(aluno || professor)\n\n# Perda dura: Aprenda dos rótulos verdadeiros\nhard_loss = CrossEntropy(saída_aluno, rótulos_verdadeiros)\n\n# Valores típicos:\nalpha = 0.5  # Balanceado\nalpha = 0.7  # Mais ênfase no professor\nalpha = 0.3  # Mais ênfase nos rótulos\n```\n\n### 3. KLD Direta vs Reversa\n\n```python\n# KL direta: KL(Aluno || Professor)\n# - Aluno corresponde ao comportamento médio do professor\n# - Mode-seeking: Aluno foca nos modos de maior probabilidade do professor\n# - Bom para classificação\n\n# KL reversa: KL(Professor || Aluno)\n# - Aluno cobre todos os comportamentos do professor\n# - Mode-covering: Aluno aprende comportamentos diversos\n# - Bom para geração (MiniLLM)\n```\n\n## Estratégias de Treinamento\n\n### Estratégia 1: Destilação de Logits\n\n```python\n# Treine aluno para corresponder aos logits do professor diretamente\n\ndef logit_distillation_trainer(student, teacher, dataloader, temperature=2.0):\n    optimizer = torch.optim.AdamW(student.parameters(), lr=2e-5)\n\n    for epoch in range(3):\n        for batch in dataloader:\n            # Obtenha logits\n            with torch.no_grad():\n                teacher_logits = teacher(**batch).logits\n\n            student_logits = student(**batch).logits\n\n            # MSE em logits (alternativa a KLD)\n            loss = F.mse_loss(student_logits, teacher_logits)\n\n            # Ou use KLD\n            # loss = F.kl_div(\n            #     F.log_softmax(student_logits\u002Ftemperature, dim=-1),\n            #     F.softmax(teacher_logits\u002Ftemperature, dim=-1),\n            #     reduction='batchmean'\n            # ) * (temperature ** 2)\n\n            loss.backward()\n            optimizer.step()\n            optimizer.zero_grad()\n\n    return student\n```\n\n### Estratégia 2: Destilação em Duas Etapas\n\n```python\n# Etapa 1: Destilar do professor\nstudent = distill(teacher, student, epochs=5)\n\n# Etapa 2: Fine-tune em dados específicos de tarefa\nstudent = fine_tune(student, task_data, epochs=3)\n\n# Resulta em melhor desempenho em tarefa que destilação de etapa única\n```\n\n### Estratégia 3: Destilação Multi-Professor\n\n```python\n# Aprenda de múltiplos professores especialistas\n\ndef multi_teacher_distillation(student, teachers, batch):\n    \"\"\"Destilar de conjunto de professores.\"\"\"\n    teacher_logits_list = []\n\n    # Obtenha logits de todos os professores\n    with torch.no_grad():\n        for teacher in teachers:\n            logits = teacher(**batch).logits\n            teacher_logits_list.append(logits)\n\n    # Média das predições do professor\n    avg_teacher_logits = torch.stack(teacher_logits_list).mean(dim=0)\n\n    # Aluno aprende do conjunto\n    student_logits = student(**batch).logits\n    loss = F.kl_div(\n        F.log_softmax(student_logits, dim=-1),\n        F.softmax(avg_teacher_logits, dim=-1),\n        reduction='batchmean'\n    )\n\n    return loss\n```\n\n## Implantação em Produção\n\n### Script de Treinamento Completo\n\n```python\nfrom transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling\n\ndef train_distilled_model(\n    teacher_name=\"meta-llama\u002FLlama-2-70b-hf\",\n    student_name=\"meta-llama\u002FLlama-2-7b-hf\",\n    output_dir=\".\u002Fdistilled-llama-7b\",\n    temperature=2.0,\n    alpha=0.7,\n):\n    # Carregue modelos\n    teacher = AutoModelForCausalLM.from_pretrained(teacher_name, torch_dtype=torch.float16, device_map=\"auto\")\n    student = AutoModelForCausalLM.from_pretrained(student_name, torch_dtype=torch.float16)\n    tokenizer = AutoTokenizer.from_pretrained(teacher_name)\n\n    # Trainer customizado com destilação\n    class DistillationTrainer(Trainer):\n        def compute_loss(self, model, inputs, return_outputs=False):\n            # Forward do aluno\n            outputs_student = model(**inputs)\n            student_logits = outputs_student.logits\n\n            # Forward do professor (sem grad)\n            with torch.no_grad():\n                outputs_teacher = teacher(**inputs)\n                teacher_logits = outputs_teacher.logits\n\n            # Perda de destilação\n            soft_targets = F.softmax(teacher_logits \u002F temperature, dim=-1)\n            soft_student = F.log_softmax(student_logits \u002F temperature, dim=-1)\n            soft_loss = F.kl_div(soft_student, soft_targets, reduction='batchmean') * (temperature ** 2)\n\n            # Perda dura\n            hard_loss = outputs_student.loss\n\n            # Combinada\n            loss = alpha * soft_loss + (1 - alpha) * hard_loss\n\n            return (loss, outputs_student) if return_outputs else loss\n\n    # Argumentos de treinamento\n    training_args = TrainingArguments(\n        output_dir=output_dir,\n        num_train_epochs=3,\n        per_device_train_batch_size=4,\n        gradient_accumulation_steps=8,\n        learning_rate=2e-5,\n        warmup_steps=500,\n        logging_steps=100,\n        save_steps=1000,\n        bf16=True,\n        gradient_checkpointing=True,\n    )\n\n    # Treine\n    trainer = DistillationTrainer(\n        model=student,\n        args=training_args,\n        train_dataset=train_dataset,\n        data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),\n    )\n\n    trainer.train()\n    student.save_pretrained(output_dir)\n    tokenizer.save_pretrained(output_dir)\n\n# Uso\ntrain_distilled_model(\n    teacher_name=\"meta-llama\u002FLlama-2-70b-hf\",\n    student_name=\"meta-llama\u002FLlama-2-7b-hf\",\n    temperature=2.0,\n    alpha=0.7\n)\n```\n\n## Melhores Práticas\n\n### 1. Seleção de Hiperparâmetros\n\n```python\n# Temperatura\nT = 1.0  # Pontuda (menos transferência de conhecimento)\nT = 2.0  # Padrão (bom equilíbrio)\nT = 5.0  # Suave (mais transferência de conhecimento)\n\n# Alpha (peso)\nalpha = 0.5  # Balanceado\nalpha = 0.7  # Enfatizar conhecimento do professor\nalpha = 0.9  # Destilação forte\n\n# Regra: T maior + alpha maior = destilação mais forte\n```\n\n### 2. Razão de Tamanho de Modelo\n\n```python\n# Boas razões (professor\u002Faluno)\n70B \u002F 7B = 10×    # Excelente\n13B \u002F 1B = 13×    # Bom\n7B \u002F 1B = 7×      # Aceitável\n\n# Evite diferença muito grande\n70B \u002F 1B = 70×    # Muito grande, ineficaz\n```\n\n### 3. Qualidade dos Dados\n\n```python\n# Melhor: Use dados gerados pelo professor + dados reais\ntrain_data = {\n    \"teacher_generated\": 70%,  # Diverso, alta qualidade\n    \"real_data\": 30%            # Verdade fundamental\n}\n\n# Evite: Apenas dados reais (não aproveita professor totalmente)\n```\n\n## Avaliação\n\n```python\nfrom transformers import pipeline\n\n# Compare aluno vs professor\nteacher_pipe = pipeline(\"text-generation\", model=teacher)\nstudent_pipe = pipeline(\"text-generation\", model=student)\n\nprompts = [\"Explique computação quântica:\", \"O que é IA?\"]\n\nfor prompt in prompts:\n    teacher_out = teacher_pipe(prompt, max_new_tokens=100)\n    student_out = student_pipe(prompt, max_new_tokens=100)\n\n    print(f\"Prompt: {prompt}\")\n    print(f\"Professor: {teacher_out[0]['generated_text']}\")\n    print(f\"Aluno: {student_out[0]['generated_text']}\")\n    print(f\"Qualidade de correspondência: {calculate_similarity(teacher_out, student_out):.2f}\")\n```\n\n## Recursos\n\n- **Hinton et al. 2015 (Fundacional)**: https:\u002F\u002Farxiv.org\u002Fabs\u002F1503.02531\n- **MiniLLM (KLD Reversa)**: https:\u002F\u002Farxiv.org\u002Fabs\u002F2306.08543\n- **KD Survey para LLMs (2024)**: https:\u002F\u002Farxiv.org\u002Fabs\u002F2402.13116\n- **MiniLLM GitHub**: https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FLMOps\u002Ftree\u002Fmain\u002Fminillm","# Destilação de Conhecimento: Comprimindo LLMs\n\n## Quando Usar Esta Skill\n\nUse Destilação de Conhecimento quando você precisa:\n- **Comprimir modelos** de 70B → 7B retendo 90%+ de desempenho\n- **Transferir capacidades** de modelos proprietários (GPT-4) para código aberto (LLaMA, Mistral)\n- **Reduzir custos de inferência** implantando modelos alunos menores\n- **Criar modelos especializados** destilando conhecimento específico de domínio\n- **Melhorar modelos pequenos** usando dados sintéticos de professores grandes\n\n**Técnicas-chave**: Escalamento de temperatura, alvos suaves, KLD reversa (MiniLLM), destilação de logits, destilação de resposta\n\n**Papers**: Hinton et al. 2015 (arXiv 1503.02531), MiniLLM (arXiv 2306.08543), KD Survey (arXiv 2402.13116)\n\n## Instalação\n\n```bash\n# transformers padrão\npip install transformers datasets accelerate\n\n# Para treinamento\npip install torch deepspeed wandb\n\n# Opcional: implementação MiniLLM\ngit clone https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FLMOps\ncd LMOps\u002Fminillm\npip install -e .\n```\n\n## Início Rápido\n\n### Destilação de Conhecimento Básica\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments\n\n# 1. Carregue modelos professor (grande) e aluno (pequeno)\nteacher = AutoModelForCausalLM.from_pretrained(\n    \"meta-llama\u002FLlama-2-70b-hf\",  # Professor grande\n    torch_dtype=torch.float16,\n    device_map=\"auto\"\n)\n\nstudent = AutoModelForCausalLM.from_pretrained(\n    \"meta-llama\u002FLlama-2-7b-hf\",  # Aluno pequeno\n    torch_dtype=torch.float16,\n    device_map=\"cuda:0\"\n)\n\ntokenizer = AutoTokenizer.from_pretrained(\"meta-llama\u002FLlama-2-70b-hf\")\n\n# 2. Defina perda de destilação\ndef distillation_loss(student_logits, teacher_logits, labels, temperature=2.0, alpha=0.5):\n    \"\"\"\n    Combine perda dura (cross-entropy) com perda suave (divergência KL).\n\n    Args:\n        temperature: Suaviza distribuições de probabilidade (maior = mais suave)\n        alpha: Peso para perda de destilação (1-alpha para perda dura)\n    \"\"\"\n    # Perda dura: Cross-entropy padrão com rótulos verdadeiros\n    hard_loss = F.cross_entropy(student_logits.view(-1, student_logits.size(-1)), labels.view(-1))\n\n    # Perda suave: Divergência KL entre aluno e professor\n    soft_targets = F.softmax(teacher_logits \u002F temperature, dim=-1)\n    soft_student = F.log_softmax(student_logits \u002F temperature, dim=-1)\n    soft_loss = F.kl_div(soft_student, soft_targets, reduction='batchmean') * (temperature ** 2)\n\n    # Perda combinada\n    return alpha * soft_loss + (1 - alpha) * hard_loss\n\n# 3. Loop de treinamento\nfor batch in dataloader:\n    # Forward do professor (sem grad)\n    with torch.no_grad():\n        teacher_outputs = teacher(**batch)\n        teacher_logits = teacher_outputs.logits\n\n    # Forward do aluno\n    student_outputs = student(**batch)\n    student_logits = student_outputs.logits\n\n    # Compute perda de destilação\n    loss = distillation_loss(\n        student_logits,\n        teacher_logits,\n        batch['labels'],\n        temperature=2.0,\n        alpha=0.7  # 70% suave, 30% dura\n    )\n\n    # Backward e otimize\n    loss.backward()\n    optimizer.step()\n    optimizer.zero_grad()\n```\n\n### MiniLLM (KLD Reversa)\n\n**Fonte**: arXiv 2306.08543 (2024)\n\n**Inovação**: Use KLD reversa em vez de KLD direta para melhor destilação de modelos generativos.\n\n```python\ndef reverse_kl_loss(student_logits, teacher_logits, temperature=1.0):\n    \"\"\"\n    Divergência KL reversa: KL(Professor || Aluno)\n    Melhor para modelos generativos que KLD direta.\n    \"\"\"\n    # Distribuição do professor (alvo)\n    p_teacher = F.softmax(teacher_logits \u002F temperature, dim=-1)\n\n    # Distribuição do aluno (modelo)\n    log_p_student = F.log_softmax(student_logits \u002F temperature, dim=-1)\n\n    # KL reversa: Soma sobre professor, aluno aprende a cobrir modos do professor\n    reverse_kl = -(p_teacher * log_p_student).sum(dim=-1).mean()\n\n    return reverse_kl * (temperature ** 2)\n\n# Treinamento com MiniLLM\nfor batch in dataloader:\n    with torch.no_grad():\n        teacher_logits = teacher(**batch).logits\n\n    student_logits = student(**batch).logits\n\n    # KLD reversa (melhor para geração)\n    loss = reverse_kl_loss(student_logits, teacher_logits, temperature=1.0)\n\n    loss.backward()\n    optimizer.step()\n```\n\n**Por que KL reversa?**\n- **KL direta** (padrão): Aluno aprende a corresponder à *média* do professor\n- **KL reversa** (MiniLLM): Aluno aprende a *cobrir* todos os modos do professor\n- Melhor para geração diversa de texto\n\n### Destilação de Resposta\n\n```python\n# Gere dados sintéticos do professor, treine aluno para imitá-lo\n\n# 1. Gere respostas sintéticas do professor\nprompts = [\"Explique IA:\", \"O que é ML?\", \"Defina PLN:\"]\n\nteacher_responses = []\nfor prompt in prompts:\n    inputs = tokenizer(prompt, return_tensors='pt').to(teacher.device)\n    outputs = teacher.generate(**inputs, max_new_tokens=256, do_sample=True, temperature=0.7)\n    response = tokenizer.decode(outputs[0], skip_special_tokens=True)\n    teacher_responses.append(response)\n\n# 2. Treine aluno nas respostas do professor (fine-tuning padrão)\ntrain_dataset = [\n    {\"text\": f\"{prompt}\\n{response}\"}\n    for prompt, response in zip(prompts, teacher_responses)\n]\n\n# 3. Fine-tune do aluno\ntrainer = Trainer(\n    model=student,\n    args=TrainingArguments(output_dir=\".\u002Fstudent\", num_train_epochs=3, learning_rate=2e-5),\n    train_dataset=train_dataset,\n)\ntrainer.train()\n```\n\n## Conceitos Fundamentais\n\n### 1. Escalamento de Temperatura\n\n**Objetivo**: Suavizar distribuições de probabilidade para expor incerteza do professor.\n\n```python\n# Temperatura baixa (T=1): Distribuição pontuda\nlogits = [3.0, 2.0, 1.0]\nprobs_T1 = softmax(logits \u002F 1.0)  # [0.67, 0.24, 0.09]\n\n# Temperatura alta (T=4): Distribuição suave\nprobs_T4 = softmax(logits \u002F 4.0)  # [0.42, 0.34, 0.24]\n\n# T maior revela mais informações sobre rankings relativos\n```\n\n**Regra**: Use T=2-5 para destilação (2 é padrão comum).\n\n### 2. Componentes da Função de Perda\n\n```python\n# Perda total = alpha * perda_suave + (1 - alpha) * perda_dura\n\n# Perda suave: Aprenda do conhecimento do professor\nsoft_loss = KL(aluno || professor)\n\n# Perda dura: Aprenda dos rótulos verdadeiros\nhard_loss = CrossEntropy(saída_aluno, rótulos_verdadeiros)\n\n# Valores típicos:\nalpha = 0.5  # Balanceado\nalpha = 0.7  # Mais ênfase no professor\nalpha = 0.3  # Mais ênfase nos rótulos\n```\n\n### 3. KLD Direta vs Reversa\n\n```python\n# KL direta: KL(Aluno || Professor)\n# - Aluno corresponde ao comportamento médio do professor\n# - Mode-seeking: Aluno foca nos modos de maior probabilidade do professor\n# - Bom para classificação\n\n# KL reversa: KL(Professor || Aluno)\n# - Aluno cobre todos os comportamentos do professor\n# - Mode-covering: Aluno aprende comportamentos diversos\n# - Bom para geração (MiniLLM)\n```\n\n## Estratégias de Treinamento\n\n### Estratégia 1: Destilação de Logits\n\n```python\n# Treine aluno para corresponder aos logits do professor diretamente\n\ndef logit_distillation_trainer(student, teacher, dataloader, temperature=2.0):\n    optimizer = torch.optim.AdamW(student.parameters(), lr=2e-5)\n\n    for epoch in range(3):\n        for batch in dataloader:\n            # Obtenha logits\n            with torch.no_grad():\n                teacher_logits = teacher(**batch).logits\n\n            student_logits = student(**batch).logits\n\n            # MSE em logits (alternativa a KLD)\n            loss = F.mse_loss(student_logits, teacher_logits)\n\n            # Ou use KLD\n            # loss = F.kl_div(\n            #     F.log_softmax(student_logits\u002Ftemperature, dim=-1),\n            #     F.softmax(teacher_logits\u002Ftemperature, dim=-1),\n            #     reduction='batchmean'\n            # ) * (temperature ** 2)\n\n            loss.backward()\n            optimizer.step()\n            optimizer.zero_grad()\n\n    return student\n```\n\n### Estratégia 2: Destilação em Duas Etapas\n\n```python\n# Etapa 1: Destilar do professor\nstudent = distill(teacher, student, epochs=5)\n\n# Etapa 2: Fine-tune em dados específicos de tarefa\nstudent = fine_tune(student, task_data, epochs=3)\n\n# Resulta em melhor desempenho em tarefa que destilação de etapa única\n```\n\n### Estratégia 3: Destilação Multi-Professor\n\n```python\n# Aprenda de múltiplos professores especialistas\n\ndef multi_teacher_distillation(student, teachers, batch):\n    \"\"\"Destilar de conjunto de professores.\"\"\"\n    teacher_logits_list = []\n\n    # Obtenha logits de todos os professores\n    with torch.no_grad():\n        for teacher in teachers:\n            logits = teacher(**batch).logits\n            teacher_logits_list.append(logits)\n\n    # Média das predições do professor\n    avg_teacher_logits = torch.stack(teacher_logits_list).mean(dim=0)\n\n    # Aluno aprende do conjunto\n    student_logits = student(**batch).logits\n    loss = F.kl_div(\n        F.log_softmax(student_logits, dim=-1),\n        F.softmax(avg_teacher_logits, dim=-1),\n        reduction='batchmean'\n    )\n\n    return loss\n```\n\n## Implantação em Produção\n\n### Script de Treinamento Completo\n\n```python\nfrom transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling\n\ndef train_distilled_model(\n    teacher_name=\"meta-llama\u002FLlama-2-70b-hf\",\n    student_name=\"meta-llama\u002FLlama-2-7b-hf\",\n    output_dir=\".\u002Fdistilled-llama-7b\",\n    temperature=2.0,\n    alpha=0.7,\n):\n    # Carregue modelos\n    teacher = AutoModelForCausalLM.from_pretrained(teacher_name, torch_dtype=torch.float16, device_map=\"auto\")\n    student = AutoModelForCausalLM.from_pretrained(student_name, torch_dtype=torch.float16)\n    tokenizer = AutoTokenizer.from_pretrained(teacher_name)\n\n    # Trainer customizado com destilação\n    class DistillationTrainer(Trainer):\n        def compute_loss(self, model, inputs, return_outputs=False):\n            # Forward do aluno\n            outputs_student = model(**inputs)\n            student_logits = outputs_student.logits\n\n            # Forward do professor (sem grad)\n            with torch.no_grad():\n                outputs_teacher = teacher(**inputs)\n                teacher_logits = outputs_teacher.logits\n\n            # Perda de destilação\n            soft_targets = F.softmax(teacher_logits \u002F temperature, dim=-1)\n            soft_student = F.log_softmax(student_logits \u002F temperature, dim=-1)\n            soft_loss = F.kl_div(soft_student, soft_targets, reduction='batchmean') * (temperature ** 2)\n\n            # Perda dura\n            hard_loss = outputs_student.loss\n\n            # Combinada\n            loss = alpha * soft_loss + (1 - alpha) * hard_loss\n\n            return (loss, outputs_student) if return_outputs else loss\n\n    # Argumentos de treinamento\n    training_args = TrainingArguments(\n        output_dir=output_dir,\n        num_train_epochs=3,\n        per_device_train_batch_size=4,\n        gradient_accumulation_steps=8,\n        learning_rate=2e-5,\n        warmup_steps=500,\n        logging_steps=100,\n        save_steps=1000,\n        bf16=True,\n        gradient_checkpointing=True,\n    )\n\n    # Treine\n    trainer = DistillationTrainer(\n        model=student,\n        args=training_args,\n        train_dataset=train_dataset,\n        data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),\n    )\n\n    trainer.train()\n    student.save_pretrained(output_dir)\n    tokenizer.save_pretrained(output_dir)\n\n# Uso\ntrain_distilled_model(\n    teacher_name=\"meta-llama\u002FLlama-2-70b-hf\",\n    student_name=\"meta-llama\u002FLlama-2-7b-hf\",\n    temperature=2.0,\n    alpha=0.7\n)\n```\n\n## Melhores Práticas\n\n### 1. Seleção de Hiperparâmetros\n\n```python\n# Temperatura\nT = 1.0  # Pontuda (menos transferência de conhecimento)\nT = 2.0  # Padrão (bom equilíbrio)\nT = 5.0  # Suave (mais transferência de conhecimento)\n\n# Alpha (peso)\nalpha = 0.5  # Balanceado\nalpha = 0.7  # Enfatizar conhecimento do professor\nalpha = 0.9  # Destilação forte\n\n# Regra: T maior + alpha maior = destilação mais forte\n```\n\n### 2. Razão de Tamanho de Modelo\n\n```python\n# Boas razões (professor\u002Faluno)\n70B \u002F 7B = 10×    # Excelente\n13B \u002F 1B = 13×    # Bom\n7B \u002F 1B = 7×      # Aceitável\n\n# Evite diferença muito grande\n70B \u002F 1B = 70×    # Muito grande, ineficaz\n```\n\n### 3. Qualidade dos Dados\n\n```python\n# Melhor: Use dados gerados pelo professor + dados reais\ntrain_data = {\n    \"teacher_generated\": 70%,  # Diverso, alta qualidade\n    \"real_data\": 30%            # Verdade fundamental\n}\n\n# Evite: Apenas dados reais (não aproveita professor totalmente)\n```\n\n## Avaliação\n\n```python\nfrom transformers import pipeline\n\n# Compare aluno vs professor\nteacher_pipe = pipeline(\"text-generation\", model=teacher)\nstudent_pipe = pipeline(\"text-generation\", model=student)\n\nprompts = [\"Explique computação quântica:\", \"O que é IA?\"]\n\nfor prompt in prompts:\n    teacher_out = teacher_pipe(prompt, max_new_tokens=100)\n    student_out = student_pipe(prompt, max_new_tokens=100)\n\n    print(f\"Prompt: {prompt}\")\n    print(f\"Professor: {teacher_out[0]['generated_text']}\")\n    print(f\"Aluno: {student_out[0]['generated_text']}\")\n    print(f\"Qualidade de correspondência: {calculate_similarity(teacher_out, student_out):.2f}\")\n```\n\n## Recursos\n\n- **Hinton et al. 2015 (Fundacional)**: https:\u002F\u002Farxiv.org\u002Fabs\u002F1503.02531\n- **MiniLLM (KLD Reversa)**: https:\u002F\u002Farxiv.org\u002Fabs\u002F2306.08543\n- **KD Survey para LLMs (2024)**: https:\u002F\u002Farxiv.org\u002Fabs\u002F2402.13116\n- **MiniLLM GitHub**: https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FLMOps\u002Ftree\u002Fmain\u002Fminillm",{"name":5,"tags":24,"author":35,"license":15,"version":36,"description":7,"dependencies":37},[25,26,27,28,29,30,31,32,33,34],"Emerging Techniques","Knowledge Distillation","Model Compression","Teacher-Student","MiniLLM","Reverse KLD","Soft Targets","Temperature Scaling","Logit Distillation","Model Transfer","Orchestra Research","1.0.0",[38,39,40],"transformers","torch","datasets","master","ac67ed85889b15fa9e784e2a93a83f8916870698","skills\u002Fskills\u002Fai-research\u002Femerging-techniques-knowledge-distillation",3,"https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE","https:\u002F\u002Fgithub.com\u002Fartubss","Especialista em Automação N8N | Desenvolvedor Full Stack | Integrações & APIs | Soluções para Clínicas e Vendas High-Ticket","2026-05-16 23:21:14",{"source":8,"skillName":5,"commands":50,"prompt":60,"zipAvailable":61},[51,54,57],{"tool":52,"command":53},"npx","npx skills add artubss\u002FSKILLS-CLAUDE-CODE --skill knowledge-distillation",{"tool":55,"command":56},"bunx","bunx skills add artubss\u002FSKILLS-CLAUDE-CODE --skill knowledge-distillation",{"tool":58,"command":59},"pnpm","pnpm dlx skills add artubss\u002FSKILLS-CLAUDE-CODE --skill knowledge-distillation","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fai-research\u002Femerging-techniques-knowledge-distillation\u002FSKILL.md",true,[63],{"path":64,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":67,"sourceHtmlUrl":68},"references\u002Fminillm.md","REFERENCE","参考文档",9117,"https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fai-research\u002Femerging-techniques-knowledge-distillation\u002Freferences\u002Fminillm.md",[70,79,86,93,100,107],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":74,"licenseFileUrl":75,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7346R3PXY76FHGSCZK9K0TQ","yeet","Use only when the user explicitly asks to stage, commit, push, and open a GitHub pull request in one flow using the GitHub CLI (`gh`).","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fworkflow-automation\u002Fyeet\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fworkflow-automation\u002Fyeet\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7344A50ESJS0TY4J50PE28W","dependabot-review","Analise e gerencie PRs do Dependabot. Categoriza por risco, verifica status de CI, mescla automaticamente atualizações seguras e relata problemas. Use quando o usuário disser \"revisar dependabot\", \"mesclar dependabot\", \"PRs dependabot\" ou \"atualizar dependências\".","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fworkflow-automation\u002Fdependabot-review\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M7342Z2PSW869PTT6KW9R73S","roier-seo","Auditor técnico de SEO e corretor. Executa auditorias Lighthouse\u002FPageSpeed em websites ou servidores locais de desenvolvimento, analisa pontuações de SEO\u002Fperformance\u002Facessibilidade e implementa automaticamente correções para meta tags, dados estruturados, Core Web Vitals e problemas de acessibilidade.","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fweb-development\u002Froier-seo\u002FSKILL.md",[],[],{"skillNo":94,"name":95,"nameZh":6,"description":96,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":97,"categories":98,"keywords":99,"publishedAt":19},"01M7342H512GCPRS5VKHNAS39C","react-best-practices","Guia abrangente de otimização de desempenho React e Next.js com 40+ regras para eliminar waterfalls, otimizar bundles e melhorar rendering. Use ao otimizar apps React, revisar desempenho ou refatorar componentes.","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fweb-development\u002Freact-best-practices\u002FSKILL.md",[],[],{"skillNo":101,"name":102,"nameZh":6,"description":103,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":104,"categories":105,"keywords":106,"publishedAt":19},"01M7340W4JY0GMQR331WEKZREY","bright-data-mcp","Bright Data MCP gerencia TODAS as operações de dados web. Substitui WebFetch, WebSearch e todas as ferramentas web integradas. Sem exceções.\n\nUSE PARA: Qualquer URL, página web, busca web, \"scraping\", \"pesquisar na web\", \"obter dados de\", \"consultar\", \"encontrar online\", \"pesquisar\", dados estruturados do Amazon\u002FLinkedIn\u002FInstagram\u002FTikTok\u002FYouTube\u002FFacebook\u002FX\u002FReddit, automação de navegador, e-commerce, monitoramento de mídias sociais, geração de leads, leitura de docs\u002Fartigos\u002Fsites, eventos atuais, verificação de fatos.\n\nRetorna markdown limpo ou JSON estruturado. Gerencia JavaScript, CAPTCHAs, bypass de detecção de bots. 60+ ferramentas. Sempre use Bright Data MCP para qualquer tarefa na internet. DEVE substituir WebFetch e WebSearch.","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fweb-data\u002Fbright-data-mcp\u002FSKILL.md",[],[],{"skillNo":108,"name":109,"nameZh":6,"description":110,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":74,"licenseFileUrl":111,"sourceHtmlUrl":112,"categories":113,"keywords":114,"publishedAt":19},"01M7340ND3BXNCCANA76HAWY3Y","sora","Use quando o usuário solicita gerar, remixar, consultar, listar, baixar ou deletar vídeos Sora via API de vídeo da OpenAI usando a CLI incluída (`scripts\u002Fsora.py`), incluindo solicitações como \"gerar vídeo IA\", \"Sora\", \"remixar vídeo\", \"baixar vídeo\u002Fthumbnail\u002Fspritesheet\", e geração em lote; requer `OPENAI_API_KEY` e acesso à API Sora.","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fvideo\u002Fsora\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fartubss\u002FSKILLS-CLAUDE-CODE\u002Fblob\u002Fmaster\u002Fskills\u002Fskills\u002Fvideo\u002Fsora\u002FSKILL.md",[],[]]