De quantos bits uma IA precisa?

Você decide baixar um modelo de IA com oito bilhões de parâmetros.

Tem um computador, algumas tarefas em mente e a crença otimista de que baixar alguma coisa é uma atividade com começo e fim.

Então chega à página do modelo.

Há uma versão FP16. Uma de oito bits. Uma de seis. Uma de cinco. Várias de quatro. E algo chamado Q4_K_M, que parece o código de uma peça de reposição que seria bom fotografar antes de ir à loja de ferragens.

Todas são versões do mesmo modelo treinado. Contêm essencialmente o mesmo conjunto de parâmetros aprendidos. Mas suas necessidades de memória são muito diferentes.

Seu primeiro impulso é compreensível: escolher a maior. Certamente ela contém mais daquilo que torna o modelo útil.

Sua placa de vídeo, com seus oito gigabytes de VRAM, também gostaria de participar dessa decisão.

A diferença entre as versões vem, em grande parte, da quantização de pesos: representar os pesos numéricos aprendidos pelo modelo com menos bits, usando aproximações escolhidas com cuidado.

Reduzir a precisão desses números pode diminuir drasticamente a memória que ocupam.

Parece uma pechincha, imediatamente seguida de um motivo para desconfiar.

O que se perdeu? O modelo ainda vai entender seus documentos? Ainda poderá ajudar com código? Um modelo de quatro bits sabe que Boston fica em Massachusetts, ou removeram a geografia para abrir espaço para a gramática?

Não existe um departamento decidindo quais cidades sobrevivem à compressão.

O que muda é a fidelidade com que os números aprendidos são preservados. Esses números influenciam os cálculos, então alterá-los pode afetar a maneira como o modelo usa o que aprendeu.

Mas preservar cada bit disponível tem um custo. E, para o trabalho que você realmente quer fazer, a precisão adicional pode ou não justificar mais memória de vídeo.

Essa é a pergunta por trás de todo aquele menu de downloads:

De quanta precisão numérica do modelo original eu preciso — e o que posso fazer com a VRAM que economizo?

O modelo já foi à escola

Antes de comparar quatro bits com dezesseis, vale separar aprender de armazenar o que foi aprendido.

Durante o treinamento, um modelo ajusta enormes conjuntos de valores numéricos chamados pesos. Juntos, eles influenciam como reconhece padrões, segue instruções e produz respostas.

Quando você baixa um modelo pré-treinado comum, esse treinamento já aconteceu.

A versão de quatro bits não estudou quatro anos enquanto a de dezesseis estudava dezesseis. São representações numéricas diferentes do mesmo modelo treinado.

A educação veio primeiro. A quantização muda a forma de preservar seus resultados.

Imagine que o treinamento tenha produzido este peso:

Para entender a precisão numérica, compare estas representações:

Elas descrevem aproximadamente o mesmo valor, mas preservam quantidades diferentes de detalhes.

A primeira mantém todos os dígitos do nosso exemplo. A segunda arredonda o valor para duas casas decimais. A terceira é uma aproximação mais grosseira.

Essa é a ideia cotidiana por trás da precisão numérica: o quanto o número armazenado preserva o valor que queríamos guardar.

Ao representar os mesmos pesos com menos bits, geralmente aceitamos aproximações mais grosseiras em troca de menor consumo de memória.

O exemplo decimal é uma ilustração. Computadores usam formatos binários, então quatro bits não significam quatro casas decimais. Os formatos distribuem seus bits de maneiras diferentes, e a quantização real é mais sofisticada do que simplesmente cortar os últimos dígitos.

Mas a troca fundamental é real.

Mais bits dão mais espaço para preservar fielmente os números aprendidos. Menos bits economizam memória, mas descartam parte do detalhe numérico.

Como as capacidades do modelo dependem desses números, perder detalhes pode afetar sua capacidade de usar o que aprendeu.

Às vezes é difícil perceber a diferença. Às vezes ela importa.

