Destile as respostas de um modelo maior em um modelo pequeno

Cerca de 22 minutos min de leitura, com 3 exemplos em 6 seções.

Edição 2026.11.9 Exemplos aprovados em 20 de nov de 2026 36 de 36 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.9. Leia o original

Ao final deste capítulo, você será capaz de treinar um pequeno modelo aluno com os rótulos que um modelo professor maior atribui às linhas de treinamento, medir com que frequência esses rótulos concordam com os rótulos de referência (gold) e decidir, a partir das mesmas mensagens, se o aluno vale a pena ser usado ao lado de um aluno treinado com os rótulos de referência.

Um roteador aprende a nomear a equipe a partir de mensagens rotuladas. Este capítulo pergunta se um modelo maior pode fazer essa rotulagem para as linhas de treinamento, de modo que um modelo pequeno aprenda com as respostas dele. Os rótulos de referência vêm do BANKING77. O capítulo 5 treinou uma cabeça sobre os rótulos de referência das linhas de treinamento, e o adaptador que ele salvou, banking77-lora-v1, é o adaptador rotulado por humanos. O resultado dele no teste é a referência para tudo o que este capítulo faz, e o limiar é o que o seu manifesto registra, escolhido em dev pela regra que o capítulo 5 aplicou.

Rotular os dados com a referência custa tempo de pessoas, e a destilação é a tentativa de contornar isso: as respostas de um modelo maior fazem o papel dos rótulos de referência. O modelo maior aqui é o substituto. Ele é maior do que o SmolLM2-135M-Instruct, o modelo base sobre o qual o roteador deste livro é construído, e responde à mesma pergunta que o roteador faz.

O que a destilação copia

Última alteração na edição 2026.11.9

A destilação treina um modelo pequeno para reproduzir um modelo grande. O artigo de Hinton, Vinyals e Dean, que deu nome à destilação, propôs treinar um modelo pequeno com as probabilidades que o modelo grande atribui a cada classe, como alvos suaves (Hinton et al., 2015, arXiv:1503.02531). Essas probabilidades carregam mais informação do que um único rótulo, argumenta o artigo, e um modelo pequeno treinado dessa forma pode, muitas vezes, aprender com bem menos dados do que o modelo grande precisa. Essa é a afirmação do próprio artigo, com base nos seus próprios experimentos, e não uma regra válida para toda tarefa.

Este capítulo não usa alvos suaves. O substituto devolve uma equipe para cada mensagem, a equipe que ele considera mais provável, e o aluno vê apenas essa equipe. Kim e Rush usaram a mesma simplificação para tradução, em que substituíram a distribuição do professor pela sua saída mais provável: "Nossa aproximação mais simples é substituir a distribuição q do professor pela sua moda" (Kim e Rush, 2016, arXiv:1606.07947). O cenário deles é tradução, não classificação. Nós tomamos emprestada a simplificação e a medimos nesta tarefa, em vez de presumir que ela se sustenta aqui. Neste caso, a resposta gulosa do professor cumpre o papel da moda: é a única equipe que o professor devolve para cada mensagem.

Duas coisas decorrem de treinar com um rótulo por mensagem. Um aluno aprende os erros do professor junto com as suas respostas corretas, porque o laço de treinamento trata um rótulo errado como um rótulo, da mesma forma que um rótulo certo. E os erros do aluno podem diferir dos do professor, razão pela qual vale medir o aluno tanto contra os rótulos de referência quanto contra o professor.

Regra prática: Antes de treinar um aluno com as respostas de um professor, meça com que frequência a resposta do professor coincide com o rótulo de referência nas linhas que você rotulou, e leia algumas das discordâncias. Espere que o aluno reproduza os erros do professor, e conte-os em mensagens que o aluno não viu durante o treinamento.

Um professor cujos termos permitem isso

O professor precisa ser um modelo cujos termos permitam treinar com as suas saídas. A versão GGUF do substituto neste livro é o repositório unsloth/Qwen3-4B-Instruct-2507-GGUF, arquivo Qwen3-4B-Instruct-2507-Q4_K_M.gguf, na revisão registrada no manifesto do professor. O modelo é o Qwen3-4B-Instruct-2507, da Qwen, e a versão é feita pela unsloth. Creditamos ambos. O model card dessa versão declara license: apache-2.0 e indica Qwen/Qwen3-4B-Instruct-2507 como seu modelo base (model card na revisão fixada). A licença do modelo base, em um commit fixado, é a Apache License 2.0. A Apache License 2.0, em sua seção 2, concede o direito de "to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works" (Apache License 2.0).

