Capítulo 5: Large Language Models (LLMs)

Capítulo 5: Large Language Models (LLMs)#

cover

Introdução aos Modelos de Linguagem de Grande Escala (LLMs)#

Os Modelos de Linguagem de Grande Escala, conhecidos como LLMs (Large Language Models), representam uma das maiores inovações no campo do Deep Learning e da Inteligência Artificial. Construídos sobre arquiteturas de redes neurais profundas, os LLMs são treinados em volumes massivos de dados textuais, possibilitando compreender, gerar e interagir com a linguagem humana de forma natural, coerente e flexível.

Histórico e Evolução#

Modelos Baseados em Contagem e Probabilidade#

Os métodos iniciais no processamento de linguagem natural, como o bag-of-words e os modelos de Markov, focavam em padrões de frequência e transições probabilísticas. Embora eficazes em tarefas simples, esses modelos eram incapazes de capturar contextos semânticos mais profundos ou relações complexas entre palavras.

Representações Embedding#

A introdução do Word2Vec em 2013 marcou um divisor de águas no NLP. Pela primeira vez, foi possível criar representações densas de palavras em espaços vetoriais contínuos, onde relações semânticas e sintáticas eram capturadas de forma intuitiva. Operações como $ \text{"rei"} - \text{"homem"} + \text{"mulher"} = \text{"rainha"} $ demonstraram o poder de vetores para modelar analogias. Apesar de sua simplicidade, o Word2Vec continua sendo uma referência histórica e prática, embora métodos mais avançados, como embeddings contextuais, tenham se tornado predominantes.

Modelos Recurrentes (RNNs)#

As Redes Neurais Recorrentes (RNNs) representaram um avanço ao incorporar a noção de sequencialidade no processamento de texto. Elas introduziram estados internos que permitiam “memorizar” informações ao longo de sequências.

LSTMs (Long Short-Term Memory): Resolveram problemas de dependências de longa distância por meio de portas que regulam o fluxo de informações entre os estados.
GRUs (Gated Recurrent Units): Oferecem uma alternativa mais simples às LSTMs, mantendo desempenho competitivo com menor custo computacional.

Arquiteturas Transformer#

Em 2017, o artigo “Attention is All You Need” redefiniu o campo da inteligência artificial ao introduzir os Transformers, uma arquitetura que revolucionou o processamento de linguagem natural (NLP) e aprendizado profundo. Ao substituir os mecanismos recorrentes por atenção, os Transformers modelam relações entre palavras de forma direta e eficiente, independentemente da distância entre elas em uma sequência.

Um dos conceitos fundamentais dos Transformers é o positional encoding, que incorpora informações sobre a posição relativa das palavras na sequência. Isso é essencial, pois, ao contrário de redes recorrentes, os Transformers processam as palavras em paralelo, e essa codificação garante que a ordem das palavras seja considerada no contexto.

Outro pilar é o mecanismo de atenção, que permite que o modelo foque em diferentes partes da entrada para determinar o significado contextual das palavras. Dentro desse mecanismo, o self-attention é o avanço principal. Ele calcula a relação de cada palavra com todas as outras na mesma sequência, permitindo que o modelo compreenda dependências complexas, tanto locais quanto distantes. Isso transforma os Transformers em sistemas altamente eficazes para capturar nuances contextuais em dados textuais.

Esses avanços, aliados à capacidade de processamento paralelo, possibilitaram o surgimento de modelos como BERT, GPT e outros, que continuam a liderar o estado da arte em diversas aplicações de inteligência artificial.

Modelos Pré-treinados e Finetuning#

Modelos Pré-treinados#

Modelos como BERT (Bidirectional Encoder Representations from Transformers) e GPT (Generative Pre-trained Transformer) aprendem representações linguísticas robustas em grandes volumes de texto antes de serem adaptados para tarefas específicas.