A tarefa é descobrir qual caso se aplica ao seu trabalho.

Sua placa de vídeo tem um apartamento menor

Seu SSD pode ter espaço para várias versões de um modelo. Um disco de dois terabytes comporta uma bela coleção.

Sua placa de vídeo é uma proprietária menos generosa.

Nos próximos exemplos, suponha que você queira executar o modelo inteiramente em uma GPU dedicada. Os pesos precisam caber na memória de vídeo, ou VRAM, dessa placa, com espaço adicional para processar seus pedidos.

É esse orçamento de memória que nos interessa aqui.

Um bit tem dois estados possíveis: zero ou um. Vários bits juntos formam mais combinações:

Quatro bits oferecem dezesseis combinações. Seis oferecem sessenta e quatro. Oito oferecem 256.

Um formato numérico usa essas combinações para representar valores. Mais possibilidades de representação custam mais memória de verdade.

Oito bits formam um byte. Dezesseis bits formam dois bytes.

Considere um modelo simplificado com exatamente oito bilhões de pesos. Com dezesseis bits por peso, os dados brutos dos pesos exigem aproximadamente:

Isso representa cerca de 16 GB de dados de pesos para acomodar na VRAM, antes de acrescentar memória de trabalho.

Uma placa de vídeo de 8 GB não pode fornecer esse espaço. Ela não fica mais flexível quando você explica que o modelo tem ótimas avaliações.

Com quatro bits por peso, a conta idealizada fica assim:

Formatos reais acrescentam informações auxiliares e podem manter alguns componentes com maior precisão. Mas a diferença básica é considerável.

O mesmo conjunto de pesos aprendidos pode ocupar muito menos VRAM.

Essas equações usam gigabytes decimais. O software pode mostrar GiB, uma unidade um pouco maior. Mais importante: elas descrevem apenas os dados dos pesos, não toda a memória necessária para executar o modelo.

Portanto, quatro bits não significa “precisa de uma placa de vídeo de quatro gigabytes”.

A relação útil é que, para o mesmo modelo, menos bits por peso geralmente deixam mais memória de vídeo disponível para todo o resto.

Os oito bilhões de parâmetros continuam presentes. Só tiveram o auxílio-moradia revisto.

O que quatro bits realmente armazenam

Vamos voltar ao nosso peso imaginário:

Como um código de quatro bits pode representar um número desses?

Um código de quatro bits identifica dezesseis possibilidades. Em um exemplo propositalmente simples, poderíamos fazer esses códigos representarem dezesseis valores separados por intervalos de 0.1:

Nosso valor original não está na lista. O mais próximo disponível é 0.4.

O sistema pode guardar o código compacto 4, junto com uma informação compartilhada dizendo que cada passo representa 0.1:

O tamanho do passo é chamado de escala.

A diferença entre o peso original e sua aproximação é:

Essa diferença é o erro de quantização.

Este é um exemplo didático, não a receita literal do Q4_K_M. Pesos reais podem ser negativos, e os métodos práticos escolhem suas representações com mais cuidado.

Muitos métodos dividem os pesos em grupos, cada um com uma escala apropriada ou outras informações de interpretação. Assim, o mesmo código de quatro bits pode representar valores aproximados diferentes em grupos diferentes. O modelo inteiro não fica restrito a uma única lista universal de dezesseis números. O guia de quantização da Hugging Face explica esses mapeamentos.

Pense em uma régua cujas marcações pudessem ser espaçadas conforme as medidas à sua frente.

Um grupo de valores muito próximos se beneficia de marcações finas. Valores espalhados por uma faixa maior precisam de outra distribuição.

O número de marcações continua limitado. Você pode posicioná-las com inteligência, mas não criar mais por puro entusiasmo.

Computadores continuam decepcionantemente imunes ao entusiasmo.

Como o arredondamento chega à resposta

Nosso peso original era 0.3726. Sua aproximação é 0.4.