Lemos a Apache-2.0 como uma licença que não impõe nenhuma restrição ao uso das saídas de um modelo. O seu texto regula o Work e os Derivative Works, conforme a seção 2 acima indica, e não menciona saídas. Esta é a nossa leitura da licença, não uma citação dela, e vale apenas para a licença deste modelo. Os adaptadores que este livro distribui são licenciados sob a Apache-2.0, e o aviso ao lado deles informa a licença e a atribuição.

As licenças diferem. Uma licença de pesos abertos, como a Apache-2.0, regula os arquivos do modelo; um modelo hospedado é regido pelos termos de serviço do seu provedor, que podem proibir o uso do serviço ou de suas saídas para treinar um modelo concorrente. Os termos mudam, então leia os termos atuais de qualquer modelo com o qual você pretende treinar, no dia em que for usá-lo. Este livro nunca usa um modelo hospedado como professor.

O substituto é um modelo aberto, por isso a sua licença pode ser lida e o seu arquivo pode ser fixado por um hash, que o manifesto do professor registra. As respostas de um modelo hospedado podem mudar quando o provedor altera o modelo, e os seus termos podem proibir esse uso. São motivos para preferir um professor aberto cujo arquivo seja fixo, mesmo antes de se ler os seus termos.

Regra prática: Leia a licença e os termos de uso do professor no dia em que treinar. Nomeie o professor, a sua licença e a sua revisão no capítulo, e aponte o manifesto do aluno para o registro do professor. Não treine com as saídas de um modelo cujos termos o proíbam. Uma licença que não impõe restrição às saídas responde à pergunta apenas para aquela licença, então leia o seu texto antes de presumir a resposta para outro modelo.

Rotule as linhas de treinamento com o professor

Última alteração na edição 2026.11.2

O professor rotula apenas as linhas de treinamento. As linhas de desenvolvimento são mantidas para escolher os limiares, e as linhas de teste são mantidas para o relatório, como o capítulo 2 expôs. As linhas a rotular são sorteadas do arquivo de treinamento, fora do conjunto de desenvolvimento. As linhas rotuladas são as primeiras 1,000 de um sorteio aleatório com semente de 2,000 dessas linhas, um subconjunto aleatório delas, e o registro as ordena por índice antes de rotulá-las. A execução de rotulagem foi planejada para as 2,000, mas não conseguiu concluir tantas dentro do seu limite de tempo, então o livro relata as 1,000 linhas que rotulou.

O sorteio tem semente fixa. Rótulos já salvos para uma linha escolhida são mantidos e não são rotulados de novo, de modo que uma execução que para e continua acrescenta apenas as linhas que ainda não foram rotuladas. Não testamos se uma execução retomada produz os mesmos rótulos que uma única execução completa.

O substituto (stand-in) responde a cada mensagem com o prompt do roteador do capítulo 1. Ele decodifica de forma gulosa, com temperatura zero. Em um teste com 40 mensagens de teste, duas execuções deram respostas idênticas, e esse teste é a única verificação que fizemos de repetibilidade. Sua resposta é restringida por uma gramática aos 77 nomes de equipe, de modo que cada rótulo é uma equipe real.

