Sebenta · Inteligência Artificial (UC00623)

Introdução

Esta UC é uma introdução prática à Inteligência Artificial no estado em que ela está em 2026. Não é um curso académico de matemática — é uma sebenta para quem quer usar IA em produtos e workflows reais: chamar APIs de LLMs, treinar modelos simples com scikit-learn, fazer prompt engineering eficaz, construir agents, e perceber o que está por trás de tudo isto.

O panorama mudou completamente desde 2022. ChatGPT democratizou IA, GPT-4 / Claude / Gemini tornaram-se ferramentas diárias, e APIs baixaram os custos 100x. Hoje qualquer developer pode integrar IA poderosa em produtos — a habilidade chave é saber quando e como, não treinar redes neuronais do zero.

Esta sebenta cobre fundamentos de ML (para perceberes o que se passa), LLMs em profundidade prática (para usares em produção), e considerações éticas (para construires responsavelmente).

1. IA em 2026 — landscape

O que mudou desde 2022

Antes de Nov 2022 (lançamento ChatGPT): - IA era nicho técnico (pesquisadores + grandes labs). - ML clássico dominava aplicações práticas. - LLMs existiam mas pouco acessíveis.

Depois: - IA é tema de café/jornal/CEO. - APIs trivializaram acesso — qualquer dev usa GPT-4 em minutos. - Custos colapsaram — chamadas que custavam $0.10 em 2023 custam $0.001 em 2026. - Modelos open source (Llama, Mistral) competitivos. - AGI debate virou mainstream.

Onde IA é usada hoje

Software: - GitHub Copilot, Cursor, Claude Code: code completion + agents. - Linear, Notion AI: assistentes em ferramentas existentes. - Perplexity, ChatGPT Search, Google AI Overviews: pesquisa redefinida.

Conteúdo: - Copywriting (Jasper, Copy.ai). - Imagens (Midjourney, DALL-E, Stable Diffusion). - Vídeo (Sora, Runway). - Música (Suno, Udio).

Negócio: - Customer support automation. - Análise de contratos (Harvey, legal AI). - Diagnóstico médico (imagem, patologia). - Trading algorítmico.

Pessoal: - Tutoria (Khanmigo). - Tradução. - Recall / memória (notetaking AI).

Carreira

Roles: - AI Engineer: integra APIs em produtos. €40k-€80k PT, $150k+ EUA. - ML Engineer: treina modelos, gere infra. Salários top. - Data Scientist: análise, experimentação. - Prompt Engineer: especializa-se em squeeze max de LLMs. - AI Researcher: cria nova IA (PhD typically). - AI Product Manager: gere produtos com IA.

Esta UC: foco em AI Engineer (usar APIs, integrar em produtos).

2. Tipos de IA — taxonomia

Por capacidade

• Narrow AI (estamos aqui): especializada numa tarefa (jogar xadrez, traduzir).
• AGI (futuro?): humano-level em qualquer tarefa cognitiva.
• ASI (especulativo): super-humano em tudo.

GPT-4/Claude são narrow mas muito largos — bons em milhares de tarefas.

Por abordagem

• Symbolic AI: regras explícitas (sistemas peritos, Prolog). Vintage mas ainda em alguns nichos.
• Statistical ML: aprende padrões de dados. Random forests, SVM, etc.
• Deep Learning: redes neuronais profundas. Domina visão, voz, NLP.
• LLMs: transformers treinados em texto. Sub-categoria de deep learning.
• Hybrid: combinações.

Por modalidade

• Texto (LLMs).
• Imagem (visão computacional, generative).
• Áudio (speech-to-text, music gen).
• Vídeo (Sora).
• Multimodal: aceita várias (GPT-4o, Claude 4, Gemini).

3. Machine Learning fundamentos

Tipos de aprendizagem

Supervised learning (com rótulos): - Tens pairs (input, output_esperado). - Modelo aprende a mapear. - Sub-tipos: - Classificação: output é categoria (spam/não-spam, cão/gato/pássaro). - Regressão: output é número (preço, temperatura).

Unsupervised learning (sem rótulos): - Só inputs, descobre estrutura. - Sub-tipos: - Clustering: agrupa similares (K-Means). - Dimensionality reduction: comprime dados (PCA, t-SNE). - Anomaly detection.