BERT (2018):
Análise bidirecional do contexto textual, ideal para tarefas como classificação e respostas a perguntas.
Exemplo: Na frase “Eu fui ao banco sacar dinheiro”, o BERT considera as palavras anteriores e posteriores para deduzir que “banco” refere-se a uma instituição financeira.
GPT (evolução até GPT-4):
Abordagem unidirecional focada na geração de texto coerente.
Exemplo: Ao receber “Escreva um resumo sobre a história da aviação”, o GPT gera parágrafos completos e estruturados.

Finetuning#

Após o pré-treinamento, o modelo é ajustado com dados rotulados específicos, adaptando-o para problemas especializados.
Exemplo: Ajustar o BERT para classificar avaliações de filmes como positivas ou negativas.

Comparação entre BERT e GPT#

Aspecto	BERT	GPT
Direcionalidade	Bidirecional	Unidirecional
Objetivo do Treinamento	Predição de palavras mascaradas	Geração de texto fluido
Tarefas Principais	Classificação, respostas a perguntas	Geração de texto, completamento
Ponto Forte	Compreensão contextual completa	Criatividade e fluidez

Princípios Básicos dos LLMs#

Os LLMs são treinados para prever a próxima palavra ou token em sequências textuais. Essa tarefa possibilita aplicações avançadas como resumo automático, interação em linguagem natural e resolução de problemas complexos.

Tokens#

Tokens são as menores unidades processadas pelos LLMs. Eles podem representar palavras, subpalavras, caracteres ou símbolos.
Exemplo: “Inacreditável” pode ser segmentado em “ina”, “credi” e “vável”, dependendo da segmentação utilizada.

Características Principais#

Treinamento em larga escala: Utilizam datasets com bilhões ou trilhões de tokens.
Generalização: Realizam tarefas com aprendizado zero-shot, few-shot ou ajustado por finetuning.
Infraestrutura avançada: Requerem GPUs e TPUs de última geração.

Bancos de Dados: Relacionais vs. Vetoriais#

Bancos Relacionais Os bancos de dados relacionais são organizados em tabelas, com linhas representando registros e colunas armazenando atributos. Eles são otimizados para consultas determinísticas, onde os resultados seguem critérios exatos definidos pelo usuário.
Exemplo: “Recupere todas as vendas acima de R$ 1000.” Nesse caso, a consulta retorna registros que correspondem exatamente à condição especificada.

Bancos Vetoriais Diferentemente dos bancos relacionais, os bancos vetoriais são projetados para armazenar e consultar embeddings — representações numéricas de dados, como textos ou imagens, em espaços multidimensionais. Eles realizam buscas por similaridade, identificando itens com significados ou características próximas, mesmo sem uma correspondência exata.
Exemplo: Dada uma consulta textual como “melhores filmes de ficção científica”, o banco vetorial retorna resultados semanticamente relacionados, mesmo que os títulos dos filmes não contenham exatamente essas palavras.

Aspecto	Relacionais	Vetoriais
Modelo de Dados	Estruturado (tabelas, colunas)	Não estruturado (vetores)
Tipo de Consultas	Determinísticas	Similaridade semântica
Aplicação	ERP, CRM, sistemas financeiros	Motores de busca, recomendação

Integração com LLMs#

Os LLMs (Large Language Models) geram embeddings que capturam o significado semântico de textos, imagens ou outros dados. Esses embeddings podem ser armazenados em bancos vetoriais para facilitar buscas semânticas, recomendações e outras aplicações baseadas em similaridade.

Exemplo de aplicação: Um sistema de recomendação pode usar embeddings gerados por um LLM para sugerir artigos, produtos ou conteúdos. Mesmo que as palavras-chave da consulta do usuário não correspondam diretamente aos itens no banco, a busca semântica identifica itens relacionados por contexto e significado. Isso permite recomendações mais precisas e relevantes, especialmente em sistemas onde o contexto é crucial, como assistentes virtuais ou e-commerce.

Modelos Modernos#

Modelos como GPT-4, Google Gemini, e Meta LLaMA representam o estado da arte em LLMs (Large Language Models), combinando pré-treinamento extensivo e fine-tuning para oferecer capacidades avançadas e diversificadas. Eles baseiam-se em arquiteturas Transformer, com particularidades específicas:

