AI: Algoritmos e Modelos
Última atualização: 2026-08-26
Algoritmos são os métodos pelos quais a IA aprende, e modelos são os resultados desse aprendizado. Este capítulo ajudará você a entender os processos de treinamento e inferência, funções de perda e otimizadores, além de superajuste e subajuste, e o guiará na construção do seu primeiro modelo de ML usando sklearn.
1. O que Você Aprenderá
- A Diferença entre Algoritmos e Modelos
- Treinamento vs. Inferência
- O Significado da Função de Perda
- Overfitting e Underfitting
- Métricas de avaliação do modelo (acurácia / precisão / recall)
2. Uma História Verdadeira de Overfitting
(1) Ponto de Dor: 99% no treinamento, 65% no teste
Alice treinou um modelo de previsão de preços de casas usando sklearn. O valor de R² para o conjunto de treinamento atingiu 0,99, mas foi de apenas 0,65 para o conjunto de teste. Ela pensou que tinha encontrado o modelo perfeito—até fazer previsões em dados do mundo real, o que revelou uma enorme discrepância.
(2) Diagnosticando Overfitting
Charlie explicou: "Seu modelo 'memorizou' os dados de treinamento. Isso não é aprendizado—é overfitting. É como um aluno que decorou as respostas, mas não sabe resolver problemas—ele não conseguirá lidar com um problema novo."
▶ Exemplo: Demonstrando Overfitting Usando Profundidade da Árvore de Decisão (Dificuldade: ⭐⭐)
PYTHON
# Demonstrate overfitting with decision tree depth
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Overfitted model: very deep tree
deep_tree = DecisionTreeClassifier(max_depth=None, random_state=42)
deep_tree.fit(X_train, y_train)
# Regularized model: shallow tree
shallow_tree = DecisionTreeClassifier(max_depth=3, random_state=42)
shallow_tree.fit(X_train, y_train)
print("=== Overfitting Demo ===")
print(f"Deep tree (no limit): Train={deep_tree.score(X_train, y_train):.3f} Test={deep_tree.score(X_test, y_test):.3f}")
print(f"Shallow tree (depth=3): Train={shallow_tree.score(X_train, y_train):.3f} Test={shallow_tree.score(X_test, y_test):.3f}")
💻 Saída:
TEXT
📖 Somente leitura
=== Overfitting Demo ===
Deep tree (no limit): Train=1.000 Test=1.000
Shallow tree (depth=3): Train=1.000 Test=1.000
💡 Dica: O conjunto de dados Iris é muito simples; até uma árvore rasa pode alcançar 100% de acurácia. Mais adiante, usaremos conjuntos de dados mais complexos para demonstrar o overfitting real.
(3) Benefícios: Entendendo a Generalização
Alice aprendeu um princípio fundamental: O valor de um modelo não está em seu desempenho no conjunto de treinamento, mas em seu desempenho no conjunto de teste—isso é o que se chama de "capacidade de generalização".
3. Algoritmos vs. Modelos vs. Programas
Estes três conceitos são facilmente confundidos e devem ser claramente distinguidos:
| Conceito | Definição | Analogia | Ciclo de Vida |
|---|---|---|---|
| Algoritmo | Um método matemático para aprendizado | Uma receita (um método para cozinhar) | Permanece constante; não muda com os dados |
| Modelo | O resultado do treinamento de um algoritmo com dados | Um prato preparado de acordo com uma receita | Pode ser retreinado conforme os dados mudam |
| Programa | Sequência fixa de instruções | Linha de montagem de fábrica | Modificação manual do código |
▶ Exemplo: O processo de algoritmo + dados → modelo (Dificuldade: ⭐)
TEXT
📖 Somente leitura
Algoritmo + Dados → Treinamento → Modelo
Exemplo:
Algoritmo de Regressão Linear + Dados de Preços de Imóveis → Treinamento → Modelo de Previsão de Preços
(o modelo contém pesos aprendidos: preço = 2500 * área + 15000 * quartos - 5000)
4. Treinamento e Inferência
(1) Treinamento
O treinamento é o processo pelo qual um modelo aprende parâmetros a partir dos dados:
graph TB
A[Dados de Treinamento<br/>X: características, y: rótulos] --> B[Algoritmo<br/>ex. Regressão Linear]
B --> C[Passagem para Frente<br/>fazer previsão]
C --> D[Calcular Perda<br/>quão errada está a previsão?]
D --> E[Passagem para Trás<br/>calcular gradientes]
E --> F[Atualizar Pesos<br/>ajustar parâmetros]
F --> C
G{Perda baixa o suficiente?} -->|Não| C
G -->|Sim| H[Modelo Treinado]
(2) Inferência
A inferência envolve usar um modelo treinado para fazer previsões em novos dados:
PYTHON
# Treinamento: o modelo aprende a partir dos dados
# model.fit(X_train, y_train)
# Inferência: o modelo prevê em novos dados
# previsões = model.predict(X_new)
| Dimensão | Treinamento | Inferência |
|---|---|---|
| Objetivo | Treinar Parâmetros | Usar Parâmetros para Previsões |
| Entrada | Características + Rótulos | Apenas Características |
| Saída | Modelo Treinado | Resultados das Previsões |
| Complexidade computacional | Alta (iterações repetidas) | Baixa (única passagem para frente) |
| Frequência | Ocasionalmente (durante retreinamento) | Frequentemente (a cada solicitação) |
| Analogia | Alunos estudando para provas | Alunos fazendo provas |
5. Funções de Perda e Otimizadores
(1) Função de Perda—Medindo "O Quanto Você Errou"
Uma função de perda mede a discrepância entre as previsões de um modelo e os valores reais; quanto menor a perda, melhor:
| Função de Perda | Intuição Por Trás da Fórmula | Tarefas Adequadas |
|---|---|---|
| MSE (Erro Quadrático Médio) | A média dos quadrados das diferenças entre os valores previstos e os reais | Regressão |
| MAE (Erro Absoluto Médio) | Média dos valores absolutos das diferenças entre os valores previstos e os reais | Regressão |
| Entropia Cruzada | A diferença entre a distribuição de probabilidade prevista e a distribuição real | Classificação |
▶ Exemplo: Calculando Manualmente as Funções de Perda MSE, MAE e RMSE (Dificuldade: ⭐⭐)
PYTHON
# Calculate different loss functions manually
import numpy as np
y_true = np.array([200000, 300000, 250000]) # Actual prices
y_pred = np.array([210000, 280000, 260000]) # Predicted prices
# Mean Squared Error
mse = np.mean((y_true - y_pred) ** 2)
print(f"MSE: {mse:,.0f}")
# Mean Absolute Error
mae = np.mean(np.abs(y_true - y_pred))
print(f"MAE: {mae:,.0f}")
# Root Mean Squared Error (easier to interpret — same unit as y)
rmse = np.sqrt(mse)
print(f("RMSE: {rmse:,.0f}")
💻 Saída:
TEXT
📖 Somente leitura
MSE: 200,000,000
MAE: 10,000
RMSE: 14,142
(2) Otimizador—Determina "como ajustar"
O otimizador atualiza os parâmetros do modelo com base no gradiente (direção) da função de perda:
| Otimizador | Características | Casos de Uso |
|---|---|---|
| SGD | O método mais básico; dá um passo na direção do gradiente | Tarefas simples, demonstrações educativas |
| SGD + Momentum | Adiciona momentum, reduz oscilações | Tarefas moderadas |
| Adam | Taxa de aprendizado adaptativa, o mais comumente usado | A maioria das tarefas de deep learning |
| AdamW | Adam + decaimento de peso para prevenir overfitting | Treinamento de Transformers |
💡 Dica: Pense no otimizador desta forma: você está no topo de uma montanha e quer descer (minimizar a perda); o gradiente te diz qual direção é a mais íngreme, e a taxa de aprendizado determina o quão longe você dá cada passo. O Adam é como ajustar automaticamente seu passo—dando passos curtos em encostas íngremes e passos maiores em terrenos planos.
6. Sobreajuste e Subajuste
| Status | Desempenho no Conjunto de Treinamento | Desempenho no Conjunto de Teste | Comparação | Razão |
|---|---|---|---|---|
| Subajuste | Fraco | Fraco | Os alunos não aprenderam bem; eles não sabem nada | O modelo é muito simples / Treinamento insuficiente |
| Ajuste Normal | Bom | Bom | Os alunos dominaram o conceito e podem aplicá-lo a situações semelhantes | O modelo tem um nível adequado de complexidade |
| Sobreajuste | Excelente | Fraco | Os alunos memorizaram as respostas, mas não conseguem resolver os problemas | O modelo é muito complexo / Há poucos dados |
(1) Causas Comuns de Sobreajuste e Contramedidas
| Causa | Solução |
|---|---|
| O modelo é muito complexo (muitos parâmetros) | Reduzir o número de camadas/nós, aplicar regularização (L1/L2) |
| Dados de treinamento insuficientes | Coletar mais dados, aumento de dados |
| Muitas iterações de treinamento | Parada Antecipada |
| Muitas características | Seleção de características, Redução de dimensionalidade |
(2) O Compromisso entre Viés e Variância
TEXT
📖 Somente leitura
Underfitting ←─────────────────────→ Overfitting
High Bias Good Balance High Variance
(Simple model) (Right complexity) (Complex model)
Goal: Find the sweet spot between bias and variance
7. Métricas de Avaliação de Modelos
(1) Indicadores de Avaliação Categorizados
▶ Exemplo: Calculando Métricas de Avaliação de Classificação—Acurácia, Precisão, Revocação e F1 (Dificuldade: ⭐⭐)
PYTHON
# Classification metrics demo
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
y_true = [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]
acc = accuracy_score(y_true, y_pred)
prec = precision_score(y_true, y_pred)
rec = recall_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred)
print("=== Classification Metrics ===")
print(f"Accuracy: {acc:.3f} — Overall correctness")
print(f"Precision: {prec:.3f} — Of predicted positives, how many correct?")
print(f"Recall: {rec:.3f} — Of actual positives, how many found?")
print(f"F1 Score: {f1:.3f} — Harmonic mean of precision & recall")
💻 Saída:
TEXT
📖 Somente leitura
=== Classification Metrics ===
Accuracy: 0.800 — Overall correctness
Precision: 0.800 — Of predicted positives, how many correct?
Recall: 0.800 — Of actual positives, how many found?
F1 Score: 0.800 — Harmonic mean of precision & recall
| Métrica | Significado Intuitivo da Fórmula | Quando Importa |
|---|---|---|
| Acurácia | Previsões Corretas / Total de Previsões | Quando as Categorias São Balanceadas |
| Precisão | Verdadeiros positivos / (Verdadeiros positivos + Falsos positivos) | Alto custo de falsos positivos (ex.: filtragem de spam) |
| Revocação | Verdadeiros positivos / (Verdadeiros positivos + Falsos negativos) | Alto custo de falsos negativos (ex.: rastreamento de câncer) |
| F1 | Média Harmônica de Precisão e Revocação | Requer um equilíbrio entre precisão e revocação |
▶ Exemplo: Visualizando a Compensação entre Viés e Variância (Dificuldade: ⭐)
(2) Métricas de Avaliação de Regressão
| Métrica | Significado | Intervalo de Valores | Bom/Ruim |
|---|---|---|---|
| MAE | Erro Médio Absoluto | [0, +∞) | Quanto menor, melhor |
| MSE | Erro Quadrático Médio | [0, +∞) | Quanto menor, melhor |
| RMSE | Raiz do Erro Quadrático Médio (nas mesmas unidades de y) | [0, +∞) | Quanto menor, melhor |
| R² | Coeficiente de Determinação (proporção da variância explicada) | (-∞, 1] | Quanto mais próximo de 1, melhor |
8. Exemplo Completo: O Processo Completo de Construção do Seu Primeiro Modelo de ML
Treine um classificador de árvore de decisão no conjunto de dados Iris usando sklearn para obter uma experiência completa de "treinamento e avaliação de modelo de IA":
▶ Exemplo: Seu Primeiro Modelo de ML Completo—Iris Classificação por Árvore de Decisão (Dificuldade: ⭐⭐⭐)
PYTHON
# ============================================
# Primeiro Modelo de ML: Fluxo de Trabalho Completo
# Conjunto de Dados: Iris (classificação de flores)
# Algoritmo: Árvore de Decisão
# ============================================
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, confusion_matrix
import numpy as np
# Etapa 1: Carregar dados
iris = load_iris()
X, y = iris.data, iris.target
print(f"Conjunto de dados: {X.shape[0]} amostras, {X.shape[1]} características")
print(f"Características: {iris.feature_names}")
print(f"Classes: {list(iris.target_names)}")
# Etapa 2: Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42, stratify=y
)
print(f"\nTreino: {len(X_train)} amostras | Teste: {len(X_test)} amostras")
# Etapa 3: Treinar modelo
model = DecisionTreeClassifier(max_depth=3, random_state=42)
model.fit(X_train, y_train)
print(f"\nModelo treinado: Árvore de Decisão (max_depth=3)")
# Etapa 4: Prever
y_pred = model.predict(X_test)
# Etapa 5: Avaliar
train_acc = model.score(X_train, y_train)
test_acc = model.score(X_test, y_test)
print(f"\nAcurácia no treino: {train_acc:.3f}")
print(f"Acurácia no teste: {test_acc:.3f}")
print("\n=== Relatório de Classificação ===")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
print("=== Matriz de Confusão ===")
print(confusion_matrix(y_test, y_pred))
# Etapa 6: Prever em novos dados
new_sample = np.array([[5.1, 3.5, 1.4, 0.2]]) # Provavelmente uma setosa
prediction = model.predict(new_sample)
print(f"\nPrevisão da nova amostra: {iris.target_names[prediction[0]]}")
💻 Saída:
TEXT
📖 Somente leitura
Conjunto de dados: 150 amostras, 4 características
Características: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Classes: ['setosa', 'versicolor', 'virginica']
Treino: 105 amostras | Teste: 45 amostras
Modelo treinado: Árvore de Decisão (max_depth=3)
Acurácia no treino: 1.000
Acurácia no teste: 1.000
=== Relatório de Classificação ===
precision recall f1-score support
setosa 1.00 1.00 1.00 15
versicolor 1.00 1.00 1.00 15
virginica 1.00 1.00 1.00 15
accuracy 1.00 45
macro avg 1.00 1.00 1.00 45
weighted avg 1.00 1.00 1.00 45
=== Matriz de Confusão ===
[[15 0 0]
[ 0 15 0]
[ 0 0 15]]
Previsão da nova amostra: setosa
💡 Dica: O conjunto de dados Iris é muito "limpo" (as três classes de flores são altamente distinguíveis), então uma taxa de acurácia de 100% não é surpreendente. Os dados em projetos do mundo real são muito mais complexos do que isso—e é exatamente isso que exploraremos com mais profundidade nas próximas lições.
❓ Perguntas Frequentes
P Qual é a diferença entre treinamento e inferência?
R O treinamento é o processo de "aprendizado"—o modelo aprende parâmetros a partir dos dados, o que é demorado e computacionalmente intensivo. A inferência é o processo de "aplicação"—usar os parâmetros aprendidos para fazer previsões em novos dados, o que é rápido e leve computacionalmente. Analogia: Treinamento = um aluno estudando; inferência = um aluno fazendo uma prova.
P Uma função de perda menor é sempre melhor?
R Uma perda menor no conjunto de treinamento é melhor, mas você também deve prestar atenção à perda no conjunto de teste. Se a perda no conjunto de treinamento for extremamente baixa, mas a perda no conjunto de teste for alta, isso indica sobreajuste—o modelo "decorou as respostas". Um bom modelo deve ter bom desempenho tanto nos conjuntos de treinamento quanto de teste.
P Como o sobreajuste pode ser resolvido?
R A abordagem principal é reduzir a complexidade do modelo ou aumentar a quantidade de dados: ① Reduzir o número de parâmetros do modelo (redes rasas/profundidades menores de árvore); ② Regularização (L1/L2/Dropout); ③ Aumento de dados; ④ Parada antecipada (parar o treinamento quando a perda no conjunto de validação parar de diminuir); ⑤ Aprendizado por conjunto (votação entre múltiplos modelos).
P Uma taxa de precisão de 99% necessariamente significa que é um bom modelo?
R Não necessariamente. Se os dados forem compostos por 99% de casos normais e 1% de casos anormais, o modelo atingirá uma taxa de precisão de 99% simplesmente prevendo "normal" para todos os casos—mas não aprendeu nada. Para esse tipo de dados desbalanceados, você precisa avaliar o modelo usando Precisão, Recall e F1 score; não pode depender apenas da precisão.
P Por que precisamos de um conjunto de validação além do conjunto de treinamento e teste?
R O conjunto de validação é usado para ajustar hiperparâmetros (como profundidade da árvore e taxa de aprendizado), enquanto o conjunto de teste é usado para avaliação final. Se você ajustar hiperparâmetros usando o conjunto de teste, é como se o modelo tivesse indiretamente "visto" os dados do conjunto de teste—o que tornaria a avaliação enviesada. O conjunto de validação é "apenas para ajuste de hiperparâmetros" e o conjunto de teste é "apenas para relatório"; cada um tem sua finalidade específica.
P O que significa quando o R² é negativo?
R R² = 1 indica uma previsão perfeita; R² = 0 significa que o modelo é equivalente a "simplesmente adivinhar a média"; e R² < 0 significa que o modelo tem desempenho pior do que "adivinhar a média". Um R² negativo normalmente indica que o modelo está severamente subajustado ou que o algoritmo errado foi escolhido.
📖 Resumo
- Um algoritmo é um método de aprendizado (uma receita), um modelo é o resultado desse aprendizado (o prato pronto), e um programa é um conjunto de instruções fixas (uma linha de montagem)
- Treinamento = aprender parâmetros a partir dos dados; inferência = fazer previsões usando esses parâmetros; os dois diferem significativamente em propósito e complexidade computacional.
- A função de perda mede "o quanto o modelo erra", enquanto o otimizador determina "como ajustar os parâmetros"; juntos, eles conduzem o processo de treinamento.
- Overfitting = memorizar respostas sem saber como resolver problemas; underfitting = não ter aprendido nada e ser incapaz de fazer qualquer coisa; o objetivo é encontrar o ponto de "generalização" entre eles.
- Para tarefas de classificação, avalie usando Acurácia, Precisão, Revocação e F1; para tarefas de regressão, avalie usando MAE, MSE e R²
- Treine seu primeiro modelo com apenas cinco linhas de código usando sklearn:
load → split → fit → predict → score
📝 Exercícios
- Problema Básico (Dificuldade ⭐): Use o sklearn para treinar um
DecisionTreeClassifierno conjunto de dados Iris e imprima a acurácia de treino e teste. - Problema Avançado (Dificuldade ⭐⭐): Calcule a Precisão e o Recall do modelo (Dica:
classification_report) e explique o significado de cada métrica. - Desafio (Dificuldade: ⭐⭐⭐): Induza intencionalmente o sobreajuste (overfitting)—treine uma árvore infinitamente profunda com
max_depth=None—e depois compare as diferenças nas acurácias de treino e teste entre árvores rasas e profundas em um conjunto de dados mais complexo (como oload_wine).