teacher-agreement.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Measure how often the teacher's label matches gold on the training rows it labelled, and its accuracy on test_200from its recorded answers. The point rests on the agreement line; the example reads recorded answers only."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()RECORDED = router_lib.HERE / "data" / "recorded"train = router_lib.read_rows("train")teacher_rows = [json.loads(line) for line in (RECORDED / "teacher-labels" / "labels.jsonl").read_text().splitlines()]# row["index"] is the row's position in the training file; field 1 of a row is its gold teamagree = sum(row["label"] == train[row["index"]][1] for row in teacher_rows)n = len(teacher_rows)print(f"training rows labelled by the teacher: {n}")print(f"teacher agrees with gold on training rows: {agree}/{n} ({agree / n:.1%})")print(f"teacher disagrees with gold on training rows: {n - agree}/{n} ({(n - agree) / n:.1%})")test = router_lib.read_rows("test")sample = router_lib.read_sample("test_200")standin = router_lib.standin_answers()# sample holds test row positions; field 1 of a test row is its gold team, field 0 its textgolds = [test[i][1] for i in sample]teacher_preds = [standin[i] for i in sample]correct = sum(p == g for p, g in zip(teacher_preds, golds))print(f"messages on test_200 with a teacher answer: {sum(i in standin for i in sample)}/{len(sample)}")print(f"teacher accuracy on test_200: {correct}/{len(sample)} ({correct / len(sample):.1%})")
Saídapython teacher-agreement.py
training rows labelled by the teacher: 1000
teacher agrees with gold on training rows: 549/1000 (54.9%)
teacher disagrees with gold on training rows: 451/1000 (45.1%)
messages on test_200 with a teacher answer: 200/200
teacher accuracy on test_200: 109/200 (54.5%)

O rótulo do professor coincide com o rótulo gold em 549/1000 (54.9%) das 1000 linhas de treinamento que ele rotulou, e discorda em 451/1000 (45.1%). Um aluno treinado com as linhas em que há discordância aprende o rótulo errado como resposta para cada uma delas. As duas últimas linhas da saída vêm das respostas registradas do substituto sobre test_200, as 200 mensagens de teste que este capítulo relata. Ali o professor acerta em 109/200 (54.5%) mensagens.

Leia a linha teacher agrees with gold on training rows antes de treinar qualquer aluno. A linha teacher accuracy on test_200 é a precisão do próprio professor sobre mensagens que ninguém usou para treinamento, e é a referência para todas as medidas de cópia abaixo.

Contagens não mostram como são as discordâncias. Três linhas de treinamento, cada uma rotulada card_arrival no arquivo gold, mostram o padrão. Cada mensagem trata de um cartão que ainda não chegou, descrita aqui sem o seu texto, já que as mensagens nunca são citadas neste livro. O professor indicou card_delivery_estimate para duas delas e lost_or_stolen_card para a terceira, de modo que ele nomeia uma equipe diferente do rótulo gold em cada caso.

Regra prática: Meça a concordância do professor com o gold em uma amostra rotulada de linhas antes de treinar um aluno com os rótulos. Rotule apenas linhas fora de desenvolvimento e de teste, e registre o modelo do professor, sua versão e suas configurações no manifesto de registro do professor, e aponte para ele o manifesto do aluno, para que cada rótulo possa ser rastreado.

Treinar o aluno com os rótulos do professor

Última alteração na edição 2026.11.2

O aluno usa a receita do capítulo 5. Ele tem o mesmo modelo base, os mesmos alvos do LoRA, a mesma cabeça, a mesma semente e o mesmo tamanho de lote. Seus rótulos vêm do professor, em vez do arquivo gold. As linhas e os passos também diferem do capítulo 5: o aluno treina com 1000 linhas por 125 passos, e o adaptador rotulado por humanos treinou com 9000 linhas por 1125 passos. O controle da seção de concordância mantém as linhas e os passos do aluno e muda apenas os rótulos. O adaptador do aluno é banking77-distilled-v1. Seu manifesto registra as suas configurações e aponta para o registro do professor, teacher-labels/manifest.json, que informa o modelo e a versão do professor, as suas configurações e as linhas que ele rotulou, para que qualquer pessoa possa rastrear de onde vem cada rótulo.

A receita é mantida fixa de propósito. Se o aluno mudasse a receita e os rótulos ao mesmo tempo, uma diferença nos resultados poderia vir de qualquer uma das duas mudanças, e o leitor não saberia dizer qual delas. Manter a receita fixa faz com que os rótulos sejam a única diferença à qual os resultados podem ser atribuídos.

O limiar de um aluno é escolhido no dev pela mesma regra usada para o adaptador rotulado por humanos. A regra toma o menor limiar, em uma grade de centésimos, no qual as mensagens não encaminhadas têm pelo menos 0.90 de acurácia no dev. A regra tem uma alternativa de reserva (fallback) para um aluno que não consegue atingir essa meta. O fallback toma o limiar com a maior acurácia nas mensagens não encaminhadas, o menor deles em caso de empate, e ignora qualquer limiar que encaminhe todas as mensagens. A saída informa que o fallback foi usado. Essa é a regra do livro para um resultado que não atinge a meta, por isso ele é relatado como fallback e não como um aluno que atingiu a meta. Um limiar de fallback é escolhido a partir das mensagens que um limiar mantém no dev, e, com um limiar alto, isso pode ser apenas um punhado de mensagens. Trate um valor de fallback como provisório e relate-o com a taxa de encaminhamento que ele custa no teste, como faz este capítulo.

