Execute o Llama sem GPU! LLM Quantizado com LLMWare e Dragão Quantizado

Introdução

À medida que as tecnologias LLM ganham maior adoção e o ecossistema começa a amadurecer, as organizações estão começando a reconhecer os limites e os custos do uso de tecnologias LLM. Muitas empresas, originalmente entusiasmadas com a aplicação de tecnologias LLM , abandonaram iniciativas centralizadas, prosseguindo, em vez disso, uma estratégia de encorajar esforços descentralizados para incorporar serviços como ChatGPT e Claude nos seus fluxos de trabalho.

Existem várias razões para este fenômeno. A falta de experiência em LLM, os requisitos de MLOps e a dependência de infraestrutura especializada de GPU são barreiras para a implementação de iniciativas de IA em grande escala. Destes, porém, o problema mais espinhoso é a dependência de GPUs.

Neste artigo, discutiremos as dificuldades específicas apresentadas pela dependência da GPU, exploraremos uma solução potencial e veremos um exemplo interessante de uma das empresas pioneiras que trabalham nesta área.

Disponibilidade de GPU como limitações para LLMs

A maioria dos modelos de alto desempenho e disponíveis publicamente, como GPT-4, Llama 2 e Claude, contam com infraestrutura de GPU altamente especializada. O GPT-4, um dos maiores modelos disponíveis comercialmente, funciona em um cluster de 8 GPUs A100. O modelo 70B do Llama 2, que é bem menor, ainda requer pelo menos uma GPU A40 para rodar a uma velocidade razoável.

Este nível de exigência de GPU praticamente exclui a possibilidade de executar esses modelos localmente - uma GPU A100, supondo que você encontre um vendedor, custa perto de US$ 25.000. Depois de obter as GPUs, você precisará de habilidades especializadas para configurar e manter os servidores. Muito poucas organizações estariam dispostas a incorrer em tais despesas para experimentar tecnologias LLM.

Para resolver esse problema, diversas startups e provedores de nuvem desenvolveram extensas ofertas de PaaS. Alguns serviços como o Replicate, que usei em artigos e projetos anteriores, permitem que os usuários aluguem servidores GPU e paguem pelo tempo de computação utilizado. Outros provedores, como OpenAI e Anthropic, oferecem seus modelos como uma API por token, abstraindo ainda mais as complexidades de infraestrutura. No entanto, estes serviços exigem que os dados sejam enviados para uma rede externa, o que torna a utilização destes serviços um fracasso para organizações preocupadas com a privacidade. Além disso, muitos desses serviços sofrem escassez durante picos de demanda, à medida que o uso da GPU ultrapassa a disponibilidade, tornando-os opções não confiáveis para cargas de trabalho críticas de produção.

Além disso, o tempo de GPU, não importa como seja cobrado, é caro para grandes tarefas de computação – afinal, as empresas que possuem e operam essas GPUs precisam de um retorno sobre seu investimento. Embora esses custos sejam quase insignificantes para casos de uso experimentais, os casos de uso comercial geralmente exigem a incorporação de grandes contextos, ajustes finos ou exemplos múltiplos. Estes custos representam uma barreira significativa à adoção, especialmente para organizações com grandes conjuntos de dados ou que não dispõem dos recursos financeiros de grandes empresas dos EUA.

Em um artigo anterior, exploramos a compactação de parâmetros como uma estratégia para reduzir a dependência de GPUs. No artigo de hoje, exploraremos outra técnica interessante chamada quantização.

Antes de mergulharmos na exploração, entretanto, talvez queiramos aprender um pouco sobre quantização primeiro.

Quantização (leitura opcional)

Nesta seção, examinaremos brevemente os fundamentos da quantização. No entanto, se você está simplesmente procurando uma maneira de executar LLMs poderosos localmente em seu computador, sinta-se à vontade para pular esta seção por enquanto e voltar mais tarde. LLMWare, a empresa cuja tecnologia usaremos hoje, construiu algumas ferramentas incríveis que permitem que você comece com modelos quantizados sem ter que entrar nas implementações C/C++ por trás de tudo.

O que é quantização?

A quantização é uma técnica que busca reduzir os requisitos computacionais e de memória para executar um LLM usando tipos numéricos de menor precisão. Muitos modelos populares de código aberto, como Llama, Falcon e Alpaca, usam PyTorch como estrutura subjacente. Por padrão, os modelos PyTorch usam pontos flutuantes de 32 bits, o que significa que um único parâmetro ocupa 32 “bits” na memória da GPU. A quantização visa substituir esses parâmetros por pontos flutuantes de 16 bits, inteiros de 8 bits ou mesmo inteiros de 4 bits. A quantização bem-sucedida leva a melhorias dramáticas na velocidade computacional e reduções no uso de memória, o que significa que modelos grandes podem ser executados em GPUs de baixo custo, chips gráficos incorporados ou até mesmo CPUs. Essa ideia já existe há algum tempo - o próprio PyTorch adicionou suporte para pontos flutuantes de 16 bits e compilações de modelos à medida que a tecnologia amadureceu, mas o progresso tem sido lento devido às decisões iniciais de design na estrutura PyTorch.