Reinforcement learning: - Agent aprende por tentativa/erro. - Recebe rewards. - Jogos (AlphaGo), robótica, optimização.

Semi-supervised, self-supervised: variantes.

Algoritmos clássicos

Em Python: scikit-learn implementa tudo com API consistente.

Workflow ML típico

1. Recolher dados.
2. Explorar (EDA): histograms, correlations, missing values.
3. Preprocessar: clean, encode categóricas, normalize.
4. Split: train/validation/test.
5. Treinar modelo.
6. Avaliar em validation.
7. Tune hyperparameters.
8. Avaliar final em test.
9. Deploy em produção.

Exemplo prático: classificar spam

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Dados (exemplo)
df = pd.read_csv("emails.csv")  # colunas: text, label (0/1)

# Split
X_train, X_test, y_train, y_test = train_test_split(
    df["text"], df["label"], test_size=0.2, random_state=42
)

# Features (texto → vectores)
vec = TfidfVectorizer(max_features=5000, stop_words="english")
X_train_vec = vec.fit_transform(X_train)
X_test_vec = vec.transform(X_test)

# Train
model = MultinomialNB()
model.fit(X_train_vec, y_train)

# Eval
predictions = model.predict(X_test_vec)
print(classification_report(y_test, predictions))

Output típico:

              precision    recall  f1-score   support
           0       0.97      0.99      0.98       747
           1       0.95      0.84      0.89       121
    accuracy                           0.97       868

4. Métricas

Classificação

Confusion matrix (binário):

• Accuracy = (TP+TN) / total — overall correctness.
• Precision = TP / (TP+FP) — quão fiáveis são os YES preditos.
• Recall = TP / (TP+FN) — quantos YES reais encontro.
• F1 = 2·P·R / (P+R) — média harmónica.

Quando usar: - Datasets balanceados → accuracy ok. - Desbalanceados (1% spam, 99% ham) → accuracy enganadora. Usar precision/recall/F1. - Custo de FP vs FN diferente: tune threshold.

Regressão

• MSE (Mean Squared Error): média de (y - ŷ)².
• RMSE: raiz de MSE — mesma unidade que y.
• MAE: média de |y - ŷ| — menos sensível a outliers.
• R²: variância explicada (0-1, mais alto = melhor).

Train/val/test split

Dataset
├── Train (70-80%): treina modelo
├── Validation (10-15%): tune hyperparams, model selection
└── Test (10-15%): avaliação final — NÃO TOCAR!

Cross-validation (K-fold): divide train em K subsets, treina K vezes. Mais robusto que single split.

Overfitting vs Underfitting

Overfitting: - Modelo decora training data. - Training acc >> validation acc. - Fixes: mais dados, regularização (L1/L2), dropout, early stopping, modelo mais simples.

Underfitting: - Modelo demasiado simples. - Training acc baixa. - Fixes: modelo mais complexo, mais features, treino mais longo.

5. Deep Learning — visão geral

Redes neuronais

Inspiradas (loosely) em neurónios biológicos. Cada "neurónio" calcula:

output = activation(W · input + b)

• W: weights (aprendidos).
• b: bias (aprendido).
• activation: ReLU, sigmoid, tanh, softmax.

Rede = muitos neurónios em camadas. Deep = muitas camadas.

Training

1. Forward pass: input → output (predição).
2. Loss: compara output com label real (ex: cross-entropy).
3. Backward pass (backpropagation): calcula gradients.
4. Update weights: gradient descent.

Repete milhares/milhões de vezes em batches de dados.

Tipos de arquitecturas

• MLP (Multi-Layer Perceptron): fully connected, base.
• CNN (Convolutional): imagens. ResNet, VGG.
• RNN / LSTM: séries temporais (largely substituídas por transformers).
• Transformer: attention-based, hoje em tudo (NLP, visão, áudio).
• GAN: gera imagens (generator + discriminator competem).
• Diffusion: state-of-the-art em geração de imagens (DALL-E 3, Stable Diffusion).

Frameworks

• PyTorch (Facebook/Meta): dominante em pesquisa.
• TensorFlow / Keras (Google): grande em produção.
• JAX: emergente, Google.

Exemplo PyTorch (MLP para MNIST)

