AI: Aprendizado Supervisionado

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

O aprendizado supervisionado é o paradigma de aprendizado mais fundamental e amplamente utilizado em IA — ele fornece ao modelo as "respostas corretas" para que ele possa aprender regras de previsão a partir dos dados. Este capítulo o ajudará a dominar classificação e regressão, regressão linear e árvores de decisão, e métricas de avaliação, e incluirá uma comparação prática dos dois modelos utilizando o conjunto de dados de preços de imóveis da Califórnia.

1. O Que Você Vai Aprender

• Diferenças entre Classificação e Regressão e Seus Cenários de Aplicação
• Regressão Linear: Intuição e Implementação
• Lógica de Divisão de Árvores de Decisão
• Processo Completo de Treinamento/Teste/Avaliação
• O Impacto das Características no Desempenho do Modelo

2. História: Uma Narrativa Linear é Suficiente?

(1) Ponto de Dor: Limitações dos Modelos Lineares

O senhorio de Alice queria prever o aluguel com base na metragem quadrada do imóvel, número de quartos e localização. Alice construiu um modelo usando regressão linear, obtendo um R² de 0.82. Ela ficou empolgada — mas Bob apontou: "Seu modelo prevê um aluguel mensal de $5.000 para uma unidade de 50 metros quadrados e $8.000 para uma de 80 metros quadrados — essa relação linear faz sentido? A taxa de aumento do aluguel desacelera significativamente quando a área ultrapassa 150 metros quadrados, e seu modelo linear não captura isso."

(2) Insights das Árvores de Decisão

Charlie sugeriu: "Tente uma árvore de decisão. As árvores de decisão não assumem uma relação linear; elas podem fazer previsões segmentadas por faixa — uma regra para áreas < 80, outra para 80–150, e outra para > 150 — o que reflete mais fielmente o mercado real."

▶ Exemplo: Regressão Linear vs. Árvores de Decisão—Ajustes Diferentes para os Mesmos Dados (Dificuldade: ⭐)

# Regressão Linear vs Árvore de Decisão em dados simples de aluguel
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor

area = np.array([30, 50, 70, 80, 100, 120, 150, 180, 200, 250]).reshape(-1, 1)
rent = np.array([1800, 3000, 4200, 5000, 6000, 6800, 7500, 7900, 8100, 8300])

lr = LinearRegression().fit(area, rent)
dt = DecisionTreeRegressor(max_depth=3, random_state=42).fit(area, rent)

print("Área | Real   | Prev. Linear | Prev. Árvore")
for i in range(len(area)):
    a = area[i, 0]
    print(f"{a:5.0f} | {rent[i]:6.0f} | {lr.predict([[a]])[0]:10.0f} | {dt.predict([[a]])[0]:8.0f}")

Área | Real   | Prev. Linear | Prev. Árvore
   30 |   1800 |         2187 |       1800
   50 |   3000 |         2780 |       3000
   70 |   4200 |         3374 |       4200
   80 |   5000 |         3670 |       5000
  100 |   6000 |         4264 |       6000
  120 |   6800 |         4857 |       6800
  150 |   7500 |         5748 |       7500
  180 |   7900 |         6639 |       7900
  200 |   8100 |         7233 |       8100
  250 |   8300 |         8716 |       8300

(3) Desempenho: Escolher o algoritmo certo é mais importante do que ajustar os parâmetros

Alice aprendeu: As suposições de um algoritmo determinam o limite superior do modelo. A regressão linear assume uma relação linear global, enquanto as árvores de decisão não — quando os dados são não-lineares, as árvores de decisão naturalmente têm uma vantagem.

3. Classificação vs. Regressão—As Duas Principais Tarefas do Aprendizado Supervisionado

O núcleo do aprendizado supervisionado é "aprender regras de previsão a partir de dados rotulados." Com base no tipo de rótulos, é dividido em duas grandes tarefas:

(1) Quando usar classificação e quando usar regressão?

Os critérios são simples: verifique se o rótulo diz "Qual escolher" ou "Quanto custa".

