Quantize o roteador e meça o que muda

Cerca de 21 minutos min de leitura, com 2 exemplos em 5 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ê saberá armazenar os pesos do backbone do roteador ajustado como inteiros de 8 bits em uma única chamada, contar as previsões que mudam em uma amostra fixa e dizer o que essa contagem mostra e o que não mostra. Você também verá como a velocidade é medida e o que a gravação feita em uma máquina revelou.

Uma cópia quantizada do roteador ocuparia menos espaço; a questão é se ela ainda responde da mesma forma. O capítulo 5 deixou o roteador como um adaptador, banking77-lora-v1, cujos pesos são float32. Seu limiar de encaminhamento é 0.63, escolhido no conjunto de desenvolvimento pela regra descrita no capítulo 5. A quantização armazena os pesos em menos bits. Um modelo quantizado ocupa menos espaço para os seus pesos e pode devolver respostas diferentes. Este capítulo mede a segunda parte, as respostas diferentes, sobre a amostra fixa de 200 mensagens de teste que o capítulo 5 avaliou, test_200. Ele não afirma que quantizar é sem custo.

A cópia poderia ocupar o lugar do adaptador float32 na caixa de entrada que roteia as mensagens de suporte do banco, e três perguntas vêm antes disso. Quantos bytes ocupam os pesos da cópia, em comparação com os do adaptador? A cópia responde às mesmas mensagens da mesma forma? E ela é mais rápida na máquina que atende a caixa de entrada? As duas primeiras podem ser medidas aqui, a partir das formas do modelo e de uma amostra fixa. A terceira vem de uma gravação feita em uma máquina identificada, e a seção sobre velocidade diz o que essa gravação revelou e o que ela não cobre. Cada resposta é uma contagem com seu denominador, ou uma razão com seus insumos nomeados.

Uma chamada para quantizar as camadas lineares

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

Uma camada linear é uma matriz de pesos que mapeia um vetor em outro. A espinha dorsal do roteador é formada por elas. Quantizar uma camada armazena cada um de seus pesos como um inteiro de 8 bits, com uma escala que converte os inteiros de volta em valores de ponto flutuante aproximados. Menos bits por peso significam menos bytes para a camada, e as respostas podem se alterar, porque os valores calculados pela camada já não são os exatos.

A escala é o que faz o esquema funcionar para uma matriz inteira. Uma única escala para toda a matriz precisa cobrir seu maior peso, de modo que as linhas cujos pesos são pequenos recebem uma grade grosseira. Jacob et al. (2018) relatam que uma resolução compartilhada produz para canais com faixas estreitas um erro relativo muito maior (arXiv:1712.05877). Esse é um resultado de CNN, portanto aqui ele serve como motivo para testar escalas por linha, e não como medição. Uma escala por linha permite que cada linha de saída use a faixa completa dos inteiros de 8 bits para os seus próprios pesos. É por isso que a contagem de bytes soma uma escala float32 para cada linha de saída. As escalas são poucas, mas não são gratuitas, e por isso a contagem de bytes abaixo as inclui.

O auxiliar deste livro, int8_classifier, descreve seu esquema em sua docstring: pesos int8 por linha, com ativações float32. O esquema é o Int8WeightOnlyConfig do torchao, que o código-fonte do torchao na versão v0.18.0 descreve como "quantização int8 simétrica por canal apenas nos pesos, aplicada a camadas lineares". O auxiliar aplica-o em três etapas. Ele funde os pesos do adaptador ao modelo base com merge_and_unload do PEFT. Chama quantize_ de torchao.quantization com Int8WeightOnlyConfig, e passa um filtro que seleciona cada camada nn.Linear exceto a que se chama score. Por fim, devolve o modelo em modo de avaliação. A cópia int8, chamada banking77-lora-v1-int8 nas gravações, é o modelo que o auxiliar devolve: um modelo derivado construído a partir do adaptador, e não um segundo adaptador. A camada de saída, score, é a cabeça treinada no capítulo 5, e a seção sobre ela explica por que o auxiliar a deixa de fora.

A fusão vem primeiro por um motivo. O capítulo 5 descreveu o adaptador como um pequeno conjunto de matrizes ao lado das camadas do modelo base. A fusão incorpora a atualização do adaptador aos pesos base, de modo que cada camada passa a ser uma única matriz de pesos, quantizada uma vez, e a contagem de camadas descreve o roteador. Sem a fusão, a mesma chamada também quantizaria as matrizes do próprio adaptador como camadas int8 separadas.