O limiar do aluno é escolhido em parte da divisão dev, 500 of 1003 mensagens, porque uma execução sobre todas as mensagens do dev não cabia no orçamento de tempo de dois núcleos de CPU. Os dois exemplos do aluno usam essa mesma parte, e o controle a usa para o seu próprio limiar, de modo que os dois limiares são escolhidos a partir das mesmas mensagens do dev. O limiar do adaptador rotulado por humanos, do capítulo 5, foi escolhido com todas as 1,003 mensagens do dev.

Regra prática: Escolha o limiar de um aluno no dev pela mesma regra usada para o adaptador rotulado por humanos e, quando nenhum limiar atingir a meta, informe que o limiar é o fallback. Relate a taxa de encaminhamento que o limiar custa ao lado da acurácia, com as duas contagens, antes de comparar o aluno com qualquer coisa.

Meça a concordância, não apenas a acurácia

Última alteração na edição 2026.11.9

Três medidas atravessam este capítulo, e cada uma responde a sua própria pergunta. O professor contra o gabarito nas linhas de treinamento pergunta se o professor acerta nas linhas que ele rotula, e é a que aparece acima. O aluno contra o professor em test_200 pergunta quanto do professor o aluno copia. O aluno contra o gabarito em test_200 pergunta com que frequência o aluno indica a equipe certa, que é o número pelo qual um roteador seria avaliado. Cada uma vem impressa com seu denominador: a primeira é lida nas 1,000 linhas de treinamento, e as outras duas nas mesmas 200 mensagens de teste.

Concordância e acurácia respondem a perguntas diferentes. A concordância com o professor diz quanto do professor o aluno aprendeu, esteja o professor certo ou errado. A acurácia em relação ao gabarito diz com que frequência o aluno indica a equipe certa. Um aluno pode concordar com um professor errado e errar também, e pode discordar de um professor errado e acertar. Imprimir as duas permite que você veja qual dessas situações está ocorrendo, em vez de inferi-la a partir de um único número.

student-recorded-adapter.py Python 3.12.15 · peft 0.21.3 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Score the distilled student banking77-distilled-v1 on test_200 beside the human-labelled adapter, with the student'sthreshold chosen on dev. The point rests on the student's accuracy line and its copy lines; both adapters are loadedand scored live, and nothing is trained."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()RECORDED = router_lib.HERE / "data" / "recorded"tokenizer, student = router_lib.load_classifier(RECORDED / "distill-student" / "adapter")DEV_N = 500  # the first 500 of the 1,003 dev messages: the run's time budget under two CPUs# reached is False when no threshold meets the target, and the threshold returned is then the fallbackthreshold, reached = router_lib.dev_threshold(student, tokenizer, target=0.90, n=DEV_N)print(f"dev messages used: {DEV_N} of {len(router_lib.read_sample('dev'))}")print(f"dev threshold reaching 0.90 accuracy not handed off: {'yes' if reached else 'no'}")print(f"student threshold chosen on dev: {threshold:.2f}")test = router_lib.read_rows("test")sample = router_lib.read_sample("test_200")# sample holds test row positions; field 1 of a test row is its gold team, field 0 its textgolds = [test[i][1] for i in sample]texts = [test[i][0] for i in sample]student_preds, student_confs = router_lib.classify(student, tokenizer, texts)router_lib.print_copy_report("banking77-distilled-v1", student_preds, student_confs, golds, threshold)# chapter 5 chose the adapter's threshold on dev, and its manifest records the value used herelora = json.loads((RECORDED / "lora-full" / "manifest.json").read_text())_, lora_model = router_lib.load_classifier(RECORDED / "lora-full" / "adapter")lora_preds, lora_confs = router_lib.classify(lora_model, tokenizer, texts)router_lib.print_copy_report("banking77-lora-v1", lora_preds, lora_confs, golds, lora["handoff_threshold"])teacher = router_lib.standin_answers()teacher_preds = [teacher[i] for i in sample]matches = sum(s == t for s, t in zip(student_preds, teacher_preds))# positions within sample where the student's answer is not the gold teamwrong = [k for k in range(len(sample)) if student_preds[k] != golds[k]]wrong_like_teacher = sum(student_preds[k] == teacher_preds[k] for k in wrong)print(f"student answers equal to teacher answers on test_200: {matches}/{len(sample)} ({matches / len(sample):.1%})")print(f"student errors on test_200: {len(wrong)}/{len(sample)} ({len(wrong) / len(sample):.1%})")print(f"student errors equal to the teacher's answer: {wrong_like_teacher}/{len(wrong)}")
Saídapython student-recorded-adapter.py
dev messages used: 500 of 1003
dev threshold reaching 0.90 accuracy not handed off: no
student threshold chosen on dev: 0.68
banking77-distilled-v1 accuracy on test_200: 69/200 (34.5%)
banking77-distilled-v1 handed off: 150/200 (75.0%)
banking77-distilled-v1 accuracy on messages not handed off: 28/50 (56.0%)
banking77-lora-v1 accuracy on test_200: 172/200 (86.0%)
banking77-lora-v1 handed off: 33/200 (16.5%)
banking77-lora-v1 accuracy on messages not handed off: 156/167 (93.4%)
student answers equal to teacher answers on test_200: 100/200 (50.0%)
student errors on test_200: 131/200 (65.5%)
student errors equal to the teacher's answer: 36/131

