Introdução

A geração de texto emergiu como uma capacidade revolucionária, transformando como as máquinas interpretam e produzem texto semelhante ao humano. Este aumento de popularidade levou ao desenvolvimento de inúmeras ferramentas projetadas para simplificar e aprimorar o processo de trabalho com LLMs.

A rápida expansão dos Grandes Modelos de Linguagem, com novas versões surgindo quase semanalmente, impulsionou um aumento concomitante nas opções de hospedagem para suportar essa tecnologia. Entre as muitas ferramentas disponíveis, o Text Generation Inference (TGI) da Hugging Face se destaca, permitindo executar um LLM como serviço em nossas máquinas locais.

Este guia abordará por que o TGI da Hugging Face é uma inovação significativa e como você pode usá-lo para desenvolver modelos de IA sofisticados capazes de gerar texto cada vez mais indistinguível da escrita humana.

O que é Hugging Face Text Generation Inference?

O Hugging Face Text Generation Inference (TGI) é um framework escrito em Rust e Python para implantar e servir Grandes Modelos de Linguagem. É um kit de ferramentas pronto para produção, projetado para esse fim.

A Hugging Face desenvolve e distribui o TGI sob a licença HFOILv1.0, permitindo uso comercial desde que funcione como uma ferramenta auxiliar dentro do produto ou serviço, e não como a funcionalidade principal. Os principais desafios que resolve são:

Principais Recursos do Hugging Face Text Generation Inference (TGI)

1. Geração de Texto de Alto Desempenho
— O TGI emprega técnicas como Paralelismo de Tensor, que distribui modelos grandes entre múltiplas GPUs, e agrupamento dinâmico (dynamic batching), que agrupa prompts em tempo real dentro do servidor, para otimizar o desempenho de LLMs open-source populares, incluindo StarCoder, BLOOM, GPT-NeoX, Llama e T5.

2. Uso Eficiente de Recursos
— O TGI utiliza agrupamento contínuo (continuous batching), código otimizado e Paralelismo de Tensor para lidar com múltiplas requisições simultaneamente, minimizando o uso de recursos.

3. Flexibilidade e Segurança
— O TGI suporta vários recursos de segurança, como marca d’água (watermarking), warping de logits (modificação dos logits de tokens específicos pela infusão de um valor de viés) e sequências de parada (stop sequences) para garantir o uso responsável e controlado do LLM.

A Hugging Face otimizou a arquitetura de alguns LLMs para executar mais rapidamente com o TGI, incluindo modelos populares como LLaMA, Falcon7B e Mistral. Uma lista completa de modelos suportados pode ser encontrada na documentação.

Por que usar o Hugging Face TGI?

A Hugging Face tornou-se a plataforma de referência para desenvolver IA com capacidades de linguagem natural. Ela hospeda uma infinidade de modelos open-source líderes, tornando-se uma potência para a inovação em PLN. Tradicionalmente, esses modelos eram grandes demais para serem executados localmente, exigindo dependência de serviços baseados em nuvem.

No entanto, avanços recentes em técnicas de quantização como QLoRa e GPTQ tornaram alguns LLMs gerenciáveis em dispositivos cotidianos, incluindo computadores locais.

O Hugging Face TGI é especificamente projetado para permitir LLMs como serviço em máquinas locais. Essa abordagem aborda o desafio de inicializar um LLM, mantendo o modelo pronto em segundo plano para respostas rápidas, evitando longas esperas para cada prompt. Imagine ter um endpoint com uma coleção dos principais modelos de linguagem prontos para gerar texto sob demanda.

O que se destaca no TGI é sua implementação direta. Ele suporta várias arquiteturas de modelo simplificadas, tornando a implantação rápida e fácil.

Além disso, o TGI já está alimentando vários projetos ativos. Alguns exemplos incluem:

- Hugging Chat, uma interface open-source para modelos de acesso aberto.
- OpenAssistant, uma iniciativa comunitária open-source para treinar LLMs.
- nat.dev, uma plataforma para explorar e comparar LLMs.

No entanto, há uma limitação notável: o TGI ainda não é compatível com Macs com GPU baseada em ARM, incluindo a série M1 e posteriores.

Configurando o Hugging Face TGI

Primeiro, configure o endpoint do Hugging Face TGI.

Para instalar e executar o Hugging Face TGI localmente, comece instalando o Rust. Depois, configure um ambiente virtual Python com Python versão 3.9 ou superior, por exemplo, usando conda:

#Installing Rust
curl --proto ‘=https’ --tlsv1.2 -sSf https://sh.rustup.rs | sh

#Creating a python virtual environment
conda create -n text-generation-inference python=3.9
conda activate text-generation-inference

Além disso, é essencial instalar o Protoc. A Hugging Face recomenda usar a versão 21.12 para melhor compatibilidade. Observe que você precisará de privilégios sudo para realizar esta instalação.