O código PyTorch mais antigo usa torch.ao.quantization.quantize_dynamic, que também armazena os pesos Linear como int8, mas quantiza as ativações durante a execução, em um esquema diferente. O PyTorch 2.15 descontinua essa API, e seu aviso aponta para quantize_ do torchao (PyTorch v2.15.0, torch/ao/quantization/utils.py), que o README do torchao na versão v0.18.0 apresenta como a migração. Os exemplos deste livro não chamam nenhuma API descontinuada.

int8-layers-and-bytes.py Python 3.12.15 · peft 0.21.3 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Counts the backbone Linear layers the int8 copy quantizes, and the weight bytes they store, from their shapes.The prose's saving rests on the last printed line, the int8 share of float32 weight bytes; the head assert checks that the score head is not quantized."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)  # the counts come from shapes, so the thread count changes no printed lineimport router_lib  # noqa: E402router_lib.setup_runtime()  # fixes the seeds, requires deterministic algorithms and sets float32 as the default dtypeRECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"_, model = router_lib.int8_classifier(RECORDED / "adapter")  # merges the adapter, then quantizes every backbone Linear, not scorelayers = router_lib.backbone_linears(model)  # (name, layer) pairs, all except scorequantized = [layer for _, layer in layers if router_lib.is_int8(layer)]  # a torchao int8 weight, not a float oneweights = sum(layer.weight.numel() for _, layer in layers)rows = sum(layer.weight.shape[0] for _, layer in layers)  # weight shape is (output rows, input size)print(f"backbone Linear layers: {len(layers)}")print(f"backbone Linear layers quantized to int8: {len(quantized)}")head_quantized = router_lib.is_int8(model.score)assert not head_quantized, "the score head must stay float32"print(f"score head quantized: {'yes' if head_quantized else 'no'}")print(f"score head weight dtype: {model.score.weight.dtype}")print(f"weights in backbone Linear layers: {weights}")print(f"output rows in backbone Linear layers: {rows}")float_bytes = 4 * weightsint8_bytes = 1 * weights + 4 * rows  # one byte a weight, plus one float32 scale (4 bytes) for each output rowprint(f"weight bytes, int8 as a share of float32: {int8_bytes / float_bytes:.1%}")
Saídapython int8-layers-and-bytes.py
backbone Linear layers: 210
backbone Linear layers quantized to int8: 210
score head quantized: no
score head weight dtype: torch.float32
weights in backbone Linear layers: 106168320
output rows in backbone Linear layers: 155520
weight bytes, int8 as a share of float32: 25.1%

Construir a cópia int8 e contar suas camadas e pesos mostra o que o auxiliar quantizou. A espinha dorsal tem 210 camadas lineares, e a cópia int8 quantiza 210 delas. Essas camadas contêm 106168320 pesos, distribuídos em 155520 linhas de saída.

A última linha é aritmética sobre formas, e não uma medição de arquivo ou de processo. Um peso float32 ocupa 4 bytes. Um peso int8 ocupa 1 byte, e o cálculo acrescenta uma escala float32, de 4 bytes, para cada linha de saída, porque essa é a convenção que o esquema do auxiliar adota. Sobre os pesos dessas camadas, a cópia int8 ocupa 25.1% dos bytes float32. Um quarto dos bytes float32 corresponde aos próprios pesos, e o restante corresponde às escalas. O número cobre apenas os pesos dessas camadas. Ele deixa de fora todos os outros tensores que o modelo mantém, portanto não diz nada sobre o tamanho de um arquivo em disco nem sobre a memória usada por um roteador em execução.

Os bytes importam na máquina de serviço apenas se a memória dela precisar conter os pesos. Se isso acontece depende da máquina e do restante do processo, o que este capítulo não mede. A razão indica ao leitor quanto do orçamento de pesos a cópia libera.

