Executando Llama v2 em CPU

Hoje vamos ver como rodar um LLM de código aberto em CPU, sem a necessidade de GPU, com uma interface de bate-papo usando ChainLit e o framework Langchain.

Mas, primeiro, o que são LLMs?

Large Language Models, ou modelos de linguagem de grande porte, são uma classe avançada de inteligência artificial (IA) projetada para compreender e gerar texto em larga escala.

Treinados em enormes conjuntos de dados por meio de técnicas de aprendizado profundo, esses modelos adquirem uma compreensão contextual da linguagem, permitindo a realização de tarefas complexas, como completar frases, traduzir idiomas e responder a perguntas.

Exemplos notáveis incluem os modelos GPT (Generative Pre-trained Transformer) da empresa OpenAI, como GPT-3.5 e GPT-4, e modelos baseados em BERT da Google. Esses modelos têm aplicações em diversos setores, como assistentes virtuais e processamento de linguagem natural em larga escala.

Executando em CPUs

Por serem extremamente robustos e contarem com bilhões de parâmetros, a execução desses modelos de grande escala geralmente demanda GPUs (Unidades de Processamento Gráfico).

Esses modelos realizam operações complexas e intensivas em termos de cálculos matriciais, e as GPUs, otimizadas para esse tipo de processamento paralelo, oferecem desempenho significativamente superior em comparação com as CPUs convencionais.

Neste artigo, vamos ver um exemplo de um LLM rodando em CPU, no caso, no meu notebook pessoal.

Obtendo o modelo

Vamos precisar do modelo no formato ggml, contendo dados codificados em binário dispostos de uma certa maneira.

Ggml é uma biblioteca de tensores para aprendizado de máquina que permite a execução mais rápida de modelos grandes, como LLMs, em hardware normal. Esta biblioteca é escrita em C e possui diversos recursos que possibilitam seu desempenho até mesmo em CPUs.

Eu utilizei o modelo Llama v2, da Meta, que eu encontrei aqui.

Vamos ver agora como carregar o modelo e fazer a inferência.

Etapa 1: Lhama cpp

LLaMa.cpp é uma biblioteca de código aberto desenvolvido por Georgi Gerganov com mais de 390 colaboradores, que implementa de forma eficiente a arquitetura LLaMa da Meta em C/C++ .

Foi desenvolvida especialmente para ser executada em CPUs, com menos complexidade mas mantendo integração com outros ambientes de programação.

Vamos instalar o Llama cpp usando pip.

pip install llama-cpp-python

Agora, podemos carregar nosso modelo ggml na biblioteca.

from llama_cpp import Llama
llm = Llama(model_path="models/llama-2–7b-chat.ggmlv3.q4_0.bin")

Etapa 2: CTransformers

CTransformer é uma biblioteca em python para trabalhar com modelos Transformers implementados em C/C++ usando a biblioteca GGML. Fornece uma interface semelhante à da famosa biblioteca Transformers da Hugging Face.

Para instalar, execute o seguinte comando.

pip install ctransformers

Vamos carregar o modelo da mesma forma que faríamos com a biblioteca Transformers. Não esqueça de enviar o tipo de modelo, no nosso caso, llama.

from ctransformers import AutoModelForCausalLM
llm = AutoModelForCausalLM.from_pretrained(
    'models/llama-2–7b-chat.ggmlv3.q4_0.bin',
     model_type='llama')

Etapa 3: Langchain

Vamos criar agora um aplicativo bem simples que acessa o modelo e gera uma resposta em linguagem natural, usando o framework LangChain.

LangChain é um framework de código aberto que simplifica a conexão de modelos de IA com diversas fontes de dados, permitindo soluções de Processamento de Linguagem Natural (PLN) totalmente adaptadas.

Esse framework facilita o desenvolvimento de aplicativos alimentados por modelos de linguagem.

Instalando o langchain:

pip install langchain

Agora, vamos criar um arquivo Python app.py.

Primeiro vamos importar as bibliotecas para carregar o nosso modelo e para definir o prompt usando PromptTemplate.

Depois, combinamos o nosso llm e o prompt usando o LLMChain.

Na função load, carregamos o modelo utilizando CTransformers, depois definimos o prompt e, em seguida, definimos a LLMChain.

Executamos a nossa cadeia LLMChain com a mensagem de entrada e printamos o resultado.

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.llms import CTransformers

template = """Question: {question}
Answer:"""

prompt = PromptTemplate(template=template, input_variables=["question"])

llm = CTransformers(model="models/llama-2–7b-chat.ggmlv3.q4_0.bin", model_type='llama')
llm_chain = LLMChain(prompt=prompt, llm=llm)

response = llm_chain.run("Por que o céu é azul?")

print(response)

Para executar:

python app.py

O resultado deve variar para cada execução. Como o modelo foi treinado com uma base de dados multi-língue, o resultado da pergunta é fornecido em português.

OBS: Nem sempre o resultado fica legal, você pode tentar ajustar o prompt para melhores resultados.

Etapa 4: Chainlit

Vamos criar uma interface de chatbot com ao Chainlit.

Chainlit é uma biblioteca Python assíncrona de código aberto que torna ajuda na construção de aplicativos semelhantes ao Chat GPT com sua própria lógica e dados de negócios.

Vamos instalar:

pip install chainlit

O código final ficou assim:

from langchain.llms import CTransformers
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

import chainlit as cl

@cl.on_chat_start
def load():
  template = """Responda a essa pergunta do usuário: {question}.
             """
  prompt = PromptTemplate(template=template, input_variables=["question"])

  llm = CTransformers(model="models/llama-2–7b-chat.ggmlv3.q4_0.bin",
  model_type='llama')

  llm_chain = LLMChain(prompt=prompt, llm=llm, verbose=True)

  cl.user_session.set("llm_chain", llm_chain)

@cl.on_message
async def main(message: str):
  llm_chain = cl.user_session.get("llm_chain")
  res = await cl.make_async(llm_chain)(message,
                                    callbacks=[cl.LangchainCallbackHandler()]
                                   )
  await cl.Message(res['text']).send()
  return llm_chain

Agora basta executar esse comando no terminal:

chainlit run app.py -w

OBS: Se você quiser personalizar a página inicial da aplicação, pode alterar o arquivo markdown chamado “chainlit.md”.

Etapa 5: Resultado

Aqui eu gravei um vídeo mostrando como ficou o resultado final. Note que o vídeo foi cortado em cerca de 1 min, enquanto o modelo processava 😅

Se gostou deste post, siga-me no Medium e no LinkedIn.

Obrigada pela leitura!