• "Este e-mail é spam?" → Classificação binária (sim/não)
• "Que animal está nesta foto?" → Multiclasse (cachorro/gato/pássaro/...)
• "Quanto vale esta casa?" → Regressão (valor contínuo)
• "Qual será a temperatura máxima amanhã?" → Regressão (valor contínuo)

(2) Classificação e regressão podem ser convertidas entre si?

Alguns problemas podem ser abordados usando classificação ou regressão. Por exemplo, ao prever as notas dos alunos, você pode prever a pontuação exata (regressão) ou categorizar as notas em A, B, C ou D (classificação). A escolha depende dos requisitos do negócio.

4. Regressão Linear—Da Intuição à Implementação

(1) A Intuição por Trás dos Mínimos Quadrados

A ideia central da regressão linear: Encontrar uma linha reta tal que a soma das distâncias de todos os pontos de dados até essa linha seja minimizada.

y = w₁x₁ + w₂x₂ + ... + wₙxₙ + b

onde:
  w = pesos (inclinação para cada característica)
  b = viés (intercepto)
  
Objetivo: Encontrar w e b que minimizem Σ(yᵢ - ŷᵢ)²
      i.e., minimizar a soma dos erros quadráticos

Entendimento intuitivo: Imagine usar uma elástico para conectar todos os pontos em um gráfico de dispersão—a posição onde o elástico se endireita naturalmente é a linha de melhor ajuste para a regressão linear.

▶ Exemplo: Previsão de Preços de Imóveis Usando Regressão Linear (Dificuldade: ⭐)

# Regressão linear para previsão de preços de imóveis
from sklearn.linear_model import LinearRegression
import numpy as np

# Característica: área (m²), Rótulo: preço (USD)
X = np.array([[50], [60], [80], [100], [120], [150]])
y = np.array([150000, 180000, 240000, 300000, 360000, 450000])

model = LinearRegression()
model.fit(X, y)

print(f"Peso (w): {model.coef_[0]:.2f} USD/m²")
print(f"Viés (b):   {model.intercept_:.2f} USD")
print(f"\nFórmula: preço = {model.coef_[0]:.2f} * área + {model.intercept_:.2f}")

# Prever
nova_area = np.array([[90]])
previsao = model.predict(nova_area)
print(f"\nPreço previsto para 90 m²: ${previsao[0]:,.0f}")

Peso (w): 3000.00 USD/m²
Viés (b):   0.00 USD

Fórmula: preço = 3000.00 * área + 0.00

Preço previsto para 90 m²: $270,000

(2) O que "linear" significa em "regressão linear"?

"Linear" não significa que as características de entrada devem ser lineares; em vez disso, significa que a relação entre os pesos e a saída é linear. Você pode aplicar transformações não lineares às características:

y = w₁ * x + w₂ * x² + b   ← Ainda é regressão linear!
                                 (linear nos pesos w, não na característica x)

▶ Exemplo: Plotando uma Linha de Regressão em um Gráfico de Dispersão (Dificuldade: ⭐⭐)

# Plotar linha de regressão e pontos de dispersão
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

X = np.array([[30], [50], [70], [90], [110], [130], [150], [170]])
y = np.array([90000, 150000, 210000, 270000, 330000, 390000, 450000, 510000])

model = LinearRegression()
model.fit(X, y)

x_line = np.linspace(20, 180, 100).reshape(-1, 1)
y_line = model.predict(x_line)

plt.figure(figsize=(8, 5))
plt.scatter(X, y, color='steelblue', s=60, label='Dados reais')
plt.plot(x_line, y_line, color='orangered', linewidth=2, label='Linha de regressão')
plt.xlabel('Área (m²)')
plt.ylabel('Preço (USD)')
plt.title('Regressão Linear: Preço do Imóvel vs. Área')
plt.legend()
plt.tight_layout()
plt.savefig('linha_regressao.png', dpi=100)
print("Gráfico salvo em linha_regressao.png")

Gráfico salvo em linha_regressao.png

5. Árvores de Decisão—Dividindo o Mundo com Regras

(1) A Lógica da Divisão

