AI: IA Generativa e Grandes Modelos

Última atualização: 2026-08-26

A IA Generativa é atualmente a tendência tecnológica mais quente—ChatGPT, Midjourney e GitHub Copilot são todos produtos deste campo. Este capítulo ajudará você a entender: O que é IA generativa? Como funcionam os grandes modelos de linguagem? O que são tokens, janelas de contexto e parâmetros de temperatura? Como você pode configurar uma API de LLM com apenas cinco linhas de código Python?

1. O Que Você Aprenderá

• A Diferença entre IA Generativa e IA Discriminativa
• Como Funcionam os Modelos de Linguagem de Grande Escala (LLMs)
• Tokens e Janelas de Contexto
• Visão Geral da Família de Modelos GPT/Claude/Llama
• Chamando a API do LLM com Python

2. História: Um Assistente de IA em 5 Linhas de Código

(1) Ponto de Dor: Atualizações Inteligentes no Sistema de Atendimento ao Cliente

Alice trabalha como desenvolvedora backend em uma empresa de e-commerce. Seu chefe pediu que ela adicionasse um assistente de IA ao sistema de atendimento ao cliente, capaz de responder automaticamente a perguntas comuns dos usuários. Alice já ouviu falar de GPT e ChatGPT, mas não sabe como usá-los — "Isso não é coisa para especialistas em algoritmos? Alguém como eu, que escreve código CRUD, realmente consegue lidar com isso?"

(2) A solução de 5 linhas do Bob

Bob puxou seu teclado e, em cinco minutos, escreveu cinco linhas de código Python para fazer a API da OpenAI funcionar:

from openai import OpenAI
client = OpenAI(api_key="your-api-key")
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "How to return a product?"}]
)
print(response.choices[0].message.content)

Bob disse: "Veja, um grande modelo de linguagem é apenas um gerador de texto superpoderoso. Você dá um prompt, e ele te dá uma resposta. Não é diferente de chamar uma API REST."

▶ Exemplo: Conectar-se à API da OpenAI em 5 linhas de código (Dificuldade: ⭐)

# Chamada mínima à API da OpenAI
from openai import OpenAI
client = OpenAI()  # Usa a variável de ambiente OPENAI_API_KEY
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Say hello in 3 languages."}]
)
print(response.choices[0].message.content)

Hello! / ¡Hola! / Hello!

(3) Benefícios: Quebrando Barreiras com uma Mentalidade de API

Alice descobriu que — chamar um LLM não exige compreensão das derivações matemáticas por trás dos Transformers, assim como chamar um banco de dados não exige compreender como as árvores B+ funcionam. Entender os princípios ajuda a fazer escolhas melhores, mas tudo o que você precisa para começar é a API.

3. Distinguindo entre IA e IA Generativa

(1) Dois Paradigmas de IA

Os modelos de IA são classificados em dois grandes paradigmas com base em seus objetivos de saída:

Compreensão intuitiva: A IA discriminativa responde "O que é isso?", enquanto a IA generativa responde "Crie um para mim."

(2) Por que a IA generativa é tão popular?

A IA Generativa Explodiu em 2022–2023: Três Razões:

1. A arquitetura Transformer (2017) permite que os modelos processem textos longos.
2. Dados Massivos + Alto Poder Computacional permitiram que a escala dos modelos saltasse de centenas de milhões para centenas de bilhões de parâmetros.
3. RLHF (Aprendizado por Reforço com Feedback Humano) alinha a saída do modelo com as preferências humanas.

(3) Os modelos discriminativos e generativos podem ser combinados?

Sim. Aplicações modernas de IA frequentemente combinam os dois — primeiro usando um modelo discriminativo para classificação de intenção, e depois usando um modelo generativo para gerar uma resposta. O recurso "function call" do ChatGPT é essencialmente uma combinação de discriminação (determinando qual função chamar) e geração (gerando parâmetros da função e uma resposta em linguagem natural).

4. Como os Modelos de Linguagem Grandes (LLMs) Funcionam

(1) Mecanismo Central: Prevendo o Próximo Token

A essência de um LLM é extremamente simples—dado o texto anterior, prever o próximo token mais provável. Ao repetir este processo de previsão, uma resposta completa é gerada.