Modelo	Arquitetura Base	Características Principais	Exemplos de Uso
GPT-4	GPT (Generative Pretrained Transformer)	Especialista em geração de texto coerente, tradução automática e suporte interativo em múltiplos idiomas.	Assistentes virtuais, chatbots personalizados, ferramentas de criação de conteúdo, como resumos e redações.
Google Gemini	PaLM (Pathways Language Model)	Modelo multimodal que integra dados textuais, visuais e interativos, permitindo aplicações diversificadas.	Análise de imagens com texto, sistemas de aprendizado interativo, interfaces de suporte ao cliente.
Meta LLaMA	LLaMA (Large Language Model Meta AI)	Modelo eficiente e altamente personalizável, focado em pesquisa avançada e exploração de novas fronteiras em NLP.	Criação de conteúdos automatizados, personalização de diálogos, pesquisa acadêmica avançada.

Detalhes das Arquiteturas

GPT-4:
- Baseado no mecanismo de atenção unidirecional (causal attention).
- Focado em tarefas generativas de texto.
- Utiliza estratégias de ajuste fino para suportar múltiplos idiomas e domínios.
Google Gemini:
- Construído sobre o PaLM, integra aprendizado multimodal.
- Combina capacidades generativas e compreensivas.
- Utiliza avanços do sistema Pathways, permitindo processamento eficiente e escalável.
Meta LLaMA:
- Arquitetura otimizada para eficiência computacional.
- Flexível para adaptação em diferentes aplicações.
- Destaca-se por sua capacidade de lidar com tarefas personalizadas e pesquisas de ponta.

Conceitos Relacionados

Positional Encoding: Usado em todas as arquiteturas Transformer para incorporar informações de posição das palavras.
Self-Attention: Permite a compreensão de relações contextuais entre palavras, sendo o principal avanço dos Transformers.
Multimodalidade: Uma característica de modelos como o Google Gemini, que processam texto, imagens e outros tipos de dados.

Os avanços em modelos como esses impulsionam aplicações diversas, desde suporte ao cliente até análise de imagens e pesquisa científica, estabelecendo um novo padrão para a inteligência artificial moderna. |

Integração Prática com APIs#

Exemplo: Google Gemini no AI Studio

O Google AI Studio possibilita o uso das APIs do Google Gemini para criar aplicativos interativos. Abaixo está um exemplo em Python para gerar respostas de um chatbot baseado no modelo:

import requests

# Defina o endpoint da API e a chave de autenticação
API_URL = "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent"
API_KEY = "sua-chave-aqui"

# Dados de entrada para o modelo
data = {
    "contents": [
        {
            "parts": [
                {"text": "Quais são os benefícios do aprendizado por reforço em IA?"}
            ]
        }
    ]
}

# Requisição para a API
response = requests.post(
    f"{API_URL}?key={API_KEY}",  # Autenticação via parâmetro de consulta
    json=data
)

# Exibe a resposta do modelo
if response.status_code == 200:
    result = response.json()
    print("Resposta do modelo:", result["candidates"][0]["content"]["parts"][0]["text"])
else:
    print("Erro:", response.status_code, response.text)

Explicação resumida do código:

Importação da biblioteca requests: necessária para fazer requisições HTTP.
Configuração do endpoint e chave de API: substitua "sua-chave-aqui" por sua chave válida de API.
Preparação dos dados de entrada: forneça o texto ou pergunta que será processado pelo modelo.
Envio da requisição POST: utiliza o método requests.post para enviar os dados ao endpoint.
Tratamento da resposta: exibe o texto gerado pelo modelo ou retorna a mensagem de erro em caso de falha.

Ollama: Rodando Modelos de Linguagem Localmente#

O Ollama é uma ferramenta projetada para executar modelos de linguagem (LLMs) localmente, eliminando a necessidade de conexão a servidores externos. Isso é especialmente útil em cenários que exigem privacidade ou onde há restrições de acesso à internet. Com o Ollama, você pode rodar modelos como o llama3.2:1b diretamente no servidor, oferecendo flexibilidade para integração e personalização em aplicações locais.