A ideia central de uma árvore de decisão: dividir os dados em subconjuntos cada vez mais "puros" fazendo perguntas repetidamente. A cada vez, uma característica e um limiar são selecionados para dividir os dados em duas partes, até que os subconjuntos sejam suficientemente puros ou uma condição de parada seja atingida.

graph TD
    A[Todos os Dados<br/>Mistura de classes] --> B{Característica ≤ limiar?}
    B -->|Sim| C[Subconjunto esquerdo<br/>mais puro?]
    B -->|Não| D[Subconjunto direito<br/>mais puro?]
    C --> E{Outra característica<br/>≤ limiar?}
    C --> F[Folha: classe majoritária A]
    D --> G[Folha: classe majoritária B]
    E -->|Sim| H[Folha: classe A]
    E -->|Não| I[Folha: classe B]

graph TD
    A[Todos os Dados<br/>Mistura de classes] --> B{Característica ≤ limiar?}
    B -->|Sim| C[Subconjunto esquerdo<br/>mais puro?]
    B -->|Não| D[Subconjunto direito<br/>mais puro?]
    C --> E{Outra característica<br/>≤ limiar?}
    C --> F[Folha: classe majoritária A]
    D --> G[Folha: classe majoritária B]
    E -->|Sim| H[Folha: classe A]
    E -->|Não| I[Folha: classe B]

(2) Ganho de Informação e Coeficiente de Gini

Como escolher o "ponto de divisão ótimo"? Duas métricas comumente usadas:

▶ Exemplo: Classificação com Árvore de Decisão no Dataset Íris (Dificuldade: ⭐⭐)

# Classificação com Árvore de Decisão no dataset Íris
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report

iris = load_iris()
X, y = iris.data, iris.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X_train, y_train)

y_pred = tree.predict(X_test)

print(f"Acurácia no treino: {tree.score(X_train, y_train):.3f}")
print(f"Acurácia no teste:     {accuracy_score(y_test, y_pred):.3f}")
print(f"\nImportância das características:")
for name, imp in zip(iris.feature_names, tree.feature_importances_):
    print(f"  {name}: {imp:.3f}")

Acurácia no treino: 1.000
Acurácia no teste:     1.000

Importância das características:
  sepal length (cm): 0.000
  sepal width (cm): 0.000
  petal length (cm): 0.560
  petal width (cm): 0.440

(3) Comparação entre Regressão Linear e Árvores de Decisão

6. Avaliação de Classificação—Matriz de Confusão e Métricas Derivadas

(1) Interpretando a Matriz de Confusão

A matriz de confusão é a pedra angular da avaliação de classificação; ela divide os resultados da predição em quatro categorias:

▶ Exemplo: Saída de uma matriz de confusão e cálculo de métricas derivadas (Dificuldade: ⭐⭐)

# Confusion matrix and derived metrics
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, accuracy_score
import numpy as np

y_true = [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1]
y_pred = [1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1]

cm = confusion_matrix(y_true, y_pred)
print("Confusion Matrix:")
print(f"              Predicted Neg  Predicted Pos")
print(f"Actual Neg      {cm[0][0]:3d} (TN)      {cm[0][1]:3d} (FP)")
print(f"Actual Pos      {cm[1][0]:3d} (FN)      {cm[1][1]:3d} (TP)")

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(f"\nAccuracy:  {acc:.3f} = (TP+TN) / Total = ({cm[1][1]}+{cm[0][0]}) / {len(y_true)}")
print(f"Precision: {prec:.3f} = TP / (TP+FP) = {cm[1][1]} / ({cm[1][1]}+{cm[0][1]})")
print(f"Recall:    {rec:.3f} = TP / (TP+FN) = {cm[1][1]} / ({cm[1][1]}+{cm[1][0]})")
print(f"F1 Score:  {f1:.3f} = 2*P*R / (P+R)")

Confusion Matrix:
              Predicted Neg  Predicted Pos
Actual Neg        5 (TN)        2 (FP)
Actual Pos        2 (FN)        6 (TP)