Suponha que o valor numérico de entrada seja 2. Usando o peso original:

Usando a aproximação:

A operação é a mesma. O resultado mudou.

Um modelo faz quantidades enormes de cálculos envolvendo seus pesos. Os resultados alimentam cálculos seguintes ao longo de suas camadas.

Quando você pergunta sobre Boston, seu texto é dividido em tokens — palavras ou pedaços de palavras — e convertido em representações numéricas. Elas mudam conforme atravessam o modelo.

Esses valores numéricos que vão mudando são chamados de ativações. Os pesos aprendidos ajudam a determinar como eles são transformados.

Uma operação comum pode ser escrita de forma compacta:

Aqui, $X$ contém as informações numéricas de entrada, $W$ os pesos aprendidos e $Y$ o resultado transformado.

Por trás dessa pequena equação pode haver uma quantidade enorme de multiplicações e somas. Enquanto o modelo parece conversar tranquilamente sobre a arquitetura de Boston, o hardware faz aritmética com uma intensidade que preocuparia um contador humano.

Mudar os pesos pode, portanto, mudar os cálculos — e, por fim, a resposta.

Mas os efeitos não se resumem a somar todos os erros de arredondamento. Algumas diferenças se compensam. Outras têm pouca importância prática. Outras atingem partes mais importantes da computação.

Bons métodos de quantização tentam preservar comportamentos úteis apesar das aproximações.

Pesquisadores também consideram como os pesos são realmente usados. AWQ, ou Activation-aware Weight Quantization, usa informações sobre as ativações para proteger canais importantes por meio de ajustes de escala. A pesquisa de AWQ descreve essa abordagem.

A precisão não importa igualmente em toda parte.

Pelo visto, até dentro de uma rede neural alguns números negociaram contratos melhores.

Boston sobrevive. O roteiro exige mais atenção.

Suponha que você pergunte a várias versões do mesmo modelo capaz:

Boston fica em Massachusetts?

Todas podem responder corretamente.

Boston sobrevive à quantização de quatro bits. Massachusetts continua onde o deixamos. O rio Charles não foi transferido para Ohio.

Agora tente um pedido mais exigente:

Estou hospedado perto de Back Bay. Planeje um dia com um museu, uma livraria independente, um jantar com frutos do mar e duas horas livres à tarde. Não tenho carro, quero evitar caminhadas longas e preciso chegar à South Station antes do meu trem à noite.

O modelo precisa coordenar vários requisitos. Também precisa de informações confiáveis sobre horários e transporte.

Há mais oportunidades para as fraquezas aparecerem.

Uma boa versão de quatro bits pode resolver a tarefa muito bem. Uma versão de maior precisão pode preservar melhor a capacidade do modelo original de coordenar esses requisitos. Nenhum dos resultados decorre automaticamente da quantidade de bits.

O mesmo pode acontecer ao comparar propostas com exclusões complicadas, modificar código sem prejudicar comportamentos relacionados ou resolver um problema com várias etapas dependentes.

Essas tarefas dão motivos para cuidar da preservação do comportamento aprendido pelo modelo.

Mas precisão numérica e exatidão dos fatos são coisas diferentes.

Um modelo pode preservar seus pesos com muita precisão e ainda não ter a informação necessária para responder. Mais bits não fornecem uma tabela de horários atualizada que ele nunca recebeu.

Dezesseis bits não convencem um restaurante fechado a reabrir.

E uma resposta mais detalhada não é necessariamente mais correta. Um modelo pode errar em poucas palavras ou oferecer uma explicação impressionantemente organizada do próprio erro.

Autoconfiança, infelizmente, ocupa pouquíssimo espaço.

Então por que manter a versão de dezesseis bits?

Se uma versão de quatro bits pode responder corretamente, por que alguém usaria a maior?

Porque “funciona igualmente bem nesta tarefa” não é o mesmo que “preserva todo o comportamento do modelo original em todas as tarefas”.

