Bloco 1 · IA hoje

O que mudou desde 2022

• ChatGPT (Nov 2022) democratizou IA.
• GPT-4, Claude, Gemini: capazes de tarefas complexas.
• APIs acessíveis a qualquer dev.
• Custos baixaram 100x em 3 anos.
• Open source (Llama, Mistral) competitivo.

IA deixou de ser nicho académico → ferramenta diária.

Onde se usa IA

• Code: GitHub Copilot, Cursor, Claude Code.
• Conteúdo: copywriting, imagens (Midjourney), vídeo (Sora).
• Search: Perplexity, Google AI Overviews.
• Customer support: chatbots competentes.
• Análise: dados, contratos, código.
• Education: tutoria personalizada.
• Medicina: diagnóstico de imagem, descoberta de fármacos.

Carreira em IA

Roles:

• AI Engineer: usa APIs (OpenAI, etc.) em produtos.
• ML Engineer: treina modelos próprios.
• Data Scientist: análise + experimentação.
• Prompt engineer: optimiza prompts.
• Research scientist: cria nova IA.

Salários: AI Engineer €40k-€80k em PT, $150k+ EUA.

Bloco 2 · Tipos de IA

Categorias

• Narrow AI (hoje): especializada numa tarefa.
• AGI (futuro?): igual a humano em qualquer tarefa.
• ASI (especulativo): super-humano em tudo.

Esta UC: narrow AI atual + introdução a LLMs.

Abordagens

• Symbolic: regras explícitas (Prolog, sistemas peritos). Velho mas ainda usado.
• Statistical/ML: aprende de dados (random forests, SVM).
• Deep Learning: redes neuronais profundas (visão, voz).
• LLMs: transformers gigantes treinados em texto.
• Hybrid: combinação.

Bloco 3 · Machine Learning

Tipos de aprendizagem

• Supervised: dados rotulados (input → output esperado).

  • Classificação (spam/não-spam).
  • Regressão (preço da casa).

• Unsupervised: sem rótulos.

  • Clustering (agrupar clientes).
  • Dimensionality reduction.

• Reinforcement: aprende por tentativa e erro.

  • Jogos, robótica.

Algoritmos clássicos

• Linear Regression: preço ~ tamanho.
• Logistic Regression: classificação binária.
• Decision Trees / Random Forest: explicável.
• SVM: poderoso para data baixa-dim.
• K-Means: clustering.
• KNN: classificação por vizinhos.

Em Python: scikit-learn implementa tudo.

Exemplo: classificar emails

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split

emails = [...]      # textos
labels = [...]      # 0=ham, 1=spam

X_train, X_test, y_train, y_test = train_test_split(emails, labels)

vec = TfidfVectorizer()
X_train_vec = vec.fit_transform(X_train)
X_test_vec = vec.transform(X_test)

model = MultinomialNB()
model.fit(X_train_vec, y_train)
acc = model.score(X_test_vec, y_test)
print(f"Accuracy: {acc:.2%}")

Bloco 4 · Métricas

Classificação

• Accuracy: (TP+TN) / total — global.
• Precision: TP / (TP+FP) — quão correctas as YES previstas?
• Recall: TP / (TP+FN) — quantas YES reais apanhei?
• F1: média harmónica precision/recall.

Train/validation/test

Dataset completo
├── Train (70-80%): treinar modelo
├── Validation (10-15%): tunning hyperparâmetros
└── Test (10-15%): avaliação final (não tocar!)

NUNCA ajustar com base no test set → vais ter overfitting que não percebes.

Overfitting

• Modelo decora training data, falha em novos dados.
• Sintomas: training accuracy >> validation accuracy.
• Soluções:
  • Mais dados.
  • Regularização (L1, L2, dropout).
  • Cross-validation.
  • Early stopping.

Bloco 5 · Deep Learning

Redes neuronais

Input → [Hidden layer 1] → [Hidden 2] → ... → Output

Cada "neurónio" calcula output = activation(W·input + b).

Aprende-se W e b via backpropagation + gradient descent.

Deep = muitas hidden layers.

Tipos de redes

• CNN (Convolutional): imagens.
• RNN/LSTM: séries temporais (legacy).
• Transformer: NLP, agora tudo.
• GAN: gerar imagens.
• Diffusion: state-of-the-art em imagens (DALL-E, Stable Diffusion).

