Acelerando a Inferência do Transformer com ctransformers

Name

Lynn Mikami

Published on 30/04/2024

Introdução

Nos últimos anos, os modelos de linguagem baseados em Transformers revolucionaram o processamento de linguagem natural, possibilitando avanços em tarefas como geração de linguagem, resposta a perguntas e classificação de texto. No entanto, esses modelos costumam ser extremamente grandes, com bilhões ou até trilhões de parâmetros, o que os torna computacionalmente caros de executar, especialmente em CPUs.

ctransformers é uma biblioteca Python que tem como objetivo tornar a implantação desses grandes modelos de linguagem mais eficiente e acessível. Ele fornece ligações Python para modelos Transformers implementados em código C/C++ otimizado, aproveitando técnicas como quantização e o uso de instruções AVX para acelerar significativamente a inferência em hardware de CPU.

Com ctransformers, é possível carregar e executar modelos como GPT-2, GPT-J, GPT-NeoX, Llama e outros, com apenas algumas linhas de código Python. A biblioteca oferece uma interface simples e unificada para vários modelos, integração com o Hugging Face Hub e o framework LangChain, e acesso a APIs de baixo nível para um controle mais refinado.

O que é ctransformers?

Por trás dos panos, ctransformers utiliza a biblioteca GGML, que é uma biblioteca de tensores focada na execução de modelos de ML em CPUs. GGML fornece implementações eficientes de operações comuns, como multiplicação de matrizes, especialmente para tipos de dados quantizados. Ao combinar o GGML com kernels otimizados específicos para cada modelo, o ctransformers consegue obter um desempenho impressionante.

Uma das aplicações mais empolgantes do ctransformers é a capacidade de executar modelos grandes de código aberto, como o Llama 2, em hardware de consumo. Isso abre possibilidades para a implantação econômica e ecológica de grandes modelos de linguagem, tornando-os mais acessíveis a uma variedade maior de usuários e aplicações.

Neste artigo, abordaremos os detalhes técnicos do ctransformers, explorando suas características, desempenho e API. Passaremos por exemplos de código que mostram como carregar modelos, gerar texto e integrar com o LangChain. Por fim, discutiremos as implicações e o potencial da inferência eficiente na CPU para o futuro de PLN e IA.

Algumas características importantes do ctransformers:

• Interface unificada para carregar e executar vários modelos
• Suporte para executar modelos do Hugging Face Hub
• Integração com o framework LangChain
• Acesso à API C de baixo nível para um controle mais refinado
• Inferência otimizada na CPU usando instruções AVX

Instalação do ctransformers

Para instalar o ctransformers, basta usar o pip:

pip install ctransformers

Para suporte a GPU, instale com a variável de ambiente CT_CUBLAS definida:

CT_CUBLAS=1 pip install ctransformers --no-binary ctransformers

Uso básico do ctransformers

A classe principal para carregar e executar modelos é AutoModelForCausalLM. Veja como carregar um modelo:

from ctransformers import AutoModelForCausalLM
 
# Carregar de um arquivo local
llm = AutoModelForCausalLM.from_pretrained('path/to/ggml-model.bin', model_type='gpt2')
 
# Carregar do Hugging Face Hub
llm = AutoModelForCausalLM.from_pretrained('marella/gpt-2-ggml')

O argumento model_type especifica o tipo de modelo que está sendo carregado. As opções incluem gpt2, gptj, gpt_neox, dolly-v2, starcoder, etc.

Para gerar texto, basta chamar o modelo:

output = llm("IA vai")
print(output)

Para mais controle, há uma interface de geração:

tokens = llm.tokenize("IA vai")
 
for token in llm.generate(tokens):
    print(llm.detokenize(token))

Integração do LangChain com ctransformers

ctransformers fornece um invólucro para usar modelos com o framework LangChain:

from ctransformers.langchain import CTransformers
 
llm = CTransformers(model='marella/gpt-2-ggml')
 
# Usar com primitivas do LangChain
from langchain import PromptTemplate, LLMChain
 
template = """Pergunta: {pergunta}
Resposta:"""
 
prompt = PromptTemplate(template=template, input_variables=['pergunta'])
llm_chain = LLMChain(prompt=prompt, llm=llm)
 
pergunta = "O que é IA?"
print(llm_chain.run(pergunta))

Executando modelos Llama

ctransformers pode executar os modelos Llama de código aberto no formato GGML. Aqui está um exemplo usando o modelo Llama 2:

from ctransformers import AutoModelForCausalLM
 
id_modelo = "TheBloke/Llama-2-7B-GGML"
 
config = {
    'max_new_tokens': 256,
    'repetition_penalty': 1.1,
    'temperature': 0.1
}
 
llm = AutoModelForCausalLM.from_pretrained(
    id_modelo,
    model_type="llama",
    config=config
)
 
prompt = "Escreva um poema para me ajudar a lembrar os primeiros 10 elementos da tabela periódica"
output = llm(prompt)
print(output)

Isso carrega o modelo Llama 2 com 7B de parâmetros convertido para o formato GGML e gera um poema a partir do prompt fornecido.

O dicionário config permite especificar vários parâmetros de geração, como o número máximo de tokens, penalidade de repetição, temperatura, etc.

Conclusão

ctransformers oferece uma maneira fácil e eficiente de executar grandes modelos de linguagem em CPUs usando implementações otimizadas em C/C++. Com uma API Python simples, integração com o Hugging Face Hub e o LangChain, e suporte a uma variedade de modelos, é uma ferramenta poderosa para construir aplicações baseadas em Transformers. A capacidade de executar modelos como o Llama 2 na CPU com desempenho razoável abre novas possibilidades para implantação econômica e ecologicamente correta de grandes modelos de linguagem. À medida que o ecossistema em torno de modelos de Transformer de código aberto continua a crescer, bibliotecas como ctransformers desempenharão um papel importante em torná-los acessíveis e práticos de usar.