Um checkpoint de dezesseis bits costuma servir como versão de alta precisão da qual são feitas variantes menores. Mantê-lo evita a aproximação adicional introduzida pela quantização para poucos bits.

Isso importa quando preservar o comportamento original é mais importante do que reduzir o consumo de memória.

Talvez seu trabalho revele uma fraqueza da versão quantizada. Talvez você esteja avaliando o modelo em uma ampla variedade de tarefas. Talvez tenha VRAM suficiente para pesos de alta precisão, contexto e espaço de trabalho, e não haja muito motivo para aceitar mais perda numérica.

Maior precisão não garante uma resposta correta. Ela elimina uma fonte adicional de alterações.

A versão original também é valiosa como ponto de partida para outros trabalhos: criar novas quantizações, comparar métodos ou preparar o modelo para treinamento adicional.

Depois que um detalhe numérico é descartado, simplesmente converter a representação menor de volta a um formato maior não o recupera.

Escrever 0.400000 no lugar de 0.4 não traz 0.3726 de volta. Só dá à aproximação um terno mais comprido.

Treinamento adicional merece uma distinção à parte. Instalar um modelo de dezesseis bits não faz com que ele continue aprendendo automaticamente durante uma conversa comum. Treinar exige um processo que atualize parâmetros.

Representações de maior precisão são úteis nesse trabalho, mas abordagens de poucos bits também existem. QLoRA, por exemplo, mantém um modelo-base de quatro bits congelado enquanto treina componentes adicionais chamados adaptadores. O artigo de QLoRA explica esse método.

Portanto, modelos de dezesseis bits têm funções práticas. Preservam um ponto de partida mais fiel e podem ajudar a evitar perdas relevantes para uma carga de trabalho específica.

O que não oferecem é uma promoção automática de “conhece Boston” para “defendeu uma tese sobre Massachusetts”.

E por que você talvez não precise de dezesseis bits

A maioria das pessoas que baixa um modelo local está tentando fazer alguma coisa.

Quer organizar notas, entender um documento, redigir um e-mail, comparar produtos, trabalhar com código ou explorar um assunto.

Normalmente não está tentando preservar cada detalhe numérico por si só.

Se uma boa versão de quatro, cinco ou seis bits executa bem essas tarefas, a memória adicional de uma versão mais precisa pode trazer pouca melhoria prática para aquele uso.

Essa é a diferença entre uma diferença mensurável e uma diferença que muda sua experiência.

Ambas importam, mas respondem a perguntas diferentes.

Imagine duas versões produzindo resumos igualmente úteis dos documentos que você realmente lê. Uma ocupa muito mais VRAM. A outra deixa espaço para documentos mais longos e mais histórico de conversa.

Escolher a representação menor pode ser uma decisão técnica sensata.

Você não precisa reservar uma suíte presidencial para cada casa decimal.

Ao mesmo tempo, não existe uma regra universal dizendo que a quantização de quatro bits perde só dois por cento de qualidade, ou mantém uma porcentagem fixa de inteligência.

Uma diferença publicada pertence a um modelo, método de quantização, avaliação e configuração específicos. Outra tarefa pode mostrar uma diferença menor, maior ou praticamente sem importância.

Pesquisas como GPTQ demonstraram quantização de três e quatro bits com pequenas perdas nas avaliações relatadas, inclusive em modelos muito grandes. Isso mostra que a troca pode funcionar extremamente bem. Não é uma garantia para todo modelo e toda tarefa. O artigo de GPTQ descreve os resultados.

A pergunta útil, portanto, é pessoal e verificável:

Esta versão menor ainda faz meu trabalho bem o suficiente — e a VRAM economizada vale mais para mim do que a diferença restante?

Para muitas tarefas do dia a dia, a resposta pode ser sim.

Em algumas tarefas exigentes, maior precisão pode merecer seu espaço.

Nenhuma das decisões exige entrar para uma facção na internet.

Quatro bits e um MacBook