A quantização degrada o desempenho?

Neste ponto, é natural perguntar: isso não degradaria gravemente a precisão do modelo? A resposta curta é sim, mas somente se você fizer isso de maneira descuidada. Toda otimização traz vantagens inerentes, mas com algumas técnicas especializadas, os pesquisadores conseguiram extrair um desempenho incrivelmente estável de modelos altamente quantizados. Embora não entremos em detalhes técnicos extremos, vamos examinar os traços gerais das estratégias mais comuns usadas atualmente. Se quiser saber mais, você pode saber mais sobre isso em um guia do HuggingFace.

Quantização Calibrada

Durante o processo de quantização, um conjunto de dados de calibração é executado no modelo. O valor de cada parâmetro é registrado e o intervalo é usado para determinar como os parâmetros são quantizados. Supondo que o conjunto de dados de calibração seja representativo das entradas que o modelo encontrará, isso resulta em maior precisão do modelo resultante.

Consciente de quantização

Enquanto a Quantização Calibrada ocorre após o treinamento, o Treinamento Consciente da Quantização tenta otimizar o modelo durante o treinamento. Enquanto o modelo está em treinamento, as ativações são submetidas a uma “falsa quantização”, simulando erros que provavelmente serão introduzidos pelo processo de quantização. O modelo é então capaz de se adaptar aos erros, resultando num modelo mais robusto que pode adaptar-se especificamente às potenciais distorções.

Lhama.cpp e GGUF

Embora a quantização e as otimizações do PyTorch tenham sido bloqueadas há muito tempo pelo design da estrutura, duas tecnologias recentes de código aberto romperam essas barreiras e tornaram as tecnologias de quantização muito mais acessíveis ao público em geral. Vamos abordá-los brevemente abaixo.

Lhama.cpp

Llama.cpp foi um projeto de Georgi Gerganov para portar o modelo Llama para C/C++. Isso eliminou a complexidade introduzida pelo PyTorch e a implementação nativa permitiu que a quantização fosse implementada diretamente. Portanto, o modelo resultante pode ser executado com quantização inteira de até 4 bits, permitindo que modelos Llama com alta contagem de parâmetros sejam executados sem uma GPU especializada.

Desde então, o projeto foi estendido pela comunidade para incluir uma lista de modelos de código aberto, incluindo modelos populares como Falcon e Mistral.

GGUF

GGUF é o formato de arquivo do Llama.cpp para armazenar e transferir informações do modelo. Os modelos quantizados são armazenados neste formato para que possam ser carregados e executados pelo usuário final. GGUF é o formato sucessor do GGML e visa melhorar o GGML, fornecendo mais extensibilidade, compatibilidade com versões anteriores e estabilidade, ao mesmo tempo que permite um desenvolvimento rápido.

O desenvolvimento de um formato de arquivo universal abriu a porta para a comunidade de código aberto estender o Llama.cpp para otimizar outros modelos, e inovadores como TheBloke e LLMWare têm trabalhado nos últimos meses para miniaturizar modelos populares de código aberto.

Modelo de dragão quantizado da LLMWare

No exemplo de hoje, usaremos bibliotecas de código aberto e modelos quantizados fornecidos pela LLMWare, que fornece ferramentas convenientes para construir rapidamente fluxos de trabalho RAG especializados.

Quem é o LLMWare?

A LLMWare, uma empresa de IA generativa especializada nos setores jurídico e financeiro, tem estado ativamente envolvida na comunidade de quantização. Como já escrevi antes, o seu foco em setores preocupados com a privacidade torna-os candidatos naturais para experimentar e inovar em tecnologias de miniaturização.

Anteriormente, escrevi sobre seus modelos BLING otimizados para RAG, que extraem um desempenho incrível de 1 a 3 bilhões de modelos de parâmetros para tarefas especializadas, como revisão de contratos e análise financeira. Embora a maioria dos modelos de código aberto com tais contagens de parâmetros tendam a ser úteis apenas para problemas de brinquedos, o LLMWare é capaz de gerar desempenho pronto para produção a partir desses modelos, treinando-os para tarefas específicas. Esses modelos miniaturizados podem então funcionar sem uma GPU externa, permitindo maior privacidade e escalabilidade.