Accuracy:  0.733 = (TP+TN) / Total = (6+5) / 15
Precision: 0.750 = TP / (TP+FP) = 6 / (6+2)
Recall:    0.750 = TP / (TP+FN) = 6 / (6+2)
F1 Score:  0.750 = 2*P*R / (P+R)

(2) Quando priorizar a Precisão e quando priorizar o Recall?

7. Avaliação da Regressão—MAE / MSE / R²

(1) Comparação das Quatro Principais Métricas de Erro

▶ Exemplo: Cálculo de métricas de regressão como R² e MSE (Dificuldade: ⭐)

# Regression metrics calculation
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

y_true = np.array([200000, 300000, 250000, 400000, 350000])
y_pred = np.array([210000, 290000, 260000, 380000, 340000])

mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_true, y_pred)

print("=== Regression Metrics ===")
print(f"MAE:  ${mae:,.0f}  — Average absolute error")
print(f"MSE:  ${mse:,.0f}  — Average squared error")
print(f"RMSE: ${rmse:,.0f}  — Root of MSE (same unit as price)")
print(f"R²:   {r2:.4f}  — Proportion of variance explained")

=== Regression Metrics ===
MAE:  $12,000  — Erro absoluto médio
MSE:  $170,000,000  — Erro quadrático médio
RMSE: $13,038  — Raiz do MSE (mesma unidade do preço)
RMSE: $13,038  — Raiz do MSE (mesma unidade do preço)
R²:   0.9620  — Proporção da variância explicada

(2) O Significado Intuitivo do R²

O R² responde à pergunta: "O quanto meu modelo é melhor do que 'simplesmente adivinhar a média'?"

R² = 1  → Previsões perfeitas
R² = 0  → Não é melhor que adivinhar a média
R² < 0  → Pior que adivinhar a média (muito ruim!)

8. Escalonamento de Features—Garantindo que o Modelo Não Esteja em Desvantagem

(1) Por que o escalonamento de features é necessário?

Quando há uma grande diferença nos intervalos numéricos das diferentes features, certos algoritmos podem "favorecer" features com valores grandes:

Quando não escalonadas, a faixa de variação da renda é muito maior do que a do número de quartos, portanto o modelo pode depender excessivamente da renda e negligenciar o número de quartos.

(2) Dois Métodos Comuns de Escalonamento

# Comparação de escalonamento de features
from sklearn.preprocessing import MinMaxScaler, StandardScaler
import numpy as np

data = np.array([[30, 1, 20000],
                 [80, 3, 60000],
                 [150, 5, 120000],
                 [250, 6, 200000]])

mm = MinMaxScaler()
ss = StandardScaler()

print("Escalonado Min-Max:\n", np.round(mm.fit_transform(data), 3))
print("\nEscalonado Padrão:\n", np.round(ss.fit_transform(data), 3))

Min-Max scaled:
 [[0.     0.     0.    ]
 [0.235  0.4    0.222 ]
 [0.706  0.8    0.556 ]
 [1.     1.     1.    ]]

Standard scaled:
 [[-1.183 -1.183 -1.183]
 [-0.394 -0.394 -0.394]
 [ 0.789  0.394  0.394]
 [ 1.577  1.577  1.577]]

9. Exemplo Abrangente: Comparando Regressão Linear e Árvores de Decisão Usando o Dataset de Preços de Habitação da Califórnia

Experimente o processo completo com o dataset de Habitação da Califórnia: carregamento de dados → particionamento → treinamento → avaliação → comparação.

▶ Exemplo: Preços de Casas na Califórnia—Uma Comparação Passo a Passo de Regressão Linear vs. Regressão com Árvore de Decisão (Dificuldade: ⭐⭐⭐)

# ============================================
# Comprehensive: Linear Regression vs Decision Tree
# Dataset: California Housing
# ============================================
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

# Step 1: Load data
housing = fetch_california_housing()
X, y = housing.data, housing.target
print(f"Dataset: {X.shape[0]} samples, {X.shape[1]} features")
print(f"Features: {list(housing.feature_names)}")
print(f"Target range: [{y.min():.2f}, {y.max():.2f}] (unit: $100,000)")

