Quantizando LLMs passo a passo: convertendo modelos FP16 em GGUF

Neste artigo, você aprenderá como a quantização reduz grandes modelos de linguagem e como converter um ponto de verificação FP16 em um arquivo GGUF eficiente que você pode compartilhar e executar localmente.

Os tópicos que cobriremos incluem:

• O que os tipos de precisão (FP32, FP16, 8 bits, 4 bits) significam para o tamanho e a velocidade do modelo
• Como usar huggingface_hub para buscar um modelo e autenticar
• Como converter para GGUF com llama.cpp e carregue o resultado para Abraçando o rosto

E lá vamos nós.

Quantizando LLMs passo a passo: convertendo modelos FP16 em GGUF
Imagem do autor

Introdução

Grandes modelos de linguagem como LLaMA, Mistral e Qwen possuem bilhões de parâmetros que exigem muita memória e poder de computação. Por exemplo, executar o LLaMA 7B com whole precisão pode exigir mais de 12 GB de VRAM, tornando-o impraticável para muitos usuários. Você pode verificar os detalhes neste Abraçando a discussão do rosto. Não se preocupe ainda com o significado de “precisão whole”; vamos decompô-lo em breve. A ideia principal é esta: esses modelos são grandes demais para rodar em {hardware} padrão sem ajuda. A quantização é essa ajuda.

A quantização permite que pesquisadores independentes e amadores executem grandes modelos em computadores pessoais, diminuindo o tamanho do modelo sem afetar gravemente o desempenho. Neste guia, exploraremos como a quantização funciona, o que significam os diferentes formatos de precisão e, em seguida, percorreremos a quantização de um modelo FP16 de amostra em um formato GGUF e o add para Abraçando o rosto.

O que é quantização?

Em um nível muito básico, a quantização consiste em diminuir o tamanho de um modelo sem quebrá-lo. Grandes modelos de linguagem são compostos de bilhões de valores numéricos chamados pesos. Esses números controlam a intensidade com que diferentes partes da rede influenciam umas às outras ao produzir uma saída. Por padrão, esses pesos são armazenados em formatos de alta precisão, como FP32 ou FP16, o que significa que cada número ocupa muita memória e, quando você tem bilhões deles, as coisas ficam fora de controle muito rapidamente. Pegue um único número como 2.31384. No FP32, apenas esse número usa 32 bits de memória. Agora think about armazenar bilhões de números assim. É por isso que um modelo 7B pode facilmente ocupar cerca de 28 GB no FP32 e cerca de 14 GB mesmo no FP16. Para a maioria dos laptops e GPUs, isso já é demais.

A quantização corrige isso dizendo: na verdade, não precisamos mais de tanta precisão. Em vez de armazenar 2.31384 exatamente, armazenamos algo próximo a ele usando menos bits. Talvez isso se torne 2.3 ou um valor inteiro próximo nos bastidores. O número é um pouco menos preciso, mas o modelo ainda se comporta da mesma forma na prática. As redes neurais podem tolerar esses pequenos erros porque o resultado ultimate depende de bilhões de cálculos, e não de um único número. Pequenas diferenças são compensadas, assim como a compactação de imagem reduz o tamanho do arquivo sem prejudicar a aparência da imagem. Mas a recompensa é enorme. Um modelo que precisa de 14 GB no FP16 geralmente pode rodar cerca de 7 GB com quantização de 8 bits, ou mesmo cerca de 4 GB com quantização de 4 bits. Isto é o que torna possível executar localmente grandes modelos de linguagem, em vez de depender de servidores caros.

Após a quantização, geralmente armazenamos o modelo em um formato de arquivo unificado. Um formato in style é GGUFcriado por Georgi Gerganov (autor de llama.cpp). GGUF é um formato de arquivo único que inclui pesos quantizados e metadados úteis. Ele é otimizado para carregamento rápido e inferência em CPUs ou outros tempos de execução leves. GGUF também suporta vários tipos de quantização (como Q4_0, Q8_0) e funciona bem em CPUs e GPUs de baixo custo. Esperamos que isso esclareça o conceito e a motivação por trás da quantização. Agora vamos escrever algum código.

Passo a passo: Quantizando um modelo para GGUF

1. Instalando dependências e registro no Hugging Face

Antes de baixar ou converter qualquer modelo, precisamos instalar os pacotes Python necessários e autenticar com Abraçando o rosto. Nós usaremos abraçandoface_hub, Transformadorese Peça de frase. Isso garante que possamos acessar modelos públicos ou fechados sem erros:

2. Baixando um modelo pré-treinado

Escolheremos um modelo pequeno FP16 de Abraçando o rosto. Aqui usamos o TinyLlama 1.1B, que é pequeno o suficiente para rodar no Colab, mas ainda dá uma boa demonstração. Usando Python, podemos baixá-lo com huggingface_hub:

Este comando salva os arquivos do modelo no model_folder diretório. Você pode substituir model_id com qualquer ID de modelo Hugging Face que você deseja quantizar. (Se necessário, você também pode usar AutoModel.from_pretrained com torch.float16 para carregá-lo primeiro, mas snapshot_download é simples para capturar os arquivos.)

3. Configurando as ferramentas de conversão

A seguir, clonamos o lhama.cpp repositório, que contém os scripts de conversão. Na Colab:

Isso lhe dá acesso a convert_hf_to_gguf.py. Os requisitos do Python garantem que você tenha todas as bibliotecas necessárias para executar o script.

4. Convertendo o modelo para GGUF com quantização

Agora, execute o script de conversão, especificando a pasta de entrada, o nome do arquivo de saída e o tipo de quantização. Nós usaremos q8_0 (quantização de 8 bits). Isso reduzirá aproximadamente pela metade o consumo de memória do modelo:

Aqui /content material/model_folder é onde baixamos o modelo, /content material/tinyllama-1.1b-chat.Q8_0.gguf é o arquivo GGUF de saída e o --outtype q8_0 sinalizador significa “quantizar para 8 bits”. O script carrega os pesos FP16, converte-os em valores de 8 bits e grava um único arquivo GGUF. Este arquivo agora é muito menor e está pronto para inferência com ferramentas compatíveis com GGUF.

Você pode verificar a saída:

Você deverá ver um arquivo com alguns GB de tamanho, reduzido em relação ao modelo FP16 authentic.

5. Carregando o modelo quantizado para Hugging Face

Finalmente, você pode publicar o modelo GGUF para que outros possam baixá-lo e usá-lo facilmente usando o huggingface_hub Biblioteca Python:

Isso cria um novo repositório (se não existir) e carrega seu arquivo GGUF quantizado. Qualquer um agora pode carregá-lo com llama.cpp, llama-cpp-pythonou Ollama. Você pode acessar o arquivo GGUF quantizado que criamos aqui.

Concluindo

Seguindo as etapas acima, você pode realizar qualquer Abraçando o rosto modelo, quantize-o (por exemplo, para 4 bits ou 8 bits) e salve-o como GGUF. Em seguida, envie-o para Hugging Face para compartilhar ou implantar. Isso torna mais fácil do que nunca compactar e usar grandes modelos de linguagem no {hardware} do dia a dia.