import torch
import torch.nn as nn
import torch.optim as optim

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)            # flatten
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = MLP()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    for X, y in train_loader:
        optimizer.zero_grad()
        output = model(X)
        loss = criterion(output, y)
        loss.backward()
        optimizer.step()

Quando treinar próprio vs usar API

Treinar próprio: - Dados muito específicos (medical scans). - Sem internet (embedded). - Latência crítica. - Custo escala demasiado com API.

Usar API (OpenAI/Anthropic/Hugging Face): - Maioria dos casos. - Time to market. - Sem expertise ML interna. - Modelos genéricos chegam.

6. LLMs — Large Language Models

Como funcionam (intuição)

LLMs são transformers treinados a prever o próximo token dado contexto anterior. Quando vês o LLM "raciocinar", está apenas a prever tokens — mas o padrão emerge de treino em triliões de tokens.

Token = pedaço de palavra. ~4 chars em inglês. "computer" = 1 token; "anthropomorphic" = 4 tokens.

Treino em 3 fases

1. Pretraining: trillions de tokens da web. Aprende linguagem + factos.
2. Instruction tuning: dados (instruction → resposta). Aprende a responder.
3. RLHF (Reinforcement Learning from Human Feedback): humanos preferem A vs B. Modelo aprende a ser útil/seguro.

Modelos principais em 2026

OpenAI: - GPT-4o — generalista flagship. - GPT-4o-mini — barato, muito capaz. - GPT-4.5/5 (latest). - o1, o3 — modelos com "reasoning" (pensam mais antes de responder).

Anthropic: - Claude Opus 4.5 — flagship. - Claude Sonnet 4.5 — equilibrado, popular para code. - Claude Haiku — rápido, barato.

Google: - Gemini 2 Pro / Flash — contextos enormes (1M+ tokens).

Meta (open source): - Llama 4 — competitivo, gratuito.

Mistral (open source): - Mistral Large / Mixtral — francês, open.

Capacidades

• Conversação fluente.
• Resumir documentos longos.
• Traduzir.
• Code (write, debug, explain).
• Análise (legal, médica, financeira) com supervisão.
• Reasoning (lógica básica, matemática limitada).
• Creative writing.
• Multimodal: ver imagens (GPT-4V, Claude 4), ouvir áudio.

Limitações

• Hallucinations: inventa factos com confiança.
• Conhecimento desactualizado: cutoff date.
• Maths: erros em cálculos.
• Reasoning fraco em problemas novos.
• Bias: reflecte dados de treino.
• Sem memória entre conversas (sem context window).
• Custo ainda significativo a escala.

7. Prompt engineering

A skill mais crítica para AI engineers.

Princípios fundamentais

1. Específico > vago.
2. Contexto ajuda muito.
3. Exemplos (few-shot) batem zero-shot.
4. Estrutura o output (JSON, markdown, bullets).
5. Decompõe tasks complexas em passos.
6. Itera: prompts iniciais raramente são óptimos.

Exemplos

Vago:

Escreve sobre IA.

Específico:

Escreve um artigo de blog de 500 palavras sobre como
LLMs ajudam pequenas empresas. Audiência: empresários
sem background técnico. Tom: prático, optimista.
Estrutura:
- Intro (50w)
- 3 casos de uso (100w cada)
- Call-to-action final (50w)

Role / system prompt

messages = [
    {"role": "system", "content": """
És um expert em SEO com 10+ anos de experiência.
Respondes de forma concisa, com exemplos práticos.
Quando não sabes, dizes "não sei".
    """},
    {"role": "user", "content": "Como melhorar ranking?"}
]

Few-shot

Dá exemplos no prompt:

Classifica reviews como POSITIVO/NEGATIVO/NEUTRO.

Review: "Adorei, recomendo!" → POSITIVO
Review: "Péssimo, não voltarei" → NEGATIVO
Review: "Normal, nada de especial" → NEUTRO
Review: "Esperava melhor" → NEGATIVO
Review: "Foi ok pelo preço" → NEUTRO

Review: "Foi uma experiência transformadora!" →

Chain-of-thought (CoT)

Para reasoning, pede explicação passo-a-passo:

Problema: Uma loja vende camisas a 25€. Em saldos
têm 30% desconto. Se compro 4, quanto pago?

