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"}, ondebefore_gbeafter_gbsão as duas pegadas eratioé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.
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.
Este navegador está bloqueando cookies para learn.floati.life, então as lições que você terminou aqui não podem abrir em ordem. Permita cookies para este site e recarregue.