Input:  "The cat sat on the"
Step 1: "The cat sat on the" → predict "mat"  (most likely next token)
Step 2: "The cat sat on the mat" → predict "."
Step 3: "The cat sat on the mat." → predict "<END>"
Output: "The cat sat on the mat."

Isto não é sobre "entender" o texto; em vez disso, envolve aprender os padrões estatísticos da ocorrência de tokens dentro de um corpus massivo. No entanto, como os dados de treinamento são suficientemente grandes (na escala da internet), esses padrões estatísticos exibem uma "inteligência" impressionante.

(2) Processo de Geração do LLM

graph LR
    A[Prompt<br/>Input Text] --> B[Tokenizer<br/>Tokenize]
    B --> C[Transformer<br/>Model Inference]
    C --> D[Next Token<br/>Probability Dist.]
    D --> E[Sampling<br/>Temp/Top-P Sample]
    E --> F[Decode<br/>Decode to Text]
    F --> G{Done?}
    G -->|No| C
    G -->|Yes| H[Output<br/>Full Output Text]

graph LR
    A[Prompt<br/>Input Text] --> B[Tokenizer<br/>Tokenize]
    B --> C[Transformer<br/>Model Inference]
    C --> D[Next Token<br/>Probability Dist.]
    D --> E[Sampling<br/>Temp/Top-P Sample]
    E --> F[Decode<br/>Decode to Text]
    F --> G{Done?}
    G -->|No| C
    G -->|Yes| H[Output<br/>Full Output Text]

(3) Intuição por Trás da Arquitetura Transformer

O Transformer é o mecanismo central dos modelos de linguagem grandes (LLMs) e foi proposto pelo Google em 2017 no artigo "Attention Is All You Need". Sua inovação chave é o mecanismo de autoatenção (self-attention)—que permite ao modelo "ver" todos os outros tokens na entrada e calcular sua relevância ao processar cada token.

5. Tokens e Janelas de Contexto

(1) O que é um token?

Um token é a menor unidade de texto processada por um LLM. Não é nem um caractere nem uma palavra, mas sim uma "subpalavra"—algo entre os dois.

Texto:   "Hello, world!"
Tokens: ["Hello", ",", " world", "!"]     → 4 tokens

Texto:   "artificial intelligence"
Tokens: ["art", "ific", "ial"]               → 3 tokens (tokenização por subpalavras)

Inglês: Em média, 1 token ≈ 4 caracteres (aproximadamente 0,75 palavras). Chinês: Em média, 1 token ≈ 1–2 caracteres chineses, portanto o consumo de tokens em chinês é tipicamente 2–3 vezes maior do que em inglês.

▶ Exemplo: Calculando o número de tokens usando tiktoken (Dificuldade: ⭐)

# Calculate token count using tiktoken
import tiktoken

encoding = tiktoken.encoding_for_model("gpt-4o-mini")

texts = [
    "Hello, world!",
    "The quick brown fox jumps over the lazy dog.",
    "Artificial intelligence is changing the world.",
    "Generative AI is transforming the world."
]

for text in texts:
    tokens = encoding.encode(text)
    print(f"Text: {text}")
    print(f"  Tokens: {len(tokens)} | Decoded: {encoding.decode(tokens[:3])}...")
    print()

Text: Hello, world!
  Tokens: 3 | Decoded: Hello...

Text: The quick brown fox jumps over the lazy dog.
  Tokens: 10 | Decoded: The quick brown...

Text: Artificial intelligence is changing the world.
  Tokens: 8 | Decoded: Artifici...

Text: Generative AI is transforming the world.
  Tokens: 8 | Decoded: Generative AI is...

(2) Janela de Contexto

A janela de contexto é o número máximo de tokens que um LLM pode processar de uma só vez. Ela determina quanta informação o modelo pode "lembrar"—o número total de tokens na entrada e na saída combinados não pode exceder esse limite.

(3) Comparação dos Métodos de Faturamento Baseado em Tokens

A API do LLM é faturada com base no uso de tokens, com preços diferentes para entradas e saídas:

6. Parâmetros de Temperatura e Amostragem

(1) Temperatura

