antonino, Autor em Área de Trampo

Categorias

Os parâmetros de um modelo são estimados considerando a diferença entre o valor de treinamento e o valor previsto. Esse cálculo é realizado por uma função de perda (loss function) e o objetivo do estimador é minimizar essa função de perda.

# ============================================
# 6. AVALIAÇÃO DOS MODELOS
# ============================================
def avaliar_modelo(y_true, y_pred, nome_modelo, conjunto):
    """Função para avaliar métricas do modelo"""
    r2 = r2_score(y_true, y_pred)
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    mae = mean_absolute_error(y_true, y_pred)
    mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
 
    print(f"\n{conjunto} - {nome_modelo}:")
    print(f"  R² Score: {r2:.4f}")
    print(f"  RMSE: R$ {rmse:,.2f}")
    print(f"  MAE: R$ {mae:,.2f}")
    print(f"  MAPE: {mape:.2f}%")
 
    return r2, rmse, mae, mape
 
print("\n" + "=" * 60)
print("AVALIAÇÃO DOS MODELOS")
print("=" * 60)
 
# Avaliando modelos
print("\n📊 MODELO SEM NORMALIZAÇÃO:")
r2_train_sem, rmse_train_sem, mae_train_sem, mape_train_sem = avaliar_modelo(
    y_train, y_pred_train_sem, "Linear Regression", "TREINO"
)
r2_test_sem, rmse_test_sem, mae_test_sem, mape_test_sem = avaliar_modelo(
    y_test, y_pred_test_sem, "Linear Regression", "TESTE"
)
 
print("\n📊 MODELO COM NORMALIZAÇÃO:")
r2_train_com, rmse_train_com, mae_train_com, mape_train_com = avaliar_modelo(
    y_train, y_pred_train_com, "Linear Regression (com scaler)", "TREINO"
)
r2_test_com, rmse_test_com, mae_test_com, mape_test_com = avaliar_modelo(
    y_test, y_pred_test_com, "Linear Regression (com scaler)", "TESTE"
)

# ============================================

# 6. AVALIAÇÃO DOS MODELOS

# ============================================

def avaliar_modelo(y_true, y_pred, nome_modelo, conjunto):

"""Função para avaliar métricas do modelo"""

r2 = r2_score(y_true, y_pred)

rmse = np.sqrt(mean_squared_error(y_true, y_pred))

mae = mean_absolute_error(y_true, y_pred)

mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100

print(f"\n{conjunto} - {nome_modelo}:")

print(f" R² Score: {r2:.4f}")

print(f" RMSE: R$ {rmse:,.2f}")

print(f" MAE: R$ {mae:,.2f}")

print(f" MAPE: {mape:.2f}%")

return r2, rmse, mae, mape

print("\n" + "=" * 60)

print("AVALIAÇÃO DOS MODELOS")

print("=" * 60)

# Avaliando modelos

print("\n📊 MODELO SEM NORMALIZAÇÃO:")

r2_train_sem, rmse_train_sem, mae_train_sem, mape_train_sem = avaliar_modelo(

y_train, y_pred_train_sem, "Linear Regression", "TREINO"

)

r2_test_sem, rmse_test_sem, mae_test_sem, mape_test_sem = avaliar_modelo(

y_test, y_pred_test_sem, "Linear Regression", "TESTE"

)

print("\n📊 MODELO COM NORMALIZAÇÃO:")

r2_train_com, rmse_train_com, mae_train_com, mape_train_com = avaliar_modelo(

y_train, y_pred_train_com, "Linear Regression (com scaler)", "TREINO"

)

r2_test_com, rmse_test_com, mae_test_com, mape_test_com = avaliar_modelo(

y_test, y_pred_test_com, "Linear Regression (com scaler)", "TESTE"

)

A Bússola do Aprendizado: O Papel das Métricas de Avaliação

Ensinar uma máquina a realizar tarefas envolve um processo de tentativa e erro. O modelo começa fazendo previsões aleatórias, mas precisa de um mecanismo para avaliar a qualidade desses palpites. As funções de perda e as métricas de avaliação oferecem exatamente essa ferramenta. Elas calculam a discrepância entre a saída prevista pelo modelo e o valor real esperado. Durante o treinamento, buscamos minimizar esse valor de perda, ajustando os parâmetros internos do modelo. Portanto, a função de perda funciona como uma bússola, indicando a direção que o algoritmo deve seguir para melhorar. A escolha da métrica correta, porém, representa um passo determinante para interpretar o desempenho final. Diferentes problemas exigem diferentes formas de medir o erro. Consequentemente, utilizar a métrica inadequada pode mascarar problemas e comprometer a confiabilidade do modelo.