Pensa passo a passo:
1. Preço original = 25€
2. Desconto = 25 * 0.30 = 7.50€
3. Preço com desconto = 25 - 7.50 = 17.50€
4. Total para 4 = 17.50 * 4 = 70€

Resposta: 70€.

LLMs respondem melhor com CoT em problemas multi-passo.

Output estruturado

Extrai dados deste texto e retorna como JSON:

Texto: "João Silva tem 35 anos, é engenheiro, vive em Lisboa."

Formato JSON:
{
  "nome": "...",
  "idade": ...,
  "profissão": "...",
  "cidade": "..."
}

Ou usar JSON mode / structured outputs da API.

Anti-patterns

• "Faz o melhor possível" — vago.
• Não dar contexto suficiente.
• Esperar perfeição numa primeira tentativa.
• Não testar em casos edge.

8. Usar APIs

OpenAI

pip install openai
export OPENAI_API_KEY="sk-..."

from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "És um assistente útil."},
        {"role": "user", "content": "Capital de Portugal?"}
    ],
    temperature=0.7,    # 0 = determinístico, 1 = criativo
    max_tokens=500,
)

print(response.choices[0].message.content)
print(f"Cost: ${response.usage.total_tokens * 0.0000001:.6f}")

Anthropic Claude

pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

import anthropic
client = anthropic.Anthropic()

msg = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explica recursão"}
    ]
)
print(msg.content[0].text)

Custos típicos (2026, $/1M tokens)

Default: mini/flash models. Usa Opus/GPT-4.5 só quando justificas a complexidade.

Streaming

Para UI responsiva:

stream = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Conta-me uma história"}],
    stream=True,
)

for event in stream:
    if event.type == "content_block_delta":
        print(event.delta.text, end="", flush=True)

Function / tool calling

LLM decide chamar funções tuas:

tools = [{
    "name": "get_weather",
    "description": "Obter tempo numa cidade",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string"}
        },
        "required": ["city"]
    }
}]

msg = client.messages.create(
    model="claude-opus-4-5",
    tools=tools,
    messages=[{"role": "user", "content": "Como está Lisboa?"}]
)

if msg.stop_reason == "tool_use":
    tool_call = msg.content[0]
    # Chama a tua função
    result = get_weather(tool_call.input["city"])
    # Continua conversa com o resultado...

9. RAG — Retrieval Augmented Generation

Problema

LLMs não conhecem teus dados (manual interno, knowledge base, código privado).

Solução: RAG

1. Documentos → chunks → embeddings → vector DB.
2. Query do user → embedding → search no vector DB.
3. Top K chunks → prompt + query → LLM gera resposta.

Stack RAG típico

• Embeddings: OpenAI text-embedding-3-small ou modelos open source.
• Vector DB: Pinecone, Weaviate, Qdrant, Chroma (local).
• LLM: qualquer (Claude, GPT, etc.).
• Orchestration: LangChain, LlamaIndex.

Exemplo simples com Chroma

import chromadb
from openai import OpenAI

client = OpenAI()
chroma = chromadb.Client()
collection = chroma.create_collection("docs")

# Index docs
docs = ["Doc sobre Python...", "Doc sobre Java..."]
embeddings = [
    client.embeddings.create(model="text-embedding-3-small", input=d).data[0].embedding
    for d in docs
]
collection.add(documents=docs, embeddings=embeddings, ids=["d1", "d2"])

# Query
query = "O que é list comprehension?"
query_emb = client.embeddings.create(
    model="text-embedding-3-small", input=query
).data[0].embedding

results = collection.query(query_embeddings=[query_emb], n_results=2)
context = "\n".join(results["documents"][0])

# Gerar resposta com contexto
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": f"Responde com base em:\n{context}"},
        {"role": "user", "content": query}
    ]
)
print(response.choices[0].message.content)

10. Agents

LLMs com tools = agents. Podem chamar APIs, executar código, navegar web.

Conceito

Loop:
    1. LLM recebe goal + tools disponíveis.
    2. LLM decide acção (qual tool, com que params).
    3. Sistema executa tool.
    4. Resultado volta ao LLM.
    5. LLM decide próxima acção (até cumprir goal).

Frameworks