Instalação e Uso do Ollama#

Requisitos Básicos
Antes de instalar o Ollama, certifique-se de que seu sistema atende aos seguintes requisitos:

Sistema operacional: Linux, macOS ou Windows (com WSL).
Hardware: Recursos de CPU ou GPU compatíveis com o modelo a ser usado.
Python: Versão 3.8 ou superior.

Instalando o Ollama
Execute o comando abaixo para instalar o Ollama diretamente no seu sistema:

curl -sSf https://ollama.com/install.sh | sh

Verifique a instalação com:

ollama --version

Baixando um Modelo
Para usar um modelo, é necessário baixá-lo previamente:

ollama pull llama3.2:1b

Executando o Modelo Localmente
Após instalar e carregar o modelo, você pode executá-lo diretamente no terminal:

ollama run llama3.2:1b

Ollama via FastAPI#

Uma maneira eficiente de permitir que várias pessoas acessem o modelo local é criar uma API. O FastAPI é um framework para construir APIs modernas e performáticas em Python. Ele oferece uma interface simples para definir endpoints e validação automática de dados, sendo uma escolha popular para expor funcionalidades em aplicações web.

Criando um Servidor FastAPI para o Ollama

Instalando Dependências
Instale o FastAPI e o Uvicorn (servidor de execução):

pip install fastapi uvicorn

Configurando o Servidor
Crie um arquivo chamado ollama_server.py com o seguinte código:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import subprocess

app = FastAPI()

# Modelo de entrada para validação
class QueryRequest(BaseModel):
    prompt: str

@app.post("/query")
async def query_model(request: QueryRequest):
    """Recebe um prompt e retorna a resposta do modelo."""
    try:
        result = subprocess.run(
            ["ollama", "run", "llama3.2:1b", request.prompt],
            capture_output=True,
            text=True
        )
        if result.returncode != 0:
            raise Exception(result.stderr.strip())
        return {"response": result.stdout.strip()}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/")
async def root():
    """Verifica se o servidor está ativo."""
    return {"message": "Servidor do modelo está ativo!"}

Explicação do Código

Estrutura do servidor: O FastAPI cria um servidor web com dois endpoints:
- GET /: Verifica se o servidor está ativo.
- POST /query: Recebe um prompt como entrada e envia esse comando ao modelo local usando o comando ollama run.
Validação de entrada: O QueryRequest usa a biblioteca Pydantic para garantir que o campo prompt seja enviado no formato correto.
Execução do modelo: O comando é executado com subprocess.run, e a resposta do modelo é capturada e retornada como JSON.
Tratamento de erros: Em caso de falhas no comando ou no servidor, uma exceção é levantada com uma mensagem apropriada.

Iniciando o Servidor
Execute o servidor FastAPI com o seguinte comando:

uvicorn ollama_server:app --host 0.0.0.0 --port 5000

Testando a API

Teste Simples:
```
curl -X GET http://0.0.0.0:5000
```

Envio de Consulta ao Modelo:

curl -X POST http://<server_ip>:5000/query -H "Content-Type: application/json" -d '{"prompt": "Qual é a capital do Brasil?"}'

Interface Interativa do FastAPI:
Acesse a documentação automática do FastAPI em:
```
http://<server_ip>:5000/docs
```

Esse método garante que apenas uma instância do modelo seja carregada na memória, otimizando os recursos do servidor enquanto múltiplos usuários podem interagir com o modelo simultaneamente.

Exemplo: Meta LLaMA via Ollama#

O Ollama também pode ser integrado diretamente a projetos Python. Veja um exemplo prático de como utilizar a biblioteca ollama:

from ollama import Client

def chat_with_llama():
    client = Client(host='http://localhost:11434')
    
    try:
        response = client.chat(model='llama3.2:1b', messages=[
            {'role': 'user', 'content': 'Olá, como você está?'}
        ])
        print(response['message']['content'])
    except Exception as e:
        print(f"Erro: {e}")

if __name__ == "__main__":
    chat_with_llama()