MSE e MAE: Para Medir Erros em Regressões

Em problemas de regressão, onde prever um valor numérico contínuo é o objetivo, duas métricas se destacam. O mean_squared_error (MSE) calcula a média dos quadrados das diferenças entre os valores previstos e os reais. Por elevar os erros ao quadrado, essa métrica penaliza fortemente erros grandes, tornando-a mais sensível a outliers. Os desenvolvedores frequentemente a utilizam como função de perda durante o treinamento. Por outro lado, o mean_absolute_error (MAE) calcula a média dos valores absolutos das diferenças. Ele trata todos os erros de forma linear, sendo mais robusto a outliers. Para a avaliação final do modelo, muitos preferem o MAE quando os dados contêm valores discrepantes que não devem receber peso excessivo. A decisão entre um e outro depende, portanto, da presença e do tratamento desejado para esses pontos atípicos.

MAPE: Compreendendo o Erro Percentual

O mape (Mean Absolute Percentage Error) oferece outra perspectiva valiosa para regressão. Diferente do MSE e do MAE, que fornecem o erro na mesma unidade da variável alvo, o MAPE expressa o erro como uma porcentagem. Para calculá-lo, tiramos a média da diferença absoluta entre o valor real e o previsto, dividindo pelo valor real. Essa métrica se mostra extremamente útil para comunicar resultados a um público não técnico. “O modelo erra, em média, 5% para mais ou para menos” — essa frase exemplifica sua fácil interpretação. No entanto, precisamos ter cautela. O MAPE pode se tornar instável quando os valores reais são muito próximos de zero, pois ocorre uma divisão por um número muito pequeno. Ele se adequa melhor a conjuntos de dados onde a variável alvo mantém uma escala positiva e consistente.

R2 Score: Medindo a Qualidade do Ajuste

O r2_score, ou Coeficiente de Determinação, oferece uma perspectiva diferente sobre a qualidade do modelo de regressão. Em vez de medir a magnitude do erro, ele indica a proporção da variância dos dados que o modelo explica. O valor do R² geralmente varia entre 0 e 1. Um score de 1 significa que o modelo prevê perfeitamente todos os dados. Um score de 0 indica que o modelo não melhora a simples previsão pela média dos valores. Valores negativos também podem aparecer, sugerindo um modelo muito ruim. Essa métrica se mostra particularmente útil para comparar diferentes modelos e entender seu poder de capturar relações entre variáveis. Porém, adicionar variáveis irrelevantes ao modelo pode artificialmente elevar o R². Por essa razão, os profissionais frequentemente o utilizam em conjunto com outras métricas e técnicas de validação.

Será que é possível melhorar?

Uma tentativa é colocar mais dados de treinamento para aumentar a acurácia do modelo.

Entendendo a regressão com árvore de decisão

A regressão com árvore de decisão é um modelo supervisionado. Ele prevê valores numéricos contínuos, como preços de casas. Diferentemente da classificação, a saída aqui é um número real. Por exemplo, podemos prever a temperatura de amanhã. Este modelo divide os dados em regiões retangulares. Cada região recebe um valor constante de predição. A estrutura lembra uma árvore invertida com galhos e folhas.

As características principais incluem simplicidade e interpretabilidade. A árvore é construída por meio de divisões recursivas. Cada divisão usa uma característica e um ponto de corte. O objetivo é minimizar o erro quadrático médio local. Modelos mais profundos podem sofrer de overfitting. Por isso, o controle da complexidade é essencial. A predição final é a média dos valores na folha.

Arquitetura e componentes internos

A arquitetura começa com o nó raiz, que contém todos os dados. Cada nó interno testa uma única característica. O teste pergunta: o valor é menor que um limiar? Conforme a resposta, os dados seguem para um ramo. Esse processo se repete até chegar aos nós folha. Cada folha armazena um valor constante predito. Em regressão, esse valor é a média dos alvos locais. A profundidade da árvore é o maior número de divisões. Quanto mais folhas, mais complexo é o modelo final.