O aluno fica bem atrás do adaptador rotulado por humanos, e a diferença não está apenas nos encaminhamentos, como mostram os números gerais abaixo. Em test_200, o aluno acerta 69/200 (34.5%) mensagens e encaminha 150/200 (75.0%), enquanto o adaptador acerta 172/200 (86.0%) mensagens e encaminha 33/200 (16.5%). O limiar do aluno é o mecanismo de reserva descrito acima. A acurácia de cada execução nas mensagens que ela mantém está no limiar próprio dela, e a saída apresenta ambos ao lado deste parágrafo.

As medidas de cópia vêm a seguir. A resposta do aluno é igual à do professor em 100/200 (50.0%) mensagens, e o próprio professor acerta em 109/200 (54.5%). Um aluno que copia de perto o professor, portanto, copia também as respostas erradas dele. O aluno comete 131/200 (65.5%) erros em test_200. Desses erros, 36/131 repetem a resposta do professor. Os demais diferem dela, de modo que os erros de um aluno não são apenas os erros do professor.

A comparação com o adaptador isolado mistura duas coisas. O adaptador aprendeu com os rótulos de gabarito da divisão de treinamento completa, e o aluno aprendeu com os rótulos do professor em um conjunto menor de linhas. Uma diferença entre eles pode vir dos rótulos, do número de linhas ou de ambos. Para separar esses fatores, o livro registra a mesma receita nas mesmas linhas, mas com rótulos de gabarito. O controle, banking77-gold-1000-v1, é a receita do aluno treinada com rótulos de gabarito, e suas linhas são as linhas que o professor rotulou.