A Temperatura controla a aleatoriedade das saídas dos LLMs. Quanto menor a temperatura, mais determinística é a saída; quanto maior a temperatura, mais diversa é a saída.

Temperatura = 0    → Sempre escolhe o token mais provável (determinístico)
Temperatura = 0.7  → Maioria das vezes, mas com alguma variação (padrão para chat)
Temperatura = 1.0  → Variação natural, segue a distribuição aprendida
Temperatura = 2.0  → Muito aleatório, frequentemente sem sentido

(2) Top-P (Agrupamento K-means)

Top-P é outro parâmetro que controla a aleatoriedade. Ele amostra apenas dos primeiros P tokens na distribuição de probabilidade:

Top-P = 0.1  → Considera apenas os 10% dos tokens mais prováveis (conservador)
Top-P = 0.9  → Considera tokens que cobrem 90% de probabilidade (moderado)
Top-P = 1.0  → Considera todos os tokens (sem filtragem)

▶ Exemplo: Comparação de Saídas para Diferentes Parâmetros de Temperatura (Dificuldade: ⭐⭐)

# Compare outputs at different temperatures
from openai import OpenAI
client = OpenAI()

prompt = "Write a one-sentence description of a sunset."
temperatures = [0, 0.5, 1.0, 1.5]

for temp in temperatures:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=temp,
        max_tokens=50
    )
    text = response.choices[0].message.content
    print(f"Temperature={temp}: {text}")
    print()

Temperature=0: The sun dipped below the horizon, painting the sky in shades of orange and pink.

Temperature=0.5: Golden light spilled across the horizon as the sun melted into a sea of amber clouds.

Temperature=1.0: The day's final breath set the clouds ablaze, draping the world in a warm, fading embrace of crimson and gold.

Temperature=1.5: Colors—copper, violet, impossible rose—bloomed like dying flowers across the fractured sky as the sun surrendered.

7. Evolução da Série GPT e Famílias de Modelos

(1) Evolução da Série GPT

(2) Comparação dos Principais LLMs

(3) Comparação entre Modelos de Código Aberto vs. Código Fechado

8. Padrões de Chamada de API

(1) Padrões de Chamada Básicos

Existem apenas três parâmetros principais para chamar a API do LLM: model, messages, e o opcional temperature.

▶ Exemplo: Chamadas Básicas de API da OpenAI (Dificuldade: ⭐)

# Basic OpenAI API call with system prompt
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "What is a Transformer in 2 sentences?"}
    ],
    temperature=0.3
)

print(response.choices[0].message.content)
print(f"\nTokens used: {response.usage.total_tokens}")

A Transformer is a neural network architecture based on self-attention, allowing it to process all input tokens in parallel rather than sequentially. Introduced in 2017, it became the foundation for modern LLMs like GPT and BERT.

Tokens used: 58

(2) Modo de Diálogo Multi-round

A API de Chat mantém o histórico da conversa usando o array messages, adicionando uma mensagem por rodada:

▶ Exemplo: Chamada de API para Conversa Multi-round (Dificuldade: ⭐⭐)

# Multi-turn conversation with OpenAI API
from openai import OpenAI
client = OpenAI()

conversation = [
    {"role": "system", "content": "You are a helpful Python tutor."}
]

questions = [
    "What is a list comprehension?",
    "Can you show me an example?",
    "What if I want to filter even numbers?"
]

for q in questions:
    conversation.append({"role": "user", "content": q})
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=conversation,
        temperature=0.3
    )
    reply = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": reply})
    print(f"User: {q}")
    print(f"Bot:  {reply[:120]}...")
    print()

User: What is a list comprehension?
Bot:  A list comprehension is a concise way to create lists in Python using a single line of syntax, combining a for loop and optional conditions...

User: Can you show me an example?
Bot:  Sure! Here's a basic example: squares = [x**2 for x in range(10)] This creates a list [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]....

User: What if I want to filter even numbers?
Bot:  Add a condition: evens = [x for x in range(20) if x % 2 == 0] This produces [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]....

(3) Modo de Saída em Streaming

A saída em streaming retorna os tokens um a um, proporcionando uma melhor experiência de usuário (como efeito de máquina de escrever) e exibindo o primeiro token mais rápido:

▶ Exemplo: Experiência com Saída em Streaming (stream=True) (Dificuldade: ⭐⭐)