• Claude tools (Anthropic SDK).
• OpenAI function calling.
• LangChain Agents.
• LlamaIndex.
• CrewAI (multi-agent).
• AutoGen (Microsoft, multi-agent).

Casos de uso

• Assistente que pesquisa web + resume.
• DevOps bot que executa comandos shell.
• Customer support que consulta BD + responde.
• Code review automation.

Riscos

• Loops infinitos (max_iterations!).
• Tool misuse (LLM decide errado).
• Custo escala rapidamente (cada chamada = tokens).
• Security: cuidado com tools que executam código/SQL.

11. Ética, segurança, limites

Riscos

Bias: - Modelos treinados em dados enviesados → reproduzem estereótipos. - Particular em género, raça, género, idade.

Hallucinations: - Modelo inventa factos com confiança absoluta. - Citações falsas, datas erradas, leis inexistentes. - Sempre verificar info crítica.

Privacy: - Prompts/dados enviados para API saem da tua rede. - GDPR: cuidado com dados pessoais. - Soluções: redacção, on-prem models (Llama, Mistral self-hosted).

Misinfo / deepfakes: - Texto convincente falso, fácil de gerar. - Vídeos sintéticos. - Implicações políticas, jurídicas.

Trabalho: - Translation, copywriting, support, low-level code → automatizáveis. - Humanos mudam para roles de supervisão/criatividade/julgamento.

Best practices em produção

• Não deployar sem human-in-the-loop para decisões críticas.
• Validar outputs (parse JSON, check ranges).
• Rate limits + cost monitoring.
• Logs para debug e compliance.
• Disclaimers ao utilizador ("este conteúdo é gerado por IA").
• A/B testing vs baseline humano.
• Red teaming: tentar fazer o sistema falhar.
• Fallbacks: se LLM falha, comportamento sensato.

Frameworks emergentes

• EU AI Act (em vigor 2026): regulação categorizando IA por risco.
• NIST AI Risk Management Framework.
• Privacy reviews obrigatórios em muitas empresas.

12. Stack Aulify — exemplo prático

Esta plataforma usa IA em vários sítios: - Geração de conteúdos pedagógicos. - Sugestões em assistente do professor. - Resumos automáticos.

Stack típico: - Claude Opus 4.5 para geração de conteúdo longo. - GPT-4o-mini para classificação leve. - OpenAI embeddings + Chroma para search semantic. - Python backend (FastAPI). - Streaming para UX responsiva.

13. Próximos passos

• Fine-tuning de modelos open source (Hugging Face).
• Vector DBs em escala (Pinecone, Weaviate prod).
• Agentic frameworks profundamente (LangGraph, CrewAI).
• Multimodal (input imagem/áudio).
• Local LLMs (Ollama, llama.cpp).
• Eval frameworks (Braintrust, LangSmith).
• AI safety + interpretability.

Glossário

• LLM: Large Language Model (GPT, Claude, etc.).
• Token: unidade básica de texto (~4 chars).
• Prompt: input que dás ao LLM.
• Context window: máximo de tokens que o LLM "lê".
• Temperature: aleatoriedade da resposta (0-2).
• Hallucination: LLM inventa info falsa.
• RAG: Retrieval Augmented Generation.
• Embedding: representação vectorial de texto.
• Vector DB: BD optimizada para similaridade.
• Agent: LLM + tools que age autonomamente.
• Fine-tuning: re-treinar modelo com dados teus.
• Few-shot: dar exemplos no prompt.
• CoT: Chain-of-Thought.
• RLHF: Reinforcement Learning from Human Feedback.

Recursos

• OpenAI docs: platform.openai.com/docs.
• Anthropic docs: docs.anthropic.com.
• Hugging Face: huggingface.co (open models, datasets).
• DeepLearning.AI (Andrew Ng) — cursos.
• Fast.ai — practical deep learning.
• Papers with code — research + implementations.
• Latent Space podcast — AI news.

IA mudou tudo em 3 anos. Vai mudar tudo de novo nos próximos 3. Aprender os fundamentos é importante — mas mais ainda é construir coisas. Cada projecto ensina mais que 10 horas de teoria. Faz um chatbot, um RAG sobre os teus apontamentos, um agent que automatize uma task tua. É assim que se aprende IA hoje.