A ideia de reduzir a precisão de redes neurais existia muito antes de modelos de linguagem locais virarem um assunto popular.

O que mudou foi a escala da oportunidade.

À medida que os modelos cresciam para bilhões de parâmetros, reduzir os bits por peso podia transformar uma necessidade de memória impraticável em algo que um computador pessoal comportava.

Em março de 2023, essa possibilidade ganhou uma forma especialmente concreta com o llama.cpp, de Georgi Gerganov.

Em 11 de março, o desenvolvedor Simon Willison documentou a execução do LLaMA de sete bilhões de parâmetros em seu MacBook Pro M2. O computador tinha 64 GB de memória; o arquivo do modelo ocupava cerca de 4 GB após a quantização de quatro bits. Seu relato em primeira mão continua disponível.

Um modelo de linguagem treinado respondia a perguntas localmente em um notebook.

Para quem estava acostumado a ouvir sobre centros de dados e orçamentos enormes de treinamento, aquilo mudava a perspectiva. Era possível experimentar um modelo capaz no computador pessoal sem também comprar refrigeração industrial e contratar o responsável pela manutenção do prédio.

A quantização não tornou gratuito o treinamento original. Ajudou a tornar o resultado treinado prático de usar.

Os modelos eram caros de educar e surpreendentemente tolerantes com o estado de suas anotações.

E, quando a precisão muito baixa se mostrou útil, os pesquisadores continuaram explorando até onde podiam chegar.

Programadores às vezes chegam à filosofia subtraindo um repetidamente.

Q4_K_M e outras formas de letras miúdas

Você volta à lista de downloads.

Agora entende os quatro bits. Infelizmente, Q4_K_M ainda parece conter várias opiniões adicionais.

O rótulo identifica uma receita específica de quantização. O quatro aponta para a representação de pesos com poucos bits, mas formatos práticos precisam de mais do que os códigos compactos.

Eles também podem armazenar escalas, outras informações de interpretação e alguns componentes do modelo com maior precisão.

Assim, um formato de “quatro bits” pode usar, em média, mais de quatro bits efetivos por peso.

Dois arquivos com o rótulo de quatro bits podem diferir em tamanho e comportamento. A receita importa, não apenas o número em destaque.

Um modelo de quatro bits se parece com uma instalação de software “de cinco minutos” em um único aspecto: o número é útil, mas convém manter boas relações com as notas de rodapé.

Você também pode encontrar GGUF, o formato do arquivo que carrega o modelo e seus metadados. É um tipo de rótulo diferente de Q4_K_M, que descreve uma receita de quantização.

E FP16 e BF16 são ambos formatos de ponto flutuante de dezesseis bits, mas distribuem seus bits de maneiras diferentes entre faixa numérica e precisão.

Dá para entender a escolha prática sem decorar cada organização interna.

O importante é que a quantidade de bits não identifica completamente o formato, e seu ambiente de execução — o software que roda o modelo — precisa oferecer suporte à versão escolhida.

As siglas podem continuar sendo apenas conhecidas. Não há obrigação de convidá-las para a família.

Pesos menores também precisam se mover

Surge uma pergunta razoável: se os pesos são armazenados como códigos compactos, o computador precisa expandir o modelo inteiro para uma cópia enorme de alta precisão antes de usá-lo?

Uma implementação adequada não precisa manter permanentemente essa cópia expandida.

Rotinas otimizadas podem ler blocos compactos de pesos e interpretar seus valores aproximados como parte do cálculo. Algumas operações ainda podem usar maior precisão.

Isso não recupera a informação perdida na quantização. Multiplicar 0.4 com muita precisão não revela que o peso original era 0.3726.

Manter os pesos compactos também reduz a quantidade de dados que precisa circular pelo sistema de memória.

Esse movimento leva tempo. A largura de banda da memória descreve a velocidade de transferência dos dados. Quando movimentá-los é um gargalo importante, representações menores podem fazer o processador esperar menos.