Importar o torchao imprime avisos na saída de erro padrão, e a primeira execução de um exemplo pode imprimir um relatório de carregamento do transformers. Eles vêm do próprio código de importação das bibliotecas, e não de uma chamada feita pelos exemplos, e nada nos exemplos os suprime ou os trata. Algumas linhas dizem que o torchao não conseguiu carregar suas bibliotecas de kernel exclusivas de GPU, que o caminho em CPU não usa. Um SyntaxWarning do próprio código-fonte do torchao aparece apenas na primeira importação, antes de o Python armazenar em cache o bytecode. Avisos de que register_constant() está descontinuado vêm do torch e são disparados pela importação do torchao. O relatório de carregamento lista score.weight como MISSING: o checkpoint base não tem cabeça de classificação, então o transformers inicia uma nova, e a cabeça salva no adaptador a substitui. Nenhuma dessas mensagens altera alguma linha de saída. O livro fixa o torchao na versão 0.18.0 em seu arquivo de requisitos, e todos os exemplos usam essa fixação.

Regra prática: quantize apenas as camadas que você consegue nomear, mantenha a camada de saída em float32 e conte os bytes a partir das formas antes de afirmar qualquer economia. Relate a economia como uma razão entre bytes de pesos, com a contagem de camadas ao lado, e nunca como tamanho de arquivo ou como velocidade.

Contar as previsões que mudam

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

A quantização altera os números que cada camada calcula, então as respostas também podem mudar. O teste de uma cópia quantizada é verificar se ela responde às mesmas mensagens da mesma forma.

Pontuar test_200 com as duas cópias no limiar do manifesto do capítulo 5 mostra se elas respondem de modo semelhante. Para cada cópia, a execução conta as respostas corretas, os encaminhamentos e a acurácia nas mensagens não encaminhadas. Em seguida, conta as mensagens cuja equipe difere entre as duas cópias e as decisões de encaminhamento que diferem. A mesma execução, int8-changed-predictions, também pontua uma terceira cópia, com a cabeça quantizada também, para a seção sobre a cabeça de pontuação.

As duas cópias são tratadas de forma diferente de propósito. O lado float32 é o adaptador como o capítulo 5 o carregou, sem mesclagem, enquanto o lado int8 é mesclado primeiro, porque o auxiliar mescla antes de quantizar. Assim, a contagem abaixo considera a mesclagem e a quantização juntas. A execução nunca pontua uma cópia float32 mesclada isoladamente, e o capítulo não afirma que a mesclagem sozinha não altera nada.

int8-changed-predictions.py Python 3.12.15 · peft 0.21.3 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Scores test_200 with the float32 adapter, its int8 copy and the copy with the head in int8, at the threshold in chapter 5's manifest.The prose's point rests on the line that counts predictions changed by int8, read with the hand-off line under it."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)  # two threads for these forward passes; the speed section's recording uses fourimport router_lib  # noqa: E402router_lib.setup_runtime()  # fixes the seeds, requires deterministic algorithms and sets float32 as the default dtypeRECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"threshold = json.loads((RECORDED / "manifest.json").read_text())["handoff_threshold"]  # chosen on dev in chapter 5, stored in the manifesttest = router_lib.read_rows("test")  # (text, label index) pairssample = router_lib.read_sample("test_200")  # fixed row indices, so every copy scores the same messagesgolds = [test[i][1] for i in sample]  # index 1 of each row is its gold teamtexts = [test[i][0] for i in sample]tokenizer, float_model = router_lib.load_classifier(RECORDED / "adapter")  # the adapter as chapter 5 loaded it, unmergedfloat_preds, float_confs = router_lib.classify_by_length(float_model, tokenizer, texts)  # results in the order of texts_, int8_model = router_lib.int8_classifier(RECORDED / "adapter")  # merged first, then backbone quantized, head float32int8_preds, int8_confs = router_lib.classify_by_length(int8_model, tokenizer, texts)_, head_model = router_lib.int8_classifier_all_linears(RECORDED / "adapter")  # as above, with the score head quantized toohead_preds, head_confs = router_lib.classify_by_length(head_model, tokenizer, texts)print(f"handoff threshold from manifest: {threshold:.2f}")print(f"messages on test_200: {len(texts)}")router_lib.print_copy_report("float32", float_preds, float_confs, golds, threshold)  # a handed-off message is wrong if its team is wrong; the last measure divides by kept messages onlyrouter_lib.print_copy_report("int8", int8_preds, int8_confs, golds, threshold)changed, handoffs = router_lib.count_changes(float_preds, float_confs, int8_preds, int8_confs, threshold)  # a changed prediction is a different team, handed off or not; a changed hand-off is a confidence on the other side of the thresholdprint(f"predictions changed by int8: {changed}/{len(texts)} ({changed / len(texts):.1%})")print(f"hand-off decisions changed by int8: {handoffs}/{len(texts)}")changed_head, _ = router_lib.count_changes(float_preds, float_confs, head_preds, head_confs, threshold)print(f"predictions changed with the head in int8 too: {changed_head}/{len(texts)}")
Saídapython int8-changed-predictions.py
handoff threshold from manifest: 0.63
messages on test_200: 200
float32 accuracy on test_200: 172/200 (86.0%)
float32 handed off: 33/200 (16.5%)
float32 accuracy on messages not handed off: 156/167 (93.4%)
int8 accuracy on test_200: 172/200 (86.0%)
int8 handed off: 33/200 (16.5%)
int8 accuracy on messages not handed off: 156/167 (93.4%)
predictions changed by int8: 0/200 (0.0%)
hand-off decisions changed by int8: 0/200
predictions changed with the head in int8 too: 1/200