# Step 2: Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
print(f"\nTrain: {len(X_train)} | Test: {len(X_test)}")

# Step 3: Feature scaling (for linear regression)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Step 4: Train both models
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)

dt = DecisionTreeRegressor(max_depth=8, random_state=42)
dt.fit(X_train, y_train)  # Decision tree doesn't need scaling

# Step 5: Predict
y_pred_lr = lr.predict(X_test_scaled)
y_pred_dt = dt.predict(X_test)

# Step 6: Evaluate and compare
print("\n" + "=" * 50)
print(f"{'Metric':<12} {'Linear Reg':>12} {'Decision Tree':>14}")
print("=" * 50)

for name, pred in [("Linear Reg", y_pred_lr), ("Decision Tree", y_pred_dt)]:
    mae = mean_absolute_error(y_test, pred)
    rmse = np.sqrt(mean_squared_error(y_test, pred))
    r2 = r2_score(y_test, pred)

print(f"{'MAE':<12} {mean_absolute_error(y_test, y_pred_lr):>12.4f} {mean_absolute_error(y_test, y_pred_dt):>14.4f}")
print(f"{'RMSE':<12} {np.sqrt(mean_squared_error(y_test, y_pred_lr)):>12.4f} {np.sqrt(mean_squared_error(y_test, y_pred_dt)):>14.4f}")
print(f"{'R²':<12} {r2_score(y_test, y_pred_lr):>12.4f} {r2_score(y_test, y_pred_dt):>14.4f}")
print("=" * 50)

# Step 7: Feature importance (linear regression coefficients vs tree importances)
print("\nFeature Importance Comparison:")
print(f"{'Feature':<22} {'LR |Coef|':>10} {'DT Import':>10}")
for i, fname in enumerate(housing.feature_names):
    lr_imp = abs(lr.coef_[i])
    dt_imp = dt.feature_importances_[i]
    print(f"{fname:<22} {lr_imp:>10.4f} {dt_imp:>10.4f}")

Dataset: 20640 samples, 8 features
Features: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
Target range: [0.15, 5.00] (unit: $100,000)

Train: 16512 | Test: 4128

==================================================
Metric          Linear Reg   Decision Tree
==================================================
MAE                0.5252        0.4251
RMSE               0.7456        0.6052
R²                 0.5757        0.7210
==================================================

Feature Importance Comparison:
Feature                 LR |Coef|  DT Import
MedInc                     0.8269     0.5281
HouseAge                   0.1771     0.0521
AveRooms                   0.4283     0.0471
AveBedrms                  0.1447     0.0184
Population                 0.0021     0.0134
AveOccup                   0.0447     0.0481
Latitude                   0.8740     0.1434
Longitude                  0.8586     0.1494

❓ Perguntas Frequentes

P: O que significa “linear” na regressão linear? R: Significa que a relação entre os pesos e a saída é linear, ou seja, y = w₁x₁ + w₂x₂ + ... + b, onde cada peso w_i afeta y de forma aditiva. Não significa que as características de entrada x precisam ser lineares — você pode substituir x por x², log(x), etc., e ainda assim será “regressão linear” (são os pesos que são lineares, não as características).

P: Uma árvore de decisão pode ficar muito profunda e levar ao overfitting? R: Sim. Se a profundidade de uma árvore de decisão não for limitada, ela pode continuar dividindo até que cada nó folha contenha apenas uma amostra — resultando em um ajuste perfeito para o conjunto de treinamento, mas um desempenho extremamente pobre no conjunto de teste. Soluções: ① Limitar max_depth (ex.: 3–8) ② Definir min_samples_leaf (número mínimo de amostras por folha) ③ Definir min_samples_split ④ Usar poda ⑤ Usar uma floresta aleatória em vez de uma única árvore.

P: Um R² de 1.0 é sempre uma coisa boa? R: Não necessariamente. Um R² de 1.0 no conjunto de treinamento geralmente indica overfitting — o modelo “memorizou” todos os dados de treinamento. O principal é observar o R² no conjunto de teste: se o R² de treinamento for 0.99, mas o R² de teste for 0.3, isso indica overfitting grave. Além disso, se os próprios dados contêm quase nenhum ruído (como dados gerados por fórmulas físicas), um R² de 1.0 é razoável.