# Streaming output with OpenAI API
from openai import OpenAI
client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Explain quantum computing in 3 sentences."}],
    temperature=0.5,
    stream=True
)

print("Streaming response: ", end="")
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
print("\n\n[Stream complete]")

Streaming response: Quantum computing uses quantum bits (qubits) that can exist in superposition, representing 0 and 1 simultaneously. This allows quantum computers to process many calculations in parallel, exponentially speeding up certain problems. Key applications include cryptography, drug discovery, and optimization.

[Stream complete]

9. Exemplo Completo: Assistente de Redação com IA

Crie um "Assistente de Redação com IA": Insira a descrição de um produto, chame a API da OpenAI para gerar textos publicitários em três estilos diferentes e imprima-os para comparação.

▶ Exemplo: Assistente de Redação com IA—Gerando Textos Publicitários em 3 Estilos Diferentes (Dificuldade: ⭐⭐⭐)

# ============================================
# AI Copywriting Assistant
# Input: product description
# Output: 3 styles of ad copy
# ============================================
from openai import OpenAI
client = OpenAI()

product = "Wireless noise-cancelling headphones, 40-hour battery, $199"

styles = [
    ("Professional", "Write a professional, feature-focused ad copy."),
    ("Emotional", "Write an emotional, lifestyle-focused ad copy."),
    ("Humorous", "Write a humorous, witty ad copy.")
]

print("=" * 60)
print(f"Product: {product}")
print("=" * 60)

for style_name, style_prompt in styles:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": f"You are an expert copywriter. {style_prompt}"},
            {"role": "user", "content": f"Write ad copy for: {product}. Keep it under 80 words."}
        ],
        temperature=0.8,
        max_tokens=150
    )
    copy = response.choices[0].message.content
    tokens = response.usage.total_tokens
    cost = (response.usage.prompt_tokens * 0.15 + response.usage.completion_tokens * 0.60) / 1_000_000
    print(f"\n[{style_name}]")
    print(f"{copy}")
    print(f"\n(Tokens: {tokens}, Cost: ${cost:.6f})")

print("\n" + "=" * 60)

============================================================
Produto: Fones de ouvido sem fio com cancelamento de ruído, bateria de 40 horas, $199
============================================================

[Profissional]
Experimente a tecnologia de cancelamento de ruído premium com 40 horas ininterruptas de bateria. Nossos fones de ouvido sem fio oferecem áudio cristalino e design confortável por $199. Perfeito para profissionais que exigem foco e qualidade.

(Tokens: 72, Custo: $0.000032)

[Emocional]
Escape do ruído. Coloque estes fones e deixe o mundo desaparecer—40 horas de pura, ininterrupta paz de espírito. Seja na sua viagem matinal ou em uma noite tranquila, sua trilha sonora está esperando. Apenas $199 pela paz que você pode ouvir.

(Tokens: 68, Custo: $0.000030)

[Humorístico]
Cansado de ouvir o karaokê do vizinho? Estes fones com cancelamento de ruído bloqueiam o caos e entregam 40 horas de doce silêncio. Por $199, é mais barato que se mudar. Seus ouvidos agradecerão.

(Tokens: 58, Custo: $0.000025)

============================================================

❓ Perguntas Frequentes

P: Qual é a relação entre ChatGPT e GPT-4? R: ChatGPT é o nome do produto (aplicativo de IA conversacional da OpenAI), enquanto GPT-4 é o nome do modelo (o motor subjacente). O ChatGPT inicialmente usou GPT-3.5 e depois foi atualizado para GPT-4/GPT-4o. Usando uma analogia: ChatGPT é um carro e GPT-4 é o motor. O mesmo carro pode ser equipado com diferentes motores.

P: Tokens são a mesma coisa que palavras? R: Não, não são. Em inglês, aproximadamente 1 token = 0,75 palavras (4 caracteres); em chinês, aproximadamente 1 token = 1–2 caracteres chineses. Portanto, 1.000 caracteres chineses consomem aproximadamente 500–1.000 tokens, o que é mais do que o comprimento equivalente em inglês. Você pode usar a biblioteca tiktoken para calcular isso com precisão.

