Partilhar: Classroom Teams WhatsApp
aulify · Sebenta
UC · Unidade de Competência · UC00623

Inteligência Artificial (UC00623)

ML, deep learning, LLMs e APIs aplicadas
25h · 2.25 pontos crédito Curso: T. Desenv. Software, T. Multimédia e mais 3 cursos ↗ Referencial oficial SNQ
Índice

Há um pacote premium desta unidade: um PowerPoint editável de 100 ou mais diapositivos, um manual em PDF e dois testes com correção. Esta sebenta continua gratuita.

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):

Depois:

Onde IA é usada hoje

Software:

Conteúdo:

Negócio:

Pessoal:

Carreira

Roles:

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

2. Tipos de IA — taxonomia

Por capacidade

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

Por abordagem

Por modalidade

3. Machine Learning fundamentos

Tipos de aprendizagem

Supervised learning (com rótulos):

Unsupervised learning (sem rótulos):

Reinforcement learning:

Semi-supervised, self-supervised: variantes.

Algoritmos clássicos

Algoritmo Tipo Quando usar
Linear Regression Regressão Relação ~linear
Logistic Regression Classificação binária Simples, explicável
Decision Tree Ambos Explicável, dados mistos
Random Forest Ambos Robusto, baseline forte
SVM Classificação Datasets pequenos, high-dim
K-Means Clustering Conhecer K aprox
KNN Classificação Baseline simples
Naive Bayes Classificação texto Spam, sentiment
XGBoost Ambos Competições Kaggle

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):

Pred POS Pred NEG
Real POS TP FN
Real NEG FP TN

Quando usar:

Regressão

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:

Underfitting:

5. Deep Learning — visão geral

Redes neuronais

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

output = activation(W · input + b)

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

Frameworks

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:

Usar API (OpenAI/Anthropic/Hugging Face):

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:

Anthropic:

Google:

Meta (open source):

Mistral (open source):

Capacidades

Limitações

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

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)

Modelo Input Output
GPT-4o-mini 0.15 0.60
GPT-4o 2.50 10.00
GPT-4.5 5.00 20.00
Claude Haiku 0.25 1.25
Claude Sonnet 4.5 3.00 15.00
Claude Opus 4.5 15.00 75.00
Gemini Flash 0.075 0.30

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

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

Casos de uso

Riscos

11. Ética, segurança, limites

Riscos

Bias:

Hallucinations:

Privacy:

Misinfo / deepfakes:

Trabalho:

Best practices em produção

Frameworks emergentes

12. Stack Aulify — exemplo prático

Esta plataforma usa IA em vários sítios:

Stack típico:

13. Próximos passos

Glossário

Recursos

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.

Mais desta unidade
Vê todos os materiais de UC00623: slides, sebenta, fichas, projecto e critérios de avaliação: Abrir a unidade →
Recursos grátis para professores · explorar todos os cursos