P: Classificação e regressão podem ser convertidas uma na outra? R: Sim. Um problema de regressão pode ser “discretizado” em um problema de classificação: dividir preços de imóveis em três categorias — “baixo”, “médio” e “alto” — é um exemplo de classificação. Um problema de classificação também pode ser “probabilizado” em um problema de regressão: a regressão logística produz probabilidades (valores contínuos entre 0 e 1), que são convertidas em categorias somente após a definição de um limiar. A escolha entre classificação e regressão depende se o requisito de negócio é “selecionar um” ou “calcular um valor”.

P: Por que são necessárias múltiplas métricas de avaliação? R: Porque uma única métrica tem pontos cegos. Uma taxa de acurácia de 99% pode ser simplesmente porque 99% dos dados pertencem à mesma categoria; o R² pode ser alto, mas o MAE pode ser grande (outliers inflaram a variância geral). Cada métrica avalia o modelo de uma perspectiva diferente, e somente combinando múltiplas métricas podemos ter uma compreensão abrangente do desempenho do modelo. É como um exame físico — você não pode confiar em apenas uma métrica; pressão arterial normal não significa que sua glicemia está normal.

P: A escala de características afeta árvores de decisão? R: Não. As árvores de decisão se dividem com base em limiares das características. A escala altera apenas os valores numéricos, mas não altera a ordem, e como a ordem permanece inalterada, os pontos de divisão permanecem os mesmos. Portanto, as árvores de decisão não necessitam de escala de características. No entanto, algoritmos baseados em distância ou gradientes — como regressão linear, KNN, SVM e redes neurais — devem ser escalados primeiro.

📖 Resumo

• O aprendizado supervisionado é dividido em duas tarefas principais: classificação (prever categorias discretas) e regressão (prever valores contínuos); o fator de distinção é "qual escolher" versus "quanto calcular".
• A regressão linear usa o método dos mínimos quadrados para encontrar a linha de melhor ajuste; é simples e eficiente, mas assume uma relação linear. As árvores de decisão usam regras if-else para ajustar dados em segmentos; podem capturar relações não lineares, mas são propensas a overfitting.
• A avaliação de classificação usa pontuações de Precisão, Revocação e F1, derivadas da matriz de confusão—cenários diferentes enfatizam métricas diferentes (a Precisão é crucial para filtragem de spam, enquanto a Revocação é crucial para detecção de câncer)
• Ao avaliar modelos de regressão, considere MAE, MSE e R²—R² é o mais comumente usado, mas cuidado com a armadilha de overfitting; MAE é o mais intuitivo.
• A escala de características permite que características com diferentes unidades compitam em igualdade de condições; a regressão linear requer escalonamento, enquanto as árvores de decisão não.
• Escolher o algoritmo certo é mais importante do que ajustar parâmetros: Use regressão linear para relações lineares, árvores de decisão para relações não lineares, e se você não tiver certeza, experimente todos e compare os resultados.

📝 Exercícios

1. Problema Básico (Dificuldade ⭐): Use o sklearn para treinar um modelo LinearRegression no conjunto de dados de preços de moradia da Califórnia, plote um gráfico de dispersão da área (coluna MedInc) versus preços de moradia e desenhe uma linha de regressão no gráfico.
2. Problema Avançado (Dificuldade ⭐⭐): Use o DecisionTreeClassifier para treinar um modelo no conjunto de dados Íris, emita a matriz de confusão e calcule a precisão e o recall para cada classe (Dica: classification_report).
3. Problema Desafiador (Dificuldade ⭐⭐⭐): Usando o conjunto de dados de preços de moradia da Califórnia, compare os valores de R² de treino e teste das duas árvores de decisão, max_depth=3 e max_depth=None, para observar o sobreajuste (overfitting); então tente adicionar parâmetros de regularização, como min_samples_leaf=10, para encontrar a configuração com o maior R² de teste.

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