Mas decodificar representações compactas pode exigir trabalho adicional. O desempenho depende do hardware, do ambiente de execução, do formato e da tarefa.

Um formato que acelera a geração de respostas pode se comportar de outra maneira ao processar um pedido longo.

Portanto, “quatro bits é sempre mais rápido” não é uma regra confiável. Nem “o menor download vai produzir a resposta mais rápida”.

Nas mesmas condições, o arquivo menor geralmente será baixado antes. É reconfortante quando pelo menos uma parte da conversa se comporta direito.

Para a velocidade real de inferência, medir na configuração pretendida continua sendo valioso.

Os pesos couberam. Agora o modelo quer trabalhar.

É aqui que a VRAM economizada se torna especialmente útil.

Os pesos são apenas parte da memória necessária para executar um modelo. Ele também precisa de espaço para cálculos temporários e buffers do ambiente de execução.

Muitos modelos mantêm um cache KV, que armazena informações intermediárias associadas aos tokens já processados. Reutilizá-las evita repetir parte dos mesmos cálculos ao gerar o próximo token. A Hugging Face explica como esse cache funciona.

Suas instruções, documentos enviados, histórico de conversa e a resposta em elaboração fazem parte do contexto do modelo.

Um contexto mais longo normalmente exige mais memória de cache, embora a relação exata dependa da arquitetura e do ambiente de execução. Alguns projetos limitam ou alteram esse crescimento.

Os pesos não aumentam porque você colou mais um capítulo. A demanda adicional vem do processamento do contexto maior.

Há outra distinção fácil de perder: pesos de quatro bits não significam automaticamente um cache KV de quatro bits. A precisão dos pesos e a do cache são escolhas separadas.

Para um plano simples de memória GPU, podemos pensar assim:

A margem de trabalho cobre, por exemplo, buffers de cálculo e espaço reservado para outros usos da GPU.

Vamos colocar números nessa ideia.

A documentação do llama.cpp apresenta um arquivo Q4_K_M para Llama 3.1 8B com aproximadamente 4.58 GiB, e um Q8_0 com cerca de 7.95 GiB. Esses tamanhos publicados de arquivos de pesos são um ponto de partida para uma estimativa; não medem toda a VRAM consumida durante a execução. Fonte: comparação de quantizações do llama.cpp.

Suponha que, neste exemplo de planejamento, usemos esses valores para os pesos e reservemos 1 GiB para o cache da conversa e mais 1 GiB para espaço de trabalho e outros usos.

Com a representação menor dos pesos:

Com a maior:

Em uma placa de vídeo com orçamento de VRAM de 8 GiB, são situações muito diferentes.

As margens de um gigabyte são hipóteses deste exemplo. As necessidades reais dependem do ambiente de execução e da carga de trabalho.

Mas agora fica visível por que a conta completa importa.

A representação maior dos pesos quase cabe sozinha. O trabalho planejado não.

A representação menor deixa espaço para trabalhar.

Por isso, a representação mais fiel não é automaticamente a configuração mais útil em um computador específico.

Um modelo que consome quase toda a VRAM disponível se parece com um sofá magnífico ocupando quase a sala inteira. O sofá cabe. Agora você janta em pé.

A quantização pode abrir espaço para o resto da noite.

A RAM do sistema pode ajudar?

Sim, quando o ambiente de execução e o modelo oferecem suporte a essa distribuição.

Um modelo pode rodar na CPU usando RAM do sistema. Pode rodar em uma GPU usando VRAM. Ou o ambiente de execução pode dividir o trabalho, permitindo que parte use RAM e outra parte use a GPU. Projetos como llama.cpp oferecem execução em CPU e operação mista CPU–GPU.

Em sistemas de memória unificada, o processador e o hardware gráfico compartilham um conjunto de memória, o que muda novamente a distribuição.

Essas abordagens podem tornar utilizáveis modelos que não caberiam inteiros na VRAM de uma placa dedicada. O desempenho depende da organização.