Framework popular: PyTorch

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

model = Net()
# treino com loss + optimizer ...

Bloco 6 · LLMs

Como funcionam (intuição)

• Transformer architecture.
• Treinados a prever próximo token em corpus massivo.
• Aprendem padrões linguísticos, raciocínio, conhecimento.
• Tamanho: GPT-4 ~1.8T parâmetros (estimado).

Token = pedaço de palavra (~4 chars em inglês).

Modelos principais 2026

• GPT-4 / GPT-4o (OpenAI) — generalista.
• Claude 4 Opus / Sonnet (Anthropic) — escrita, código.
• Gemini 2 (Google) — multimodal, contexto enorme.
• Llama 4 (Meta) — open source.
• Mistral / Mixtral — open source competitivo.

Capabilities

• Chat / conversação.
• Resumir textos longos.
• Traduzir.
• Code generation (writing + debug).
• Análise de documentos.
• Reasoning (limitado mas surpreendente).
• Multimodal: imagens, áudio, vídeo input.

Limitações: hallucination (inventar factos), conhecimento desactualizado (cutoff).

Bloco 7 · Prompt engineering

Princípios

1. Específico vence vago.
2. Contexto ajuda.
3. Exemplos (few-shot) > zero-shot.
4. Estrutura o output.
5. Step-by-step para tasks complexas.

Bad prompt

Escreve algo sobre IA.

Good prompt

Escreve um artigo de blog de 500 palavras sobre como
LLMs podem ajudar pequenas empresas. Audiência:
empresários sem background técnico. Tom: prático e
optimista. Estrutura: intro + 3 casos de uso + CTA.

Few-shot

Classifica o sentimento como POSITIVO, NEGATIVO ou NEUTRO.

Texto: "Adorei o filme!" → POSITIVO
Texto: "Foi aborrecido" → NEGATIVO
Texto: "Foi normal" → NEUTRO

Texto: "Não voltarei lá" →

Chain-of-thought

Pergunta: Se um carro percorre 60km em 1h, quanto demora
para percorrer 150km à mesma velocidade?

Pensa passo a passo:
1. Velocidade: 60 km/h.
2. Tempo = distância / velocidade.
3. Tempo = 150 / 60 = 2.5 horas.

Resposta: 2 horas e 30 minutos.

Bloco 8 · APIs

OpenAI API

from openai import OpenAI

client = OpenAI(api_key="sk-...")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "És um assistente útil."},
        {"role": "user", "content": "Capital de Portugal?"}
    ]
)
print(response.choices[0].message.content)

Custo: $0.15 / 1M input tokens (gpt-4o-mini).

Anthropic Claude

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-...")

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)

Mini/Flash models = baratíssimos. Use-os por defeito.

Bloco 9 · RAG e Agents

RAG — Retrieval Augmented Generation

Pergunta → Vector search → Encontrar docs relevantes
                    ↓
                  Prompt (pergunta + docs)
                    ↓
                  LLM gera resposta

Resolve: LLMs não sabem teus dados. RAG = juntar busca + LLM.

Stack: Pinecone/Chroma/Qdrant (vector DB) + OpenAI Embeddings + LLM.

Agents

LLM com tools (capacidade de chamar funções):

def get_weather(city: str) -> str:
    # API real
    return "20°C, sol"

# LLM decide quando chamar:
# User: "Tempo em Lisboa?"
# LLM: get_weather("Lisbon")
# LLM: "Está 20°C em Lisboa, com sol."

Frameworks: Anthropic Claude tools, OpenAI function calling, LangChain, LlamaIndex.

Bloco 10 · Ética e limites

Riscos

• Bias: modelos perpetuam preconceitos dos dados.
• Hallucinations: factos errados convincentes.
• Privacy: dados de utilizadores em prompts.
• Trabalho: substituição de jobs (writing, support).
• Desinformação: deepfakes, conteúdo falso.
• Concentração de poder: poucos labs dominam.

Best practices em produção

• Sempre validar outputs antes de mostrar.
• Não confiar para decisões críticas sem human review.
• Rate limits e cost controls.
• Logs para debug.
• Disclaimers ao utilizador (é IA, pode errar).
• GDPR: cuidado com dados pessoais em prompts.