Nesta amostra, a cópia int8 altera 0/200 (0.0%) previsões e 0/200 decisões de encaminhamento. A cópia que também quantiza a cabeça é contada na seção sobre a cabeça de pontuação. A saída ao lado deste parágrafo informa a acurácia de cada cópia, seus encaminhamentos e sua acurácia nas mensagens não encaminhadas, cada um com seu denominador.

As três medidas são as que o capítulo 2 definiu, e cada uma tem seu denominador. A acurácia divide as mensagens corretas por todas as 200, de modo que uma mensagem encaminhada conta como errada se sua equipe estiver errada. A taxa de encaminhamento divide as mensagens abaixo do limiar pelas 200. A acurácia nas mensagens não encaminhadas divide as corretas entre as mensagens mantidas, e não é definida quando nenhuma é mantida. A contagem de previsões alteradas usa as mesmas 200 mensagens e faz uma pergunta que as três medidas não fazem: as duas cópias concordaram em cada uma? Concordância não é correção, e por isso a saída também imprime a acurácia.

Uma previsão alterada não é automaticamente uma perda. Ela pode transformar uma equipe errada em certa, ou uma equipe certa em errada, e a contagem sozinha não diz qual dos dois. Para ler a direção, compare a equipe de cada cópia com o rótulo de referência em cada mensagem em que as cópias divergem. A acurácia pode esconder isso. Duas cópias podem ter a mesma acurácia enquanto mensagens diferentes estão certas em cada uma, de modo que o mesmo total não diz nada sobre quais mensagens passaram de certas a erradas ou o inverso. Quando a contagem é zero, não há inversões a ler em nenhuma direção. Um leitor que obtém uma contagem diferente de zero deve ler as inversões antes de ler os totais.

Uma inversão tem um custo concreto quando uma cópia atende a fila. Suponha que o adaptador float32 envie uma mensagem para card_arrival e a cópia int8 envie a mesma mensagem para card_delivery_estimate. Ambas são equipes, e apenas uma pode ser o rótulo de referência da mensagem, de modo que a mudança corrige uma resposta ou quebra uma, a menos que ambas estejam erradas. A caixa de entrada envia a mensagem a uma equipe de qualquer forma. A mudança chegaria à equipe de suporte que atende a fila dessa equipe, e ninguém a veria em um total. A contagem é o que torna essa mudança visível antes que a cópia atenda qualquer mensagem.

Leia a contagem de previsões alteradas como um resultado, de um adaptador em um limiar, e não como uma garantia. Uma amostra, adaptador ou limiar diferente poderia mostrar uma mudança, e uma amostra de 200 pode deixar passar uma mudança que é rara em um fluxo completo de mensagens.

A contagem trata apenas de previsões e de mais nada. A cópia também mantém suas ativações em float32, como diz a documentação do auxiliar, de modo que esta contagem nada informa sobre uma cópia que quantiza também as ativações. Este capítulo não mede essa cópia.

Regra prática: Conte as previsões alteradas nas mesmas mensagens, no mesmo limiar, para as duas cópias, e imprima cada contagem com seu denominador ao lado da acurácia e da contagem de encaminhamentos. Quando a contagem for zero, informe-a como zero nessa amostra, e nomeie a amostra e o adaptador de onde ela foi tirada.