P: Qual é a configuração adequada para o parâmetro de temperatura? R: Recomendações gerais — use 0 (determinístico) para extração de código/dados/geração de JSON; 0,7 (natural e variado) para conversas/escrita do dia a dia; e 1,0–1,5 (mais variado) para brainstorming/criatividade. Se você não tem certeza, 0,7 é o valor padrão mais seguro.

P: Modelos de código aberto são suficientes? R: Depende do caso de uso. Llama 3.1 (405B) e Qwen 2.5 (72B) apresentam desempenho próximo ao do GPT-4 em muitas tarefas e são adequados para: ① cenários com requisitos rígidos de privacidade de dados; ② tarefas que exigem ajuste fino personalizado; e ③ casos com alto uso de tokens onde o controle de custos é prioridade. No entanto, se você busca o desempenho máximo e não se importa que seus dados passem por terceiros, as APIs proprietárias ainda lideram.

P: É caro chamar a API de LLM? R: Não é caro para uso diário. GPT-4o-mini custa cerca de $0,15 por 1 milhão de tokens de entrada, então 1.000 solicitações em chinês (500 caracteres cada) custariam cerca de $0,10. No entanto, se você estiver fazendo processamento em lote (como classificar 100.000 registros), os custos podem aumentar rapidamente. Recomendações: ① Use modelos mini para pequenas tarefas; ② Teste tarefas em lote em pequena escala primeiro; ③ Para uso de alto volume, considere implantar você mesmo um modelo de código aberto.

P: Por que os LLMs "alucinam" (inventam fatos)? R: Porque os LLMs são essencialmente "preditores do próximo token", não "recuperadores de fatos". Eles aprendem os padrões estatísticos da linguagem, mas não há garantia de que os fatos que geram estejam corretos. Quando o modelo está incerto, ele gera conteúdo que "parece razoável", mas está incorreto. Estratégias de mitigação: ① Reduza a temperatura ② Forneça materiais de referência (RAG) ③ Instrua o modelo a "dizer 'Eu não sei' se estiver incerto."

📖 Resumo

• IA generativa aprende a partir de distribuições de dados para criar novo conteúdo, enquanto IA discriminativa aprende limites de decisão para classificar—as duas podem ser usadas em combinação.
• O núcleo de um LLM é a "previsão do próximo token": prever repetidamente o token mais provável e concatená-los para formar uma saída completa.
• Um token é a menor unidade processada por um LLM; tokens em chinês consomem de 2 a 3 vezes mais recursos que tokens em inglês; a janela de contexto determina quanto texto o modelo pode processar por vez.
• A temperatura controla a aleatoriedade da saída: 0 = determinístico, 0.7 = natural, 1.5+ = criativo; Top-P é outro filtro de aleatoriedade.
• A série GPT evoluiu de 100 milhões de parâmetros para o nível de trilhões; GPT-4o é atualmente o modelo principal da OpenAI. No campo de código aberto, existem Llama, Qwen e Mistral.
• Chamar a API do LLM requer apenas três parâmetros principais: modelo, mensagens e temperatura; conversas de múltiplas rodadas requerem manter um histórico completo; a saída em streaming melhora a experiência do usuário.

📝 Exercícios

1. Problema Básico (Dificuldade ⭐): Escreva um pequeno programa de tradução usando a API da OpenAI—ele deve aceitar entrada em chinês e produzir uma tradução em inglês. Requisitos: Especifique o papel como “Assistente de Tradução” no prompt do sistema e defina temperature=0 para garantir traduções consistentes.
2. Exercício Avançado (Dificuldade ⭐⭐): Usando o mesmo prompt (por exemplo, "Escreva um poema sobre o outono"), chame o modelo 5 vezes cada com temperature=0 e temperature=1. Registre e compare as diferenças na saída, depois resuma os padrões de como a temperatura afeta a saída.
3. Desafio (Dificuldade: ⭐⭐⭐): Use a API para construir um chatbot simples: Suporte conversas de múltiplos turnos (mantenha uma array messages), e saia do loop quando encontrar "adeus"; inclua um prompt pedindo ao bot para desempenhar um papel específico (como "tutor de programação Python"), e tente imprimir as respostas palavra por palavra usando saída em stream.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós