Conteúdo do curso Lição 204 de 250 · Ajuste Fino, Conceitualmente
Ajuste Fino, Conceitualmente

Pegada de Memória: 4-bit vs 16-bit

Aqui está a aritmética que decide se um modelo cabe no seu hardware, e por que modelos "quantizados" estão em todo lugar. Os pesos de um modelo são apenas números, e cada número ocupa alguns bytes dependendo da sua precisão. A pegada é simples:

bytes = params * bits_per_param / 8
# (8 bits per byte)

Treinamento e inferência de precisão total geralmente usam 16-bit floats (2 bytes cada). Para rodar um modelo em um laptop ou celular você quantize ele: armazene cada weight em menos bits. 4-bit quantization usa um quarto dos bytes, porque 4 bits é um quarto de 16 bits. Mesmo número de parâmetros, um quarto da memória.

Trabalhe um modelo de 7 bilhões de parâmetros:

16-bit: 7e9 * 16 / 8 = 1.4e10 bytes  ~= 13.04 GiB
 4-bit: 7e9 *  4 / 8 = 3.5e9  bytes  ~=  3.26 GiB   (exactly 1/4)

Essa é a diferença entre um modelo que precisa de uma GPU grande e um que roda em um notebook. É exatamente por isso que um assistente no dispositivo (como o que alimenta o tutor de IA deste curso) envia um modelo de 4 bits: o custo de qualidade é pequeno, o ganho de memória e largura de banda é enorme. Isso também é por que o ajuste fino eficiente em parâmetros (LoRA) é atraente, você apenas armazena e envia alguns pesos de adaptador pequenos sobre uma base congelada, possivelmente quantizada.

O que a fórmula simples deixa de fora. Ela conta apenas os pesos, então trate isso como um piso. Formatos reais de 4 bits também armazenam uma escala para cada pequeno grupo de pesos, o que os leva a cerca de 4,5 a 5 bits por peso (um modelo 7B está mais próximo de 4 GiB do que de 3,26). Rodar o modelo precisa de espaço para o KV cache, que cresce com o comprimento do contexto. E training precisa de muito mais do que os pesos: o fine-tuning completo com o otimizador Adam mantém gradientes e dois estados do otimizador por peso, cerca de 16 bytes por parâmetro em mixed precision, então aproximadamente 100 GiB para um modelo 7B antes das ativações. Esse abismo é o real motivo pelo qual LoRA e o fine-tuning quantizado existem.

Nós relatamos a pegada em GiB (gibibytes), dividindo bytes por 1024 ** 3. Mantenha como um float exato, não arredonde, para que as relações abaixo se mantenham precisamente.

Construa duas funções.

  • model_memory(params, bits_per_param) -> a pegada em GiB como float: params * bits_per_param / 8 / (1024 ** 3).
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, onde before_gb e after_gb são as duas pegadas e ratio é from_bits / to_bits (quantas vezes menor o modelo quantizado é).

A matemática é real e avaliável; o treinamento por GPU que ela permite não é algo que este sandbox pode executar. Pressione Run para imprimir a pegada de um modelo de 7B em algumas precisões.

Sua vez

Escreva model_memory(params, bits_per_param) retornando a pegada em GiB como um float (params * bits_per_param / 8 / (1024 ** 3)), e quantization_savings(params, from_bits, to_bits) retornando {"before_gb", "after_gb", "ratio"} onde as duas pegadas vêm de model_memory e ratio é from_bits / to_bits. Não arredonde; mantenha floats exatos para que 4-bit resulte em exatamente um quarto de 16-bit.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.