Mantenha a cabeça de pontuação em float32

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

A cabeça de pontuação é a camada com 77 saídas, uma para cada time. Seu softmax dá a confiança que o capítulo 5 compara com o limiar, e sua maior probabilidade é o time que o roteador devolve. O auxiliar deixa a cabeça fora da chamada, de modo que ela permanece em float32. Esta seção explica por que o livro faz essa escolha e o que a contagem mostra a respeito.

A cópia que este capítulo usa mantém a cabeça em float32, e essa escolha se apoia em uma contagem, obtida de int8-changed-predictions. Com a cabeça também em int8, 1/200 previsões mudam nesta amostra. A contagem não ordena as camadas por sensibilidade, e o capítulo não afirma que a cabeça é, ou não é, a origem de uma mudança.

As mensagens em risco são as que têm confiança um pouco acima do limiar. Uma mudança na cabeça pode levar uma delas abaixo do limiar, e a mensagem então vai para uma pessoa, e não para um time. A contagem de decisões de encaminhamento alteradas na seção anterior mostra se uma cópia altera alguma delas, e nesta execução a cópia int8 altera 0/200 decisões de encaminhamento.

O que o auxiliar fez com a cabeça está em int8-layers-and-bytes. A cabeça não é quantizada, como afirma esse exemplo, e seus pesos são torch.float32. Essas linhas impressas vêm da mesma execução das contagens de camadas da primeira seção, de modo que as duas podem ser comparadas diretamente.

A contagem de previsões alteradas abrange toda a cópia int8 e a cópia com a cabeça também quantizada. Ela não separa nenhuma das duas camada por camada, por isso não consegue dizer de qual camada vem uma mudança. Descobrir isso exige quantizar uma camada de cada vez e contar novamente na divisão de desenvolvimento (dev).

Regra prática: Mantenha a cabeça de pontuação em float32, a menos que uma contagem na divisão dev, no limiar escolhido, mostre que uma cabeça quantizada não altera nenhum time nem nenhum encaminhamento de que você depende. Diga em qual limiar você fez a contagem.

Medir a velocidade em uma gravação

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

Menos bytes para os pesos não torna, por si só, um modelo mais rápido, e este capítulo não afirma que torne. Se a cópia int8 calcula mais rápido em uma determinada CPU depende das rotinas aritméticas que executam nessa CPU, por isso o livro mede isso em uma máquina específica, identificada pelo nome.

Nenhum exemplo imprime um tempo de execução. Um tempo muda conforme a máquina e a carga sobre ela, de modo que um exemplo que imprimisse um tempo produziria uma saída diferente a cada execução, e os exemplos do livro precisam produzir a mesma saída sempre. A razão de velocidade, em vez disso, pertence a uma gravação.

A quantização int8 apenas nos pesos economizou bytes de pesos, e saber se a cópia também calcula mais rápido em uma CPU é uma questão separada. A gravação throughput testa isso. Ela mede o tempo da cópia int8 deste capítulo, banking77-lora-v1-int8, construída pelo mesmo auxiliar que os exemplos usam, comparando-a com o adaptador em float32 e com o substituto, na máquina indicada no seu manifesto. Nessa máquina, com quatro threads e lotes de 16, a cópia int8 processou mensagens por segundo na proporção de 0.9 vezes as do classificador em float32; portanto, a gravação não oferece nenhuma razão de velocidade para servir o int8. Capítulo 10 apresenta as taxas junto com a máquina em que foram medidas. A gravação não mediu o modelo de 360M, e este capítulo não afirma velocidade para nenhuma máquina além dessa.

Uma gravação desse tipo fixa o modelo e as entradas, executa-os uma vez na máquina indicada e salva as saídas com um manifesto que nomeia o script. Os exemplos que usam uma gravação leem suas saídas salvas e não executam o modelo por conta própria. Para a comparação de velocidade, a gravação passa as mesmas mensagens pelas duas cópias, com o mesmo número de threads para cada uma, e salva o tempo de cada cópia como uma saída própria. A razão é calculada a partir dessas saídas salvas, e o leitor pode ver a máquina e o número de threads ao lado dela. Um leitor que queira a razão para a sua própria máquina deve executar a mesma gravação ali e informar a máquina junto com o resultado.