Porém, 8 GB de VRAM dedicada mais 32 GB de RAM do sistema não viram 40 GB de memória GPU igualmente rápida.

O ambiente de execução precisa distribuir dados e cálculos adequadamente. Transferir dados e fazer parte do trabalho na CPU pode afetar a velocidade.

Seu sistema operacional e os outros aplicativos também precisam de RAM. Eles não concordaram em se mudar só porque você se interessou por inteligência artificial.

Da mesma forma, o banco de dados inteiro de um agente não vai automaticamente para a VRAM. O banco funciona em seu próprio ambiente; os trechos recuperados e enviados ao modelo passam a fazer parte do contexto.

Os cálculos de GPU acima pressupõem que todos os pesos estão na placa de vídeo. Alterar essa distribuição muda o plano de memória.

De volta ao botão de download

A esta altura, a lista de arquivos deve parecer menos uma prova de admissão.

A versão de dezesseis bits preserva uma representação de alta precisão dos pesos treinados. A quantização de oito bits geralmente faz uma aproximação menos agressiva do que alternativas de menos bits. Formatos de cinco e seis oferecem opções intermediárias. Os de quatro podem tornar um modelo capaz prático com muito menos VRAM.

Em todas essas escolhas, a pergunta de fundo é a mesma: de quanta fidelidade numérica sua tarefa se beneficia?

Para classificações curtas, um contexto modesto e uma boa versão de poucos bits podem bastar. Para um assistente de programação que examina vários arquivos, ou um agente que carrega instruções e histórico de tarefas, a memória de trabalho pode ser uma parte considerável da necessidade.

Algumas tarefas revelam uma vantagem útil da precisão maior. Outras produzem resultados igualmente satisfatórios com menos.

Um modelo que cabe com uma saudação curta ainda pode ter dificuldades com o documento que você realmente queria que ele lesse. Um modelo de alta precisão sem espaço para esse documento preservou lindamente seus números, mas perdeu o objetivo da tarefa.

É por isso que os testes devem se parecer com seu trabalho.

Se quer ajuda para comparar pedidos de impressão, forneça pedidos representativos com respostas conhecidas. Se quer ajuda com código, use código que consiga avaliar. Se quer um roteiro por Boston, confira se ele respeita os limites de caminhada e se os horários vieram de uma fonte confiável.

Localizar Boston em Massachusetts é um começo promissor. Não qualifica o modelo para organizar seu fim de semana inteiro.

Ao comparar quantizações, mantenha o modelo de origem e a tarefa o mais constantes possível. Assim fica mais fácil avaliar o efeito da mudança de representação.

Esse também é o objetivo de explorar orçamentos de memória no Green Zone: ver como os pesos escolhidos, o contexto, a distribuição da memória e a capacidade disponível podem funcionar juntos.

Uma estimativa ajuda a escolher uma configuração plausível. Experimentá-la em tarefas representativas mostra se ela é útil para você.

Talvez descubra que quatro bits preservam capacidades suficientes para tudo de que precisa. Talvez prefira cinco ou seis. Ou talvez seu trabalho se beneficie de maior precisão, com VRAM suficiente para usá-la com folga.

Não há prêmio por gastar cada byte disponível apenas com os pesos.

Também não há obrigação de abrir mão de precisão quando ela traz um benefício útil.

O modelo já aprendeu. Sua decisão é com que fidelidade preservar esse aprendizado e, ao mesmo tempo, deixar espaço suficiente para trabalhar no seu computador.

Você volta à página de download. Os rótulos não mudaram, mas agora sabe lê-los.

Escolhe uma versão adequada ao seu ambiente de execução, à memória de trabalho disponível e à tarefa que realmente tem em mente.

Boston continua em Massachusetts. Seu computador tem espaço para trabalhar. Finalmente, você pode fechar a discussão de comparações.

Alguém acabou de publicar uma argumentação detalhada sobre quantização de dois bits.

Você não precisa abrir.