O que é dragão?

Dragon é uma coleção de LLMs que podem ser considerados versões mais poderosas de seus primos BLING. A intenção original do Dragon era treinar um modelo de parâmetros mais altos usando as mesmas técnicas de ajuste fino de instruções, fornecendo uma opção para usuários que precisam de mais desempenho e têm acesso a GPUs de baixo custo.

A contagem de parâmetros adicionada resultou em modelos mais poderosos que poderiam aproveitar janelas de contexto maiores e gerar resultados mais complexos, mas exigiam que o usuário tivesse hardware mais especializado, como um laptop integrado à GPU ou um contêiner de computação em nuvem com uma GPU anexada. No entanto, ainda representavam uma melhoria em relação aos modelos extremamente grandes, o que exigiria a espera pelo acesso às escassas GPUs A40 ou A100.

Dragão Quantizado, o Melhor dos Dois Mundos

Diante do exposto, é fácil ver por que a quantização deu um impulso significativo ao conjunto de ferramentas de IA do LLMWare. Com a quantização, um usuário poderia executar modelos Dragon-tier no mesmo ambiente que os modelos BLING, permitindo análises muito mais poderosas em computadores comuns.

Ao longo do último mês, a LLMWare publicou versões quantizadas de vários modelos Dragon. Hoje, avaliaremos o modelo Dragon da LLMWare construído sobre o Llama com um problema RAG de análise jurídica e compará-lo-emos com um modelo BLING semelhante. Os interessados também podem explorar outros modelos - um modelo baseado em Mistral e um modelo baseado em Yi estão disponíveis na LLMWare no momento da redação deste artigo. Além disso, o LLMWare facilitou a execução de inferências em modelos Llama.cpp com suas fortes integrações com a biblioteca ctransformers, que permite que os modelos gguf sejam trocados perfeitamente com modelos baseados em PyTorch.

Usaremos um Macbook Air com chip M1 para este experimento, o que significa que usaremos apenas hardware amplamente disponível para este exercício.

Testando Dragão Quantizado

Vale lembrar que no meu artigo anterior construímos uma aplicação RAG focada em busca de legislação. Usamos a pesquisa vetorial para pesquisar rapidamente várias legislações importantes, encontramos seções relevantes para nossa pergunta sobre interesse de parceria em zona de oportunidade qualificada e analisamos a pergunta por meio de um modelo BLING. No artigo de hoje, faremos a mesma pergunta por meio do modelo Dragon quantizado do LLMWare e determinaremos se ele tem desempenho melhor do que os modelos BLING.

Para focar na comparação de modelos e reduzir a quantidade de conhecimento prévio necessário, faremos grande parte da análise de PDF e pesquisa vetorial manualmente. Isso tem o benefício adicional de tornar o problema artificialmente mais difícil para o modelo - a pesquisa de incorporação padrão do LLMWare divide o material de origem em cerca de 1.000 tokens, mas lidar com a análise manualmente nos permite aumentar o contexto para cerca de 3.000 tokens. Isso nos ajudará a demonstrar claramente a diferença entre os modelos Dragon e BLING.

No entanto, você deverá ser capaz de integrar-se facilmente ao restante do ecossistema do LLMWare se quiser aproveitar suas ferramentas seguindo as etapas de configuração do meu último artigo sobre LLMWare. Na verdade, se você simplesmente substituir o nome dos modelos BLING pelo modelo Dragon quantizado deste artigo, tudo deverá funcionar perfeitamente.

Sem mais delongas, vamos começar!

Primeiro, vamos importar as dependências necessárias:

 import sklearn import sklearn.metrics # for cosine similarity from llmware.prompts import Prompt import time import os from openai import OpenAI from PyPDF2 import PdfReader client = OpenAI() # the library now loads the key automatically as an environment variable.

Agora podemos carregar o PDF. No exemplo anterior, carregamos várias legislações importantes, mas por hoje vamos nos concentrar apenas na versão em PDF da Lei de Reduções de Impostos e Empregos de 2017.

 reader = PdfReader([path to PDF of tax cuts and jobs act])

Agora podemos gerar os embeddings para cada página:

 embeddings = [] for pg in reader.pages: text = pg.extract_text() embeddings.append(client.embeddings.create( input=text, model="text-embedding-ada-002" ).data[0].embedding)

Vamos também gerar os embeddings para a pergunta que faremos:

 question = 'What is a qualified opportunity zone partnership interest?' q_embed = client.embeddings.create( input=question, model="text-embedding-ada-002" ).data[0].embedding

Com a incorporação em mãos, podemos realizar uma pesquisa vetorial. Como nosso espaço de busca é pequeno, podemos fazer isso manualmente.

 cos_sim = [(idx, sklearn.metrics.pairwise.cosine_similarity([e], [q_embed])[0][0]) for idx, e in enumerate(embeddings)]