A construção usa um algoritmo guloso por eficiência. Ele busca a melhor divisão em cada etapa local. A métrica típica é a redução da variância. A fórmula da variância de um nó é: $\sigma^2 = \frac{1}{N}\sum_{i=1}^{N} (y_i – \bar{y})^2$. A redução da variância após divisão é calculada assim: $\Delta = \sigma^2_{pai} – \left( \frac{N_{esq}}{N_{pai}} \sigma^2_{esq} + \frac{N_{dir}}{N_{pai}} \sigma^2_{dir} \right)$. A divisão escolhida maximiza esse delta positivo. Esse processo é repetido até um critério de parada.

Hiperparâmetros essenciais

Os hiperparâmetros controlam o crescimento da árvore. A profundidade máxima limita quantas divisões são feitas. O número mínimo de amostras por folha evita folhas vazias. O número mínimo para divisão impede divisões muito pequenas. Esses parâmetros podem ser ajustados por validação cruzada. Árvores muito profundas geralmente memorizam ruídos. Árvores rasas podem não capturar padrões complexos. Um equilíbrio é alcançado com hiperparâmetros adequados. É comum usar poda ou restrições para regularizar.

Outros parâmetros incluem o critério de divisão. O erro quadrático médio (MSE) é a função padrão. A fórmula do MSE em um nó é apresentada abaixo: $MSE = \frac{1}{N} \sum_{i=1}^{N} (y_i – \hat{y})^2$. Nessa expressão, $\hat{y}$ é a média local. Modelos de árvore são frequentemente combinados em florestas. Florestas aleatórias melhoram a precisão pela média de árvores. Contudo, a árvore única já é um ótimo ponto de partida. A interpretabilidade é mantida em árvores de pequena profundidade.

Exemplo prático em Python

Abaixo está um código para rodar no Google Colab. Ele gera dados sintéticos e treina uma árvore de regressão. O gráfico mostra a predição sobreposta aos dados reais. Certifique-se de instalar as bibliotecas necessárias. O código usa scikit-learn, matplotlib e numpy.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor

# Dados sintéticos: y = x^2 + ruído
np.random.seed(42)
X = np.sort(5 * np.random.rand(80, 1), axis=0)
y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])

# Árvore de regressão com hiperparâmetros controlados
regressor = DecisionTreeRegressor(max_depth=4, min_samples_split=5, random_state=42)
regressor.fit(X, y)

# Predição para valores suaves
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_pred = regressor.predict(X_test)

# Gráfico
plt.figure(figsize=(10, 6))
plt.scatter(X, y, s=20, label="Dados reais", color="blue")
plt.plot(X_test, y_pred, label="Predição da árvore", color="red", linewidth=2)
plt.xlabel("Característica X")
plt.ylabel("Alvo y")
plt.title("Regressão com Árvore de Decisão")
plt.legend()
plt.grid(True)
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.tree import DecisionTreeRegressor

# Dados sintéticos: y = x^2 + ruído

np.random.seed(42)

X = np.sort(5 * np.random.rand(80, 1), axis=0)

y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])

# Árvore de regressão com hiperparâmetros controlados

regressor = DecisionTreeRegressor(max_depth=4, min_samples_split=5, random_state=42)

regressor.fit(X, y)

# Predição para valores suaves

X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]

y_pred = regressor.predict(X_test)

# Gráfico

plt.figure(figsize=(10, 6))

plt.scatter(X, y, s=20, label="Dados reais", color="blue")

plt.plot(X_test, y_pred, label="Predição da árvore", color="red", linewidth=2)

plt.xlabel("Característica X")

plt.ylabel("Alvo y")

plt.title("Regressão com Árvore de Decisão")

plt.legend()

plt.grid(True)

plt.show()

O código cria 80 pontos com relação senoidal e ruído. A árvore usa profundidade máxima 4 para evitar overfitting. O gráfico resultante mostra degraus horizontais típicos. Cada degrau corresponde a uma região de uma folha. Isso ilustra perfeitamente como a árvore particiona o espaço. Alterar a profundidade para 20 produziria muitos degraus. Assim, o modelo se ajustaria excessivamente ao ruído. Por fim, recomenda-se explorar outros hiperparâmetros. Essa abordagem é poderosa e fácil de interpretar.