Regra prática: Leia uma razão de velocidade apenas de uma gravação que nomeie a máquina em que foi executada, e nunca a deduza dos bytes dos pesos. A razão acima descreve somente a máquina em que foi medida; portanto, execute a gravação na máquina em que você pretende servir o modelo antes de tomá-la como a sua velocidade.

Decida com o repasse em vista

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

A decisão é qual cópia o roteador serve. O capítulo 8 serve o adaptador float32 por padrão, e nada neste capítulo muda esse padrão. A contagem de predições alteradas pela int8 é 0/200 (0.0%), e a contagem de decisões de repasse alteradas pela int8 é 0/200. Uma contagem zero mantém a cópia como candidata. A economia que ela oferece é uma razão de bytes de pesos em algumas camadas. O registro não encontrou ganho de velocidade para a cópia int8 na sua máquina, e o livro não tem uma necessidade de memória medida que a favoreça. Por isso, uma cópia sem respostas alteradas nesta contagem e sem ganho medido não tem, por enquanto, nada que a recomende.

Manter float32 é uma escolha com custo. O adaptador ocupa mais bytes do que ocuparia a sua cópia int8, e em uma máquina pequena isso pode importar. O que o livro mostrou é mais restrito. Nesta amostra, a contagem de predições alteradas é 0/200 (0.0%), e somente uma contagem zero retira a mudança de predição como motivo para recusar a cópia. Os motivos restantes são aqueles que este capítulo não mediu, por isso não decidem contra o padrão. Se um registro na máquina de serviço mostrar um ganho de velocidade relevante, e uma necessidade de memória for medida, o caso para int8 passa a ser um caso de engenharia com um risco contado. Até lá, o adaptador float32 é aquele com menos questões em aberto.

O repasse é a parte a observar. O capítulo 5 escolheu o seu limiar de modo que a acurácia nas mensagens não repassadas atingisse a meta na divisão dev. Uma cópia cujas confianças se movem, ainda que pouco, pode repassar um conjunto diferente de mensagens, e então o limiar deixa de fazer o que foi escolhido para fazer. Por isso a contagem de predições alteradas é feita no limiar escolhido, e por isso a contagem de repasses fica ao lado dela. As mesmas medidas valem para qualquer adaptador quantizado, como um v2 retreinado.

Uma cópia quantizada falha em produção por meio de uma mudança que ninguém contou. Uma atualização de biblioteca pode mudar a aritmética, e uma mudança na mistura de mensagens pode levar algumas delas para o outro lado do limiar. Conte de novo na divisão dev sempre que as bibliotecas ou as mensagens mudarem, e antes de uma cópia quantizada servir a sua primeira mensagem.

Os mesmos passos se aplicam a uma cópia quantizada do próprio roteador de um leitor, e eles não exigem nada além das amostras e do limiar deste livro. Obtenha o limiar do manifesto do adaptador e verifique se o manifesto diz que ele foi escolhido na divisão dev. Quantize o backbone e mantenha a cabeça em float32, como faz o auxiliar. Pontue a amostra fixa com as duas cópias, e conte a acurácia, os repasses, a acurácia nas mensagens não repassadas e as predições alteradas, cada uma com o seu denominador. Leia as inversões em cada direção antes de ler os totais. Depois conte de novo na divisão dev no limiar escolhido, pois o limiar foi escolhido ali. Uma cópia que passa por estes passos ainda tem a sua velocidade e a sua memória medidas em um registro antes de substituir o adaptador float32.

Regra prática: Sirva o adaptador float32 por padrão. Considere a cópia int8 somente quando um registro na máquina de serviço indicar um ganho de velocidade, uma necessidade de memória medida a favorecê-la, e então conte as suas predições alteradas na divisão dev no limiar escolhido antes de ela servir qualquer mensagem.

Este capítulo, nesta edição

Edição 2026.11.9Exemplos aprovados em 20 de nov de 20262 de 2 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 7 de 10: Quantize o roteador e meça o que muda

  1. Uma chamada para quantizar as camadas lineares
  2. Contar as previsões que mudam
  3. Mantenha a cabeça de pontuação em float32
  4. Medir a velocidade em uma gravação
  5. Decida com o repasse em vista

Voltar ao topoTodos os capítulos