Agora podemos pegar a página mais relevante (que é o índice 132 ou a página 133 se você quiser verificar os resultados):

 most_relevant = sorted(cos_sim, key=lambda x: x[1], reverse=True)[0][0]

E com isso, chegamos ao passo mais crucial. Iremos instanciar um objeto LLMWare Prompter com o modelo quantizado Llama Dragon. A classe Prompter é fundamental aqui porque ela cuida da engenharia do prompt para nós e garante que nosso prompt seja consistente com a estrutura dos dados de treinamento do Dragon. A classe prompt também lida automaticamente com a ligação llamacpp, para que você possa usar o modelo Dragon quantizado exatamente como outros modelos.

 model_name = "llmware/dragon-llama-7b-gguf" prompter = Prompt().load_model(model_name) response = prompter.prompt_main(question, context='\n\n'.join([reader.pages[132].extract_text()]), prompt_name="default_with_context", temperature=0.3)

Espere um pouco e você verá o retorno da chamada de função. Agora imprima os resultados:

 print(response['llm_response'])

E você deverá ver algo como o seguinte:

 • A capital or profits interest acquired by the qualified opportunity fund after December 31, 2017, from the partnership solely in exchange for cash; •As of the time such interest was acquired, the partnership was a qualified opportunity zone business (or, in the case of a new partnership, it was being organized for purposes of being a qualified opportunity zone business); •During substantially all of the qualified opportunity fund's holding period for such interest, the partnership qualified as a qualified opportunity zone business.

Esta é uma resposta muito boa!

Para efeito de comparação, vamos ver o desempenho de um modelo BLING no mesmo problema. Um dos problemas que podemos esperar é que o grande tamanho do contexto pode “sobrecarregar” um modelo com parâmetros mais baixos e levar a uma resposta menos informativa. Em meus experimentos anteriores, a lhama cisalhada 2.7b teve um dos melhores desempenhos para esse problema, então decidi usá-la como representante dos modelos BLING.

 model_name_2 = "llmware/bling-sheared-llama-2.7b-0.1" prompter2 = Prompt().load_model(model_name_2) response = prompter2.prompt_main(question, context='\n\n'.join([reader.pages[132].extract_text()]), prompt_name="default_with_context", temperature=0.3)

Após algum processamento, você deverá ver algo assim.

 A qualified opportunity zone partnership interest is a capital or profits interest in a domestic partnership if such interest is acquired by the qualified opportunity fund after December 31, 2017, from the partnership solely in exchange for cash.

A resposta ainda é boa, mas perde alguns detalhes capturados pelo modelo Dragon. Especificamente, a resposta ignora o requisito do período de detenção e o novo caso de negócio. Isto está de acordo com nossas expectativas sobre a dificuldade dos modelos de parâmetros mais baixos em processar contextos maiores. Os leitores interessados podem estender este experimento usando modelos de parâmetros ainda mais baixos ou aumentando o tamanho do contexto fornecido. Você deverá ver o efeito se tornar cada vez mais pronunciado, após o que o modelo dará uma resposta curta e distorcida.

A partir deste experimento, deve ficar claro que os modelos Dragon quantizados são capazes de superar os modelos de parâmetros mais baixos para os casos de uso pretendidos, sem comprometer visivelmente a precisão do modelo.

E com isso, usamos um modelo quantizado para resolver um caso de uso do mundo real e aprendemos sobre suas características de desempenho no processo!

Conclusão

Hoje, exploramos o emocionante campo da quantização LLM e vimos como empresas como a LLMWare estão aproveitando esses desenvolvimentos para aprimorar seus modelos de linguagem especializados. Como argumentei antes, a miniaturização representa um dos caminhos mais promissores para a adoção generalizada de tecnologias de IA. Ao combinar especialização, ajuste fino e quantização, os inovadores no espaço de IA podem criar modelos escaláveis e de alto desempenho que resolvem problemas do mundo real.

Você pode encontrar a estrutura RAG do LLMWare no Github e seus modelos DRAGON e BLING no repositório Hugging Face do LLMWare.

A propósito, estou trabalhando em um projeto interessante que busca usar a IA da linguagem e a miniaturização para revolucionar a educação no mundo em desenvolvimento. Estamos trabalhando com ativistas e educadores incríveis em todo o mundo e trabalhando para reduzir a exclusão digital global. Se você quiser saber mais sobre meu projeto ou simplesmente quiser falar sobre desenvolvimentos interessantes no espaço LLM, não hesite em entrar em contato comigo no Github ou no LinkedIn .