Explicação do Código

Conexão com o servidor local: A biblioteca ollama conecta-se ao servidor local no endereço localhost:11434.
Envio de consulta: O método chat envia mensagens para o modelo especificado (llama3.2:1b).
Tratamento de erros: Garante que mensagens de erro sejam exibidas em caso de falhas.
Execução do script: O bloco if __name__ == "__main__" assegura que o código seja executado quando chamado diretamente.

Este exemplo demonstra como o Ollama pode ser integrado em aplicações maiores, permitindo interações personalizadas com modelos de linguagem de maneira prática e eficiente.

Exercícios#

(Gemini)#

Neste exercício, você irá implementar um script Python que utiliza a API do Gemini para interagir com o modelo generativo. O objetivo é criar uma interface simples onde o usuário possa inserir sua própria pergunta e receber a resposta do modelo.

Requisitos:

Configuração do Modelo:
- Use as mesmas configurações apresentadas no exemplo inicial:
  - temperature: 1
  - top_p: 0.95
  - top_k: 40
  - max_output_tokens: 8192
  - response_mime_type: "text/plain"
- O modelo a ser utilizado é o "gemini-2.0-flash-exp".
Funcionalidades do Script:
- Solicite que o usuário insira uma pergunta por meio do terminal (usando input()).
- Crie uma nova sessão de chat sem histórico inicial.
- Envie a pergunta do usuário para o modelo.
- Exiba a resposta do modelo no terminal.
Extras (Opcional):
- Após mostrar a resposta, pergunte ao usuário se ele deseja fazer outra pergunta. Se sim, continue a interação reutilizando a mesma sessão de chat.
- Adicione um comando para encerrar o script, como "sair".

Exemplo de Execução:

Digite sua pergunta para o modelo Gemini: Quais são os benefícios do aprendizado por reforço em IA?  
Resposta do modelo: O aprendizado por reforço em IA oferece benefícios como a capacidade de tomar decisões em ambientes dinâmicos, aprendizado sem supervisão direta, e otimização de estratégias em tarefas complexas.  

Deseja fazer outra pergunta? (sim/não): sim  
Digite sua pergunta para o modelo Gemini: Onde o aprendizado por reforço é aplicado com sucesso?  
Resposta do modelo: Exemplos incluem robótica, jogos como xadrez e Go, e sistemas de recomendação personalizados.  

Deseja fazer outra pergunta? (sim/não): não  
Encerrando o programa. Até logo!

(Ollama)#

Você aprendeu sobre a ferramenta Ollama para rodar modelos de linguagem localmente e o exemplo de código que utiliza a biblioteca ollama para se conectar a um servidor local. Seu objetivo agora é criar um chatbot simples que interaja com o usuário em português.

O chatbot deve receber uma mensagem do usuário, enviá-la para o modelo llama3.2:1b usando o cliente do Ollama e exibir a resposta do modelo no terminal.

Função a Ser Criada:
Implemente a função chat_with_user() que realiza as seguintes etapas:

Conecta-se ao servidor do Ollama.
Envia uma mensagem do usuário para o modelo.
Exibe a resposta do modelo.
Permite que o usuário envie novas mensagens até digitar “sair”.

Requisitos:

Conexão com o servidor Ollama: Utilize o cliente fornecido pela biblioteca ollama para conectar-se ao servidor local em http://localhost:11434.
Envio de mensagens: O modelo deve receber mensagens enviadas pelo usuário no terminal.
Resposta do modelo: Exiba a resposta do modelo de forma clara.
Loop de interação: Continue a interação até que o usuário digite “sair”.

Testes:
Teste o chatbot enviando as mensagens abaixo e confirme que ele responde apropriadamente:

Entrada: “Qual é a capital do Brasil?”
Saída esperada: O modelo deve responder “Brasília”.

Entrada: “Quem escreveu Dom Quixote?”
Saída esperada: O modelo deve responder “Miguel de Cervantes”.

Entrada: “sair”
Saída esperada: O programa exibe uma mensagem de despedida e encerra.