student-vs-gold-control.py Python 3.12.15 · peft 0.21.3 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Put the student banking77-distilled-v1 beside its control banking77-gold-1000-v1, which has the same recipe and thesame 1,000 training rows but gold labels, on the same test_200 messages. The point rests on the two counts of messageseach adapter gets right that the other gets wrong, which need no threshold; both adapters are scored live, and nothingis trained."""import jsonimport osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()RECORDED = router_lib.HERE / "data" / "recorded"DEV_N = 500  # the first 500 of the dev messages, as student-recorded-adapter uses: the time budget under two CPUsprint(f"dev messages used: {DEV_N} of {len(router_lib.read_sample('dev'))}")test = router_lib.read_rows("test")sample = router_lib.read_sample("test_200")# sample holds test row positions; field 1 of a test row is its gold team, field 0 its textgolds = [test[i][1] for i in sample]texts = [test[i][0] for i in sample]runs = {}for name, folder in [("banking77-distilled-v1", "distill-student"), ("banking77-gold-1000-v1", "gold-same-rows")]:    tokenizer, model = router_lib.load_classifier(RECORDED / folder / "adapter")    threshold, reached = router_lib.dev_threshold(model, tokenizer, target=0.90, n=DEV_N)    print(f"{name} dev threshold reaching 0.90 accuracy not handed off: {'yes' if reached else 'no'}")    print(f"{name} threshold chosen on dev: {threshold:.2f}")    preds, confs = router_lib.classify(model, tokenizer, texts)    router_lib.print_copy_report(name, preds, confs, golds, threshold)    runs[name] = [p == g for p, g in zip(preds, golds)]# dict order is insertion order: the student first, then the controlstudent, control = runs.values()n = len(golds)print(f"test_200 messages the student gets right and the control gets wrong: {sum(s and not c for s, c in zip(student, control))}/{n}")print(f"test_200 messages the control gets right and the student gets wrong: {sum(c and not s for s, c in zip(student, control))}/{n}")# Recipe sizes from the recorded manifests: the student and its control share rows and steps;# the human-labelled adapter does not. Its manifest names its row count train_rows, not rows, which is why rows_key differs.for name, folder, rows_key in [    ("banking77-distilled-v1", "distill-student", "rows"),    ("banking77-gold-1000-v1", "gold-same-rows", "rows"),    ("banking77-lora-v1", "lora-full", "train_rows"),]:    settings = json.loads((RECORDED / folder / "manifest.json").read_text())["settings"]    print(f"{name} training rows: {settings[rows_key]}")    print(f"{name} training steps: {settings['steps']}")
Saídapython student-vs-gold-control.py
dev messages used: 500 of 1003
banking77-distilled-v1 dev threshold reaching 0.90 accuracy not handed off: no
banking77-distilled-v1 threshold chosen on dev: 0.68
banking77-distilled-v1 accuracy on test_200: 69/200 (34.5%)
banking77-distilled-v1 handed off: 150/200 (75.0%)
banking77-distilled-v1 accuracy on messages not handed off: 28/50 (56.0%)
banking77-gold-1000-v1 dev threshold reaching 0.90 accuracy not handed off: no
banking77-gold-1000-v1 threshold chosen on dev: 0.97
banking77-gold-1000-v1 accuracy on test_200: 77/200 (38.5%)
banking77-gold-1000-v1 handed off: 197/200 (98.5%)
banking77-gold-1000-v1 accuracy on messages not handed off: 3/3 (100.0%)
test_200 messages the student gets right and the control gets wrong: 24/200
test_200 messages the control gets right and the student gets wrong: 32/200
banking77-distilled-v1 training rows: 1000
banking77-distilled-v1 training steps: 125
banking77-gold-1000-v1 training rows: 1000
banking77-gold-1000-v1 training steps: 125
banking77-lora-v1 training rows: 9000
banking77-lora-v1 training steps: 1125

O controle também não tem um limiar que atinja a meta de validação, e por isso usa o mecanismo de reserva; seu limiar é provisório por essa razão. Ele encaminha 197/200 (98.5%) de test_200, e acerta 3/3 (100.0%) das mensagens que mantém. Três mensagens não constituem uma medida. A acurácia geral não depende de limiar, porque conta cada mensagem independentemente do limiar, de modo que os 77/200 (38.5%) do controle ficam diretamente ao lado dos 69/200 (34.5%) do aluno.

A comparação justa é feita sobre as próprias respostas, e não exige limiar, pois compara as equipes. O controle acerta e o aluno erra em 32/200 mensagens, e o aluno acerta e o controle erra em 24/200. O controle não tem vantagem sobre o aluno que esta amostra possa estabelecer, por isso consideramos 200 mensagens insuficientes para afirmar que uma fonte de rótulos é melhor que a outra.

O adaptador foi treinado com 9000 linhas por 1125 passos, enquanto o controle e o aluno compartilham as 1000 linhas e 125 passos, de modo que a diferença entre o controle e o adaptador mistura o número de linhas e de passos com qualquer outra coisa em que as duas execuções diferem, e este capítulo não os separa.

Regra prática: Compare dois adaptadores apenas nas mesmas mensagens e nas mesmas linhas. Conte as mensagens que cada um acerta e o outro erra, e imprima as duas contagens com seu denominador. Não coloque lado a lado acurácias obtidas com limiares diferentes, como se fossem a mesma medida.

Quando o professor erra

Última alteração na edição 2026.11.9

Um estudante treinado com um rótulo por mensagem aprende os rótulos que recebe. Quando o professor erra em uma linha, o estudante foi exposto à equipe errada para aquela linha e não tem como saber o contrário. A concordância do professor com o gabarito nas linhas de treino, medida acima, é a parcela dos rótulos de treino do professor que estão corretos. O estudante é medido em mensagens de teste, e não nas suas linhas de treino, porque seus números nas linhas em que treinou mostrariam o que ele memorizou, e não o que aprendeu.

Nesta tarefa, o estudante que aprende com os rótulos do substituto não é o que você deve colocar em produção, como mostram os números acima. O Capítulo 7 quantiza banking77-lora-v1, o adaptador rotulado por humanos, e não o estudante.

Leia a medida de cópia junto com a acurácia. Se o estudante copia o professor na maioria das mensagens e o professor erra em muitas delas, o estudante herda esses erros, e sua acurácia contra o gabarito cai junto com a do professor. Se o estudante discorda do professor em muitas mensagens e mesmo assim erra, ele está aprendendo outra coisa que não os rótulos, e a primeira suspeita é o número de linhas de treino. Essa é uma regra prática baseada nos números do próprio livro, e este capítulo não a testa.

A destilação vale o seu custo em alguns casos. Recomendamos experimentá-la quando os rótulos de gabarito são escassos, quando o professor é forte na sua tarefa e quando uma amostra de rótulos de gabarito mostra que o professor concorda com eles o bastante para tornar aceitáveis os erros do estudante. Quando você já tem rótulos de gabarito para as suas linhas de treino, treine com eles e use um professor apenas para verificá-los. Um modelo professor também muda. Trate uma nova versão do professor como uma nova gravação: seus rótulos mudam, de modo que o manifesto, o limiar e as medidas do estudante precisam ser refeitos.

Em produção, a falha é silenciosa. Um estudante que copia o seu professor devolve um fluxo constante de equipes e uma taxa de encaminhamento constante, e nenhum dos dois alerta alguém. Verifique o estudante contra rótulos de gabarito em uma amostra de mensagens que uma pessoa tenha rotulado, em um cronograma fixo. O Capítulo 9 descreve o mesmo tipo de amostra para os encaminhamentos do adaptador como um próximo passo, e este livro não a constrói. Compare as respostas do estudante com esses rótulos, e não com os do professor, porque concordar com o professor não diz nada sobre a equipe à qual uma mensagem pertence.

As decisões que este capítulo tomou são estas:

  • O professor rotula apenas linhas de treino, nunca linhas de validação ou de teste.
  • O professor é o substituto, Qwen3-4B-Instruct-2507, sob Apache-2.0, e nenhum modelo hospedado é usado.
  • O estudante é treinado com a mesma receita do adaptador rotulado por humanos, e seu limiar segue a mesma regra, com o recurso de reserva informado como reserva.
  • O estudante é comparado com um controle treinado com rótulos de gabarito para as mesmas linhas, nas mesmas mensagens, e os dois compartilham as suas linhas, de modo que uma diferença entre eles vem dos rótulos, e não das linhas.

Os rótulos de um professor levam os seus erros para o estudante, por isso a concordância com o gabarito decide se a destilação vale a pena.

Regra prática: Treine um estudante com os rótulos de um professor somente quando você tiver rótulos de gabarito em número insuficiente para a tarefa e uma amostra de rótulos de gabarito mostrar que o professor concorda com eles o suficiente. Compare o estudante com o adaptador rotulado por humanos, e com a mesma receita sobre rótulos de gabarito, nas mesmas mensagens, antes de escolhê-lo. Quando o estudante perder, entregue o adaptador e diga isso no relatório.

Este capítulo, nesta edição

Edição 2026.11.9Exemplos aprovados em 20 de nov de 20263 de 3 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.9.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 6 de 10: Destile as respostas de um modelo maior em um modelo pequeno

  1. O que a destilação copia
  2. Um professor cujos termos permitem isso
  3. Rotule as linhas de treinamento com o professor
  4. Treinar o aluno com os rótulos do professor
  5. Meça a concordância, não apenas a acurácia
  6. Quando o professor erra

Voltar ao topoTodos os capítulos