Como usar modelos linguísticos abertos?

Não é novidade que modelos linguísticos proprietários como o GPT da OpenAI e o Gemini do Google são possivelmente as primeiras alternativas quando se começa a trabalhar no desenvolvimento de aplicações baseadas em LLMs.

Embora esses modelos sejam capazes de responder acuradamente um número quase sem fim de questões de amplo domínio, esses modelos ainda contam com uma barreira significativa, em particular, para o usuário comum: o custo financeiro.

Utilizar esses modelos para realizar algumas pequenas chamadas podem não ser algo necessariamente custoso do ponto de vista monetário. No entanto, como geralmente o modelo de precificação desses modelos está associado a quantidade de chamadas realizadas a suas APIs, o custo tende a aumentar a medida que se aumenta a base de usuários de um sistema baseado em LLMs.

Não obstante, as versões mais recentes desses modelos —aquelas com melhor acurácia— tendem a ser as mais caras, o que sobrecarrega ainda mais o custo do pequeno usuário. Ademais, embora muitos desses modelos forneçam calculadoras que ajudem a dar uma previsibilidade no custo total do uso dos modelos, realizar esse tipo de conta não é uma tarefa fácil, uma vez que algumas variáveis não são conhecidas antecipadamente (como a quantidade de usuários acessando o sistema e os tipos de usos desses usuários).

Como forma de minimizar essa limitação financeira, algumas empresas, universidades e entidades públicas tem disponibilizado versões abertas de modelos linguísticos. Esses modelos, muitas vezes tem desempenho semelhante (ou até superior) a modelos linguísticos proprietários, torando-se assim soluções para aqueles interessados em construir aplicações baseadas em LLMs, porém diminuindo o custo de invocações de APIs privadas.

Nesse texto, vamos conhecer alguns desses modelos e abordar algumas formas de consumi-los.

---

Bootcamp LLM4Devs

📚 Você é dev e quer criar aplicações baseadas em LLMs?

O bootcamp #LLM4Devs é um evento que acontece uma vez por mês, em formato online de 4h de duração, focado em ajudar devs a construir sua primeira aplicação baseada em LLMs. É um evento super hands on!

Alguns dos tópicos abordados:

🟠 Entendendo sobre LLMs

🟣 Testando prompts e engenharia de prompts

🔵 Entendendo de embeddings

🟢 Comparando dados por similaridade

🟡 Conectando com um banco vetorial

E tem mais! Se inscrevendo no bootcamp, você ganha acesso a três cursos sobre LLMs.

Interessou? Clique aqui e saiba mais:

---

Onde posso encontrar esses modelos abertos?

Geralmente, o primeiro local para se procurar por modelos abertos é no HuggingFace. Se você ainda não conhece, dedique um tempo para criar uma conta, navegar e entender um pouco das principais funcionalidades desse site.

Em uma analogia simples, você pode entender que o HuggingFace é o GitHub para modelos. Ou seja, um repositório de código do GitHub é análogo a um repositório de modelo no HuggingFace.

Outro ponto interessante é que o HuggingFace hospeda não somente modelos linguísticos, mas também modelos de imagens para texto, de voz para texto, multimodais, etc. Há centenas de milhares de modelos que podem ser facilmente acessados. Umas dessas formas de acessá-los é através da biblioteca transformers, desenvolvida pelo próprio HuggingFace.

No entanto, nesse texto, faremos uso do LangChain para acessar os modelos disponíveis no HuggingFace. Usaremos o LangChain, pois, embora a biblioteca transformers seja mais robusta, ao meu ver, o LangChain fornece uma interface mais intuitiva e amigável (dado um menor número de configurações necessárias) para acessar os modelos do HuggingFace.

Quais modelos posso utilizar?

Como mencionamos, o HunggingFace tem centenas de milhares de modelos hospedados. E como no GitHub, muitos desses modelos tem baixa qualidade ou não são mais mantidos. Dessa forma, é importante fazer um trabalho de pesquisa e curadoria antes de utilizar algum modelo menos conhecido em um ambiente mais produtivo.

Para facilitar, sugiro aqui alguns dos modelos linguísticos que poderiam ser utilizados inicialmente:

• mistralai/Mistral-7B-Instruct-v0.3: O Mistral-7B-Instruct-v0.3 é um modelo de linguagem grande de 7 bilhões de parâmetros desenvolvido pela Mistral AI. Este modelo é ajustado especificamente para seguir instruções, tornando-o adequado para tarefas que requerem compreensão contextual e respostas precisas em linguagem natural.

• microsoft/Phi-3-mini-4k-instruct: O Phi-3-mini-4k-instruct da Microsoft é um modelo compacto com um foco em eficiência e desempenho. Com otimização para tarefas de instrução, ele é projetado para processar e responder a consultas complexas, mantendo um equilíbrio entre qualidade de resposta e consumo de recursos computacionais. Já escrevemos sobre ele aqui na newsletter.

• meta-llama/Meta-Llama-3-8B-Instruct: O Meta-Llama-3-8B-Instruct é um modelo robusto de 8 bilhões de parâmetros criado pela Meta. Este modelo tem uma arquitetura avança e permite seguir instruções em diversas tarefas de processamento de linguagem natural. Também já escrevemos sobre ele aqui na newsletter.