PROTOC_ZIP=protoc-21.12-linux-x86_64.zip
curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v21.12/$PROTOC\_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local ‘include/*’
rm -f $PROTOC_ZIP

Primeiro, descreverei o processo de instalação a partir do zero, que pode não ser direto. Se você encontrar problemas durante este processo, pode optar por pular e utilizar diretamente uma imagem Docker, que é mais simples. Ambos os cenários serão abordados.

Assim que todos os pré-requisitos forem atendidos, podemos prosseguir com a configuração do TGI. Comece clonando o repositório GitHub:

git clone https://github.com/huggingface/text-generation-inference.git

Em seguida, navegue até o diretório do TGI em sua máquina local e instale-o usando os seguintes comandos:

cd text-generation-inference/
BUILD_EXTENSIONS=False make install

Agora, vamos explorar como utilizar o TGI, com e sem Docker. Para demonstração, usarei o modelo Falcon-7B, que é licenciado sob Apache 2.0.

Iniciando um modelo sem Docker

O processo de instalação gerou um novo comando, “text-generation-launcher”, que inicia o servidor TGI. Para ativar um endpoint usando o modelo Falcon-7B, execute simplesmente o seguinte comando:

text-generation-launcher --model-id tiiuae/falcon-7b-instruct --num-shard 1 --port 8080 --quantize bitsandbytes

Aqui está a explicação de cada parâmetro de entrada:

• model-id: Refere-se ao nome específico do modelo conforme listado no Hugging Face Hub. No nosso caso, para Falcon-7B, é “tiiuae/falcon-7b-instruct”.
• num-shard: Ajuste este parâmetro para corresponder ao número de GPUs disponíveis para utilização. O valor padrão é 1.
• port: Especifica a porta na qual o servidor ouvirá as requisições. A porta padrão é 8080.
• quantize: Para usuários com GPUs com VRAM inferior a 24 GB, a quantização do modelo é necessária para evitar sobrecarga de memória. Nos comandos anteriores, “bitsandbytes” é selecionado para quantização imediata. Outra opção, “GPTQ” (“gptq”), também está disponível, embora seu funcionamento possa ser menos familiar.

Aplicações do TGI

Existem várias maneiras de integrar o servidor Text Generation Inference (TGI) em suas aplicações. Uma vez operacional, você pode interagir com ele enviando uma requisição POST para o endpoint /generate para obter resultados.

Se você optar pelo streaming contínuo de tokens com o TGI, utilize o endpoint , conforme demonstrado na próxima seção. Essas requisições podem ser feitas usando sua ferramenta preferida, como curl, Python ou TypeScript. Para consultar o modelo servido pelo TGI com um script Python, você precisará instalar a seguinte biblioteca text-generation. Você pode fazer isso facilmente executando o seguinte comando pip:

pip install text-generation

Após iniciar o servidor TGI, crie uma instância de InferenceClient() com a URL apontando para o endpoint do modelo. Em seguida, você pode invocar text_generation() para enviar requisições ao endpoint usando Python.

from text_generation import Client
client = Client(“http://127.0.0.1:8080”)
client.text_generation(prompt=“Your prompt here!”)

Para ativar o streaming com o InferenceClient, basta definir stream=True. Isso permitirá que você receba tokens em tempo real conforme eles são gerados no servidor. Veja como usar o streaming:

for token in client.text_generation(“Your prompt here!”, max_new_tokens=12, stream=True):
print(token)

Fazendo perguntas a um modelo por meio do TGI

Lembre-se de que você estará interagindo com o modelo implantado em seu endpoint, que no nosso caso é o Falcon-7B. Através do TGI, estabelecemos um endpoint ativo que facilita a obtenção de respostas do LLM escolhido.

Como resultado, com Python, os prompts podem ser enviados diretamente ao LLM através do cliente hospedado em nosso dispositivo local, acessível pela porta 8080. Portanto, o script Python correspondente seria assim:

from text_generation import Client
client = Client(“http://127.0.0.1:8080”)
print(client.generate(“Translate the following sentence into spanish: ‘What does Large Language Model mean?’”, max_new_tokens=500).generated_text)

Receberemos uma resposta do modelo sem precisar instalá-lo em nosso ambiente. Em vez de usar Python, podemos consultar o LLM com CURL, conforme demonstrado no exemplo a seguir:

curl 127.0.0.1:8080/generate \
-X POST \
-d ‘{“inputs”:“Code in Javascript a function to remove all spaces in a string and then print the string twice.”,“parameters”:{“max_new_tokens”:500}}’ \
-H ‘Content-Type: application/json’

Após experimentar o TGI, ele demonstra uma velocidade impressionante. Com Falcon-7B (com limite de 500 tokens), leva apenas alguns segundos. Em contraste, a abordagem de inferência típica usando a biblioteca transformers requer aproximadamente 30 segundos.

Integração com novita.ai usando o LLM do novita.ai

A partir da versão 1.4.0, o TGI introduziu uma API compatível com a API LLM do novita.ai. Esta nova API de Mensagens permite uma transição perfeita para clientes e usuários de modelos novita.ai para LLMs open-source. A API é projetada para integração direta com as bibliotecas cliente do novita.ai ou com ferramentas de terceiros como LangChain ou LlamaIndex.

O suporte do TGI para Mensagens garante que seus Inference Endpoints sejam totalmente compatíveis com a API LLM do novita.ai. Essa compatibilidade permite que os usuários substituam facilmente qualquer script existente que use modelos novita.ai por LLMs abertos hospedados em endpoints TGI, sem complicações.

Esta atualização facilita a troca sem esforço, concedendo acesso imediato às extensas vantagens dos modelos open-source, incluindo:

Controle total e transparência em relação a modelos e dados. Eliminação de preocupações com limites de taxa. Flexibilidade para adaptar sistemas para atender a requisitos exclusivos. Um exemplo de como integrar o TGI ao protocolo de conclusão de chat do novita.ai é fornecido abaixo:

from openai import OpenAI

client = OpenAI(
base_url=“​https://api.novita.ai/v3/openai”,
# Get the NovitaAI API Key by referring: ​https://novita.ai/get-started/Quick\_Start.html#\_3-create-an-api-key
api_key=“”,
)

model = “meta-llama/llama-3-8b-instruct”
stream = True # or False
max_tokens = 512

chat_completion_res = client.chat.completions.create(
model=model,
messages=[
{
“role”: “system”,
“content”: “Act like you are a helpful assistant.”,
},
{
“role”: “user”,
“content”: “Hi there!”,
}
],
stream=stream,
max_tokens=max_tokens,
)

if stream:
for chunk in chat_completion_res:
print(chunk.choices[0].delta.content or “”, end=“”)
else:
print(chat_completion_res.choices[0].message.content)

Como evidente, a biblioteca novita.ai pode ser utilizada para especificar nosso ENDPOINT e nossa senha do Hugging Face. Para mais informações sobre esta integração, consulte a documentação do Hugging Face TGI.

Dicas Práticas ao Usar o TGI

Conceitos fundamentais de LLMs

Antes de mergulhar no HuggingFace TGI, é importante ter uma boa compreensão dos Grandes Modelos de Linguagem. Familiarize-se com conceitos-chave como tokenização, mecanismos de atenção e a arquitetura Transformer. Esses fundamentos são essenciais para personalizar modelos e melhorar os resultados da geração de texto.

Preparação e otimização do modelo — entendendo o Hugging Face

Aprenda a preparar e otimizar modelos para suas necessidades específicas. Isso envolve selecionar o modelo apropriado, personalizar tokenizadores e aplicar técnicas para melhorar o desempenho sem comprometer a qualidade.

Familiarize-se com como o HuggingFace opera e como usar seu HuggingFace Hub para desenvolvimento de PLN. Um bom ponto de partida é o tutorial “An Introduction to Using Transformers and Hugging Face.”

Compreender o conceito de fine-tuning também é essencial, pois os modelos frequentemente precisam de otimização para objetivos específicos. Você pode aprender como fazer fine-tuning de um modelo com o guia “An Introductory Guide to Fine-Tuning LLMs.”

Estratégias de geração

Investigue diferentes abordagens para geração de texto, incluindo busca gulosa (greedy search), busca em feixe (beam search) e amostragem top-k. Cada método tem suas vantagens e desvantagens, afetando a coerência, criatividade e relevância do texto gerado.

Conclusão

O toolkit TGI da Hugging Face capacita indivíduos a explorar a geração de texto por IA. Ele fornece um kit de ferramentas amigável para implantar e hospedar LLMs para aplicações sofisticadas de PLN que demandam texto semelhante ao humano.

Embora o auto-hospedagem de grandes modelos de linguagem ofereça privacidade de dados e controle de custos, ela exige hardware robusto. No entanto, avanços recentes na área permitem que modelos menores sejam utilizados diretamente em nossas máquinas locais.

novita.ai, a plataforma completa para criatividade sem limites que oferece acesso a mais de 100 APIs. Desde geração de imagens e processamento de linguagem até aprimoramento de áudio e manipulação de vídeo, com pagamento conforme o uso barato, libera você das tarefas de manutenção de GPU enquanto constrói seus próprios produtos. Experimente gratuitamente.

Leitura recomendada

Qual é a diferença entre LLM e GPT

Previsões do LLM Leaderboard 2024 Reveladas

Novita AI LLM Inference Engine: a maior taxa de transferência e a inferência mais barata disponível