Uso pela API de inferência do HuggingFace

Como mencionado, vamos utilizar o LangChain para acessar esses modelos. Podemos começar instalando o LangChain:

pip install langchain

Uma vez instalado, vamos usar a API HuggingFaceEndpoint, que fornece acesso ao endpoint de inferência do modelo no HuggingFace.

Esse endpoint torna simples o acesso aos modelos, uma vez que não se faz necessário baixar e configura-los localmente. Todavia, é importante notar que nem todos os modelos estão disponíveis através desse endpoint.

Para que seja possível acessar o endpoint, é necessário criar uma conta e, em seguida, um token no seu perfil no HuggingFace.

Com esse token em mãos, podemos fazer nossa primeira requisição a um modelo aberto, hospedado (e executando) no HuggingFace.

from langchain.llms import HuggingFaceHub
import os

os.environ["HUGGINGFACEHUB_API_TOKEN"] = TOKEN

llm = HuggingFaceEndpoint(repo_id="meta-llama/Meta-Llama-3-70B-Instruct", task="text-generation")

prompt = """
        <|begin_of_text|>
        <|start_header_id|>system<|end_header_id|>
        Você é um assistente de código especializado em culinária.
        <|eot_id|>
        <|start_header_id|>user<|end_header_id|>
        Me faça uma lasanha vegana.
        <|eot_id|>
        <|start_header_id|>assistant<|end_header_id|>
        """

llm.invoke(prompt)

Este código importa a biblioteca `HuggingFaceHub` do Langchain e a biblioteca `os` para manipulação de variáveis de ambiente. Ele configura a variável de ambiente HUGGINGFACEHUB_API_TOKEN com um token de acesso necessário para autenticar e acessar os recursos do HuggingFace Hub. Em seguida, um objeto chamado llm é criado usando a classe HuggingFaceEndpoint, especificando o repositório do modelo meta-llama/Meta-Llama-3-70B-Instruct e definindo a tarefa como "text-generation", que indica que o modelo será usado para gerar texto.

Após a configuração do modelo, o código define um prompt, que é um texto de entrada formatado para orientar a geração de texto do modelo. Note que o prompt é ligeiramente diferente, pois conta com uma série de tokens especiais que ajudam o modelo a responder de maneira mais assertiva. Cada modelo aberto tende a ter seus próprios tokens especiais, e conhecer esses tokens é fundamental para uma boa comunicação com o modelo.

Finalmente, o código chama o método `invoke` do objeto LLM, passando o prompt para gerar uma resposta baseada nas instruções fornecidas. Este processo permite que o modelo produza uma resposta à solicitação do usuário.

Uso do modelo localmente

Podemos também baixar e rodar um modelo localmente. Par isso, utilizaremos a biblitoeca LLamaCPP.

O LLamaCPP permite o uso de modelos empacotados como arquivos de formato gguf, que rodam em ambientes somente CPU e mistos CPU/GPU.

Para usar o LlamaCPP, precisamos de modelos cujo caminho do modelo termine com gguf. Para encontra-los, você pode fazer buscas no próprio HunggingFace pelo nome do seu modelo, mais a extensão gguf.

from langchain_community.llms import LlamaCpp

drive.mount('/content/drive')

llm = LlamaCpp(
            model_path="Phi-3-mini-4k-instruct.gguf",
            temperature=0.75,
            top_p=1,
            verbose=True,
            n_ctx=4096
            )

prompt = """<|user|>
How to explain Internet for a medieval knight?<|end|>
<|assistant|>"""

response = llm.invoke(prompt)
print(response)

No exemplo acima, usamos o modelo phi-3, logo o prompt deve utilizar os tokens seguidos por esse modelo. Note que é possível definir ainda alguns parâmetros durante a instanciação do objeto llm. Considere navegar pela documentação oficial para conhecer mais sobre esses parâmetros.

Conclusão

Concluindo, enquanto modelos linguísticos proprietários, como o GPT da OpenAI e o Gemini do Google, são frequentemente as primeiras escolhas para desenvolvedores iniciando em aplicações baseadas em LLMs, seu uso pode se tornar financeiramente inviável à medida que a base de usuários cresce. A precificação baseada no volume de chamadas às suas APIs pode tornar os custos proibitivos, especialmente para pequenas empresas ou desenvolvedores individuais. Além disso, as versões mais precisas desses modelos tendem a ser as mais caras, aumentando ainda mais o desafio financeiro.

Felizmente, a crescente disponibilidade de modelos abertos oferece uma alternativa viável e econômica. Plataformas como o HuggingFace disponibilizam uma vasta gama de modelos de alta qualidade que podem ser utilizados gratuitamente ou a um custo significativamente menor. Neste texto, exploramos como utilizar alguns desses modelos através do LangChain, uma biblioteca que facilita o acesso e a integração desses modelos em suas aplicações. Com isso, desenvolvedores podem criar soluções robustas e eficientes, minimizando os custos associados ao uso de modelos linguísticos proprietários.