Arquivo de Machine Learning - Página 9 de 16

Modelos Lineares Generalizados: Laço (Lasso)

19/12/202518/10/2025 Por antonino

Anteriormente discutimos a Regressão Linear tradicional e Ridge. Analogamente, o Lasso (Least Absolute Shrinkage and Selection Operator) é outra técnica de regularização que adiciona uma penalidade L1 à função objetivo, promovendo esparsidade nos coeficientes do modelo.

Conceito Fundamental do Lasso

Primordialmente, o Lasso realiza não apenas a regularização dos coeficientes, mas também seleção de features. Decerto, ao adicionar uma penalidade baseada no valor absoluto dos coeficientes, ele tende a zerar os coeficientes de features menos importantes.

Conforme a documentação do scikit-learn, o Lasso é particularmente útil quando acreditamos que apenas um subconjunto das features é realmente relevante para a previsão. Similarmente ao Ridge, ele ajuda a prevenir overfitting, mas com características distintas.

Formulação Matemática

O objetivo do Lasso é minimizar a seguinte função:

\(\min_{w} \frac{1}{2n}||Xw – y||_2^2 + \alpha||w||_1\)

Onde:

X é a matriz de features
y é o vetor target
w são os coeficientes do modelo
α é o parâmetro de regularização
||w||₁ é a norma L1 dos coeficientes

Características Principais do Lasso

Inegavelmente, o Lasso possui propriedades únicas que o distinguem de outras técnicas de regularização:

Seleção de features: Zera coeficientes de features irrelevantes
Esparsidade: Produz modelos com poucas features não-zero
Interpretabilidade: Modelos mais simples e interpretáveis
Regularização L1: Penalidade baseada no valor absoluto

Comparação: Lasso vs Ridge

Embora ambos sejam técnicas de regularização, existem diferenças fundamentais:

Lasso (L1): Promove esparsidade, zera coeficientes
Ridge (L2): Reduz coeficientes, mas não zera
ElasticNet: Combina L1 e L2

Parâmetros do Lasso

Os principais parâmetros para ajuste no Lasso são:

alpha: Parâmetro de regularização (α)
max_iter: Número máximo de iterações
tol: Tolerância para critério de parada
selection: Estratégia de seleção de coeficientes

Exemplo Prático: Aplicação do Lasso

Ademais, vejamos um exemplo completo demonstrando o uso do Lasso:

'''
Aplicação do Lasso para Regressão com Seleção de Features
Este exemplo demonstra como o Lasso pode ser usado
para selecionar features relevantes e evitar overfitting
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import Lasso, Ridge, LinearRegression
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com algumas features irrelevantes
X, y, true_coef = make_regression(n_samples=1000, n_features=20, 
                                 n_informative=8, noise=10, 
                                 coef=True, random_state=42)

print("Informações do Dataset:")
print(f"Número de amostras: {X.shape[0]}")
print(f"Número de features: {X.shape[1]}")
print(f"Features informativas: 8")
print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

# Dividir em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, 
                                                    random_state=42)

# Normalizar os dados (importante para regularização)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''
Comparação entre Regressão Linear, Ridge e Lasso
Cada método tem características diferentes de regularização
'''

models = {
    'Linear': LinearRegression(),
    'Ridge': Ridge(alpha=1.0),
    'Lasso': Lasso(alpha=1.0)
}

results = {}

print("\n--- Comparação de Modelos ---")
for name, model in models.items():
    # Treinar modelo
    model.fit(X_train_scaled, y_train)
    
    # Fazer previsões
    y_pred = model.predict(X_test_scaled)
    
    # Calcular métricas
    mse = mean_squared_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    
    # Armazenar resultados
    if hasattr(model, 'coef_'):
        n_nonzero = np.sum(model.coef_ != 0)
        results[name] = {
            'model': model,
            'mse': mse,
            'r2': r2,
            'n_nonzero': n_nonzero,
            'coef': model.coef_
        }
    else:
        results[name] = {
            'model': model,
            'mse': mse,
            'r2': r2,
            'n_nonzero': X.shape[1],
            'coef': None
        }
    
    print(f"{name:8} - MSE: {mse:.2f}, R²: {r2:.3f}, Features não-zero: {results[name]['n_nonzero']}")

# Otimização do parâmetro alpha para Lasso
print("\n--- Otimização do Parâmetro Alpha para Lasso ---")

param_grid = {
    'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]
}

grid_search = GridSearchCV(Lasso(max_iter=10000), param_grid, cv=5, 
                          scoring='neg_mean_squared_error', n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

print(f"Melhor alpha: {grid_search.best_params_['alpha']}")
print(f"Melhor MSE na validação: {-grid_search.best_score_:.2f}")

# Modelo Lasso otimizado
best_lasso = grid_search.best_estimator_
y_pred_best = best_lasso.predict(X_test_scaled)
final_mse = mean_squared_error(y_test, y_pred_best)
final_r2 = r2_score(y_test, y_pred_best)
n_nonzero_best = np.sum(best_lasso.coef_ != 0)

print(f"\nLasso Otimizado - MSE: {final_mse:.2f}, R²: {final_r2:.3f}")
print(f"Features selecionadas: {n_nonzero_best} de {X.shape[1]}")

# Análise dos coeficientes
print("\n--- Análise dos Coeficientes ---")
print("Comparação entre coeficientes verdadeiros e estimados:")

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

# Plot 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
features = range(len(true_coef))
plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=8)
plt.plot(features, results['Linear']['coef'], 's-', label='Linear', alpha=0.7)
plt.plot(features, results['Ridge']['coef'], '^-', label='Ridge', alpha=0.7)
plt.plot(features, best_lasso.coef_, 'd-', label='Lasso (Otimizado)', alpha=0.7)
plt.xlabel('Feature Index')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot 2: Features selecionadas pelo Lasso
plt.subplot(2, 2, 2)
lasso_coef_nonzero = best_lasso.coef_ != 0
true_coef_nonzero = true_coef != 0

# Calcular acurácia na seleção de features
correct_selection = np.sum(lasso_coef_nonzero == true_coef_nonzero)
selection_accuracy = correct_selection / len(true_coef)

plt.bar(['Selecionadas', 'Não Selecionadas'], 
        [np.sum(lasso_coef_nonzero), np.sum(~lasso_coef_nonzero)],
        color=['lightcoral', 'lightblue'])
plt.title(f'Seleção de Features pelo Lasso\nAcurácia: {selection_accuracy:.1%}')
plt.ylabel('Número de Features')

# Plot 3: Performance vs Alpha
plt.subplot(2, 2, 3)
alphas = param_grid['alpha']
cv_scores = -grid_search.cv_results_['mean_test_score']

plt.semilogx(alphas, cv_scores, 'o-', linewidth=2)
plt.xlabel('Alpha')
plt.ylabel('MSE')
plt.title('Performance vs Parâmetro Alpha')
plt.grid(True, alpha=0.3)

# Plot 4: Comparação de MSE
plt.subplot(2, 2, 4)
model_names = list(results.keys()) + ['Lasso Otimizado']
mses = [results[name]['mse'] for name in results.keys()] + [final_mse]

plt.bar(model_names, mses, color=['skyblue', 'lightgreen', 'gold', 'lightcoral'])
plt.ylabel('MSE')
plt.title('Comparação de Erro Quadrático Médio')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# Análise detalhada da seleção de features
print(f"\n--- Análise Detalhada da Seleção de Features ---")
print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")
print(f"Coeficientes Lasso não-zero: {np.sum(best_lasso.coef_ != 0)}")
print(f"Features corretamente selecionadas: {np.sum((best_lasso.coef_ != 0) & (true_coef != 0))}")
print(f"Features corretamente excluídas: {np.sum((best_lasso.coef_ == 0) & (true_coef == 0))}")
print(f"Acurácia total na seleção: {selection_accuracy:.1%}")

# Exemplo de interpretação do modelo
print(f"\n--- Interpretação do Modelo Lasso ---")
print("Features mais importantes (maiores coeficientes em valor absoluto):")

important_features = np.argsort(np.abs(best_lasso.coef_))[::-1][:5]
for i, feat_idx in enumerate(important_features):
    if best_lasso.coef_[feat_idx] != 0:
        print(f"Feature {feat_idx:2d}: coeficiente = {best_lasso.coef_[feat_idx]:.3f}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

'''

Aplicação do Lasso para Regressão com Seleção de Features

Este exemplo demonstra como o Lasso pode ser usado

para selecionar features relevantes e evitar overfitting

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import Lasso, Ridge, LinearRegression

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com algumas features irrelevantes

X, y, true_coef = make_regression(n_samples=1000, n_features=20,

n_informative=8, noise=10,

coef=True, random_state=42)

print("Informações do Dataset:")

print(f"Número de amostras: {X.shape[0]}")

print(f"Número de features: {X.shape[1]}")

print(f"Features informativas: 8")

print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

# Dividir em treino e teste

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

random_state=42)

# Normalizar os dados (importante para regularização)

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''

Comparação entre Regressão Linear, Ridge e Lasso

Cada método tem características diferentes de regularização

'''

models = {

'Linear': LinearRegression(),

'Ridge': Ridge(alpha=1.0),

'Lasso': Lasso(alpha=1.0)

}

results = {}

print("\n--- Comparação de Modelos ---")

for name, model in models.items():

# Treinar modelo

model.fit(X_train_scaled, y_train)

# Fazer previsões

y_pred = model.predict(X_test_scaled)

# Calcular métricas

mse = mean_squared_error(y_test, y_pred)

r2 = r2_score(y_test, y_pred)

# Armazenar resultados

if hasattr(model, 'coef_'):

n_nonzero = np.sum(model.coef_ != 0)

results[name] = {

'model': model,

'mse': mse,

'r2': r2,

'n_nonzero': n_nonzero,

'coef': model.coef_

}

else:

results[name] = {

'model': model,

'mse': mse,

'r2': r2,

'n_nonzero': X.shape[1],

'coef': None

}

print(f"{name:8} - MSE: {mse:.2f}, R²: {r2:.3f}, Features não-zero: {results[name]['n_nonzero']}")

# Otimização do parâmetro alpha para Lasso

print("\n--- Otimização do Parâmetro Alpha para Lasso ---")

param_grid = {

'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]

}

grid_search = GridSearchCV(Lasso(max_iter=10000), param_grid, cv=5,

scoring='neg_mean_squared_error', n_jobs=-1)

grid_search.fit(X_train_scaled, y_train)

print(f"Melhor alpha: {grid_search.best_params_['alpha']}")

print(f"Melhor MSE na validação: {-grid_search.best_score_:.2f}")

# Modelo Lasso otimizado

best_lasso = grid_search.best_estimator_

y_pred_best = best_lasso.predict(X_test_scaled)

final_mse = mean_squared_error(y_test, y_pred_best)

final_r2 = r2_score(y_test, y_pred_best)

n_nonzero_best = np.sum(best_lasso.coef_ != 0)

print(f"\nLasso Otimizado - MSE: {final_mse:.2f}, R²: {final_r2:.3f}")

print(f"Features selecionadas: {n_nonzero_best} de {X.shape[1]}")

# Análise dos coeficientes

print("\n--- Análise dos Coeficientes ---")

print("Comparação entre coeficientes verdadeiros e estimados:")

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

# Plot 1: Comparação de coeficientes

plt.subplot(2, 2, 1)

features = range(len(true_coef))

plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=8)

plt.plot(features, results['Linear']['coef'], 's-', label='Linear', alpha=0.7)

plt.plot(features, results['Ridge']['coef'], '^-', label='Ridge', alpha=0.7)

plt.plot(features, best_lasso.coef_, 'd-', label='Lasso (Otimizado)', alpha=0.7)

plt.xlabel('Feature Index')

plt.ylabel('Valor do Coeficiente')

plt.title('Comparação dos Coeficientes')

plt.legend()

plt.grid(True, alpha=0.3)

# Plot 2: Features selecionadas pelo Lasso

plt.subplot(2, 2, 2)

lasso_coef_nonzero = best_lasso.coef_ != 0

true_coef_nonzero = true_coef != 0

# Calcular acurácia na seleção de features

correct_selection = np.sum(lasso_coef_nonzero == true_coef_nonzero)

selection_accuracy = correct_selection / len(true_coef)

plt.bar(['Selecionadas', 'Não Selecionadas'],

[np.sum(lasso_coef_nonzero), np.sum(~lasso_coef_nonzero)],

color=['lightcoral', 'lightblue'])

plt.title(f'Seleção de Features pelo Lasso\nAcurácia: {selection_accuracy:.1%}')

plt.ylabel('Número de Features')

# Plot 3: Performance vs Alpha

plt.subplot(2, 2, 3)

alphas = param_grid['alpha']

cv_scores = -grid_search.cv_results_['mean_test_score']

plt.semilogx(alphas, cv_scores, 'o-', linewidth=2)

plt.xlabel('Alpha')

plt.ylabel('MSE')

plt.title('Performance vs Parâmetro Alpha')

plt.grid(True, alpha=0.3)

# Plot 4: Comparação de MSE

plt.subplot(2, 2, 4)

model_names = list(results.keys()) + ['Lasso Otimizado']

mses = [results[name]['mse'] for name in results.keys()] + [final_mse]

plt.bar(model_names, mses, color=['skyblue', 'lightgreen', 'gold', 'lightcoral'])

plt.ylabel('MSE')

plt.title('Comparação de Erro Quadrático Médio')

plt.xticks(rotation=45)

plt.tight_layout()

plt.show()

# Análise detalhada da seleção de features

print(f"\n--- Análise Detalhada da Seleção de Features ---")

print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

print(f"Coeficientes Lasso não-zero: {np.sum(best_lasso.coef_ != 0)}")

print(f"Features corretamente selecionadas: {np.sum((best_lasso.coef_ != 0) & (true_coef != 0))}")

print(f"Features corretamente excluídas: {np.sum((best_lasso.coef_ == 0) & (true_coef == 0))}")

print(f"Acurácia total na seleção: {selection_accuracy:.1%}")

# Exemplo de interpretação do modelo

print(f"\n--- Interpretação do Modelo Lasso ---")

print("Features mais importantes (maiores coeficientes em valor absoluto):")

important_features = np.argsort(np.abs(best_lasso.coef_))[::-1][:5]

for i, feat_idx in enumerate(important_features):

if best_lasso.coef_[feat_idx] != 0:

print(f"Feature {feat_idx:2d}: coeficiente = {best_lasso.coef_[feat_idx]:.3f}")

Vantagens e Limitações do Lasso

Embora o Lasso seja poderoso, é importante compreender suas características:

Vantagens

Seleção automática de features
Modelos mais interpretáveis
Bom para high-dimensional data
Prevenção de overfitting

Limitações

Pode selecionar apenas uma feature de grupo correlacionado
Sensível à escala dos dados
Pode não performar bem quando todas features são relevantes
Requer ajuste cuidadoso do parâmetro alpha

Casos de Uso Recomendados

O Lasso é particularmente útil em:

Problemas com muitas features e amostras limitadas
Quando se deseja interpretabilidade do modelo
Para seleção de features automática
Em datasets onde muitas features são irrelevantes

Enfim, o Lasso representa uma ferramenta valiosa no arsenal de machine learning, combinando regularização com seleção de features de maneira eficiente e interpretável.

Referência: https://scikit-learn.org/0.21/modules/linear_model.html#lasso

Regressão com SVM: previsões precisas além da linha reta

19/12/202518/10/2025 Por antonino

Quando prever o futuro exige mais que uma simples reta

Você já tentou prever preços de imóveis ou demanda de produtos usando regressão linear e ficou frustrado com os resultados? O problema é que o mundo real raramente segue linhas retas perfeitas. É aqui que a Regressão com Máquinas de Vetores de Suporte (SVR) brilha – ela encontra padrões complexos que outros modelos ignoram, criando previsões surpreendentemente precisas mesmo em dados caóticos.

Como o SVR vê o mundo de forma diferente

Enquanto a regressão linear tupa minimizar erros para todos os pontos igualmente, o SVR cria uma “faixa de tolerância” onde pequenos erros são aceitáveis. Pense em prever o tempo de entrega de um pedido: você se importa mais com atrasos significativos do que com variações de minutos. O SVR funciona exatamente assim – ele foca nos casos mais difíceis (os support vectors) e ignora pequenas flutuações, resultando em modelos mais robustos e generalizáveis.

Do conceito ao código: prevendo valores de ações

"""
Previsão de séries temporais com Support Vector Regression
Exemplo prático com dados do mercado financeiro
"""
import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score

# Simulando dados de preços de ações (valores fictícios)
dias = np.arange(1, 101).reshape(-1, 1)  # 100 dias de trading
# Preços com tendência de alta + sazonalidade + ruído
precos = 100 + 0.5 * dias.flatten() + 10 * np.sin(dias.flatten() * 0.5) + np.random.normal(0, 3, 100)

print("📈 PREVISÃO DE SÉRIES TEMPORAIS COM SVR")
print("=" * 50)

# Preparando os dados para treinamento
X = dias[:-20]  # Usamos 80 primeiros dias para treinar
y = precos[:-20]
X_futuro = dias[-20:]  # Últimos 20 dias para prever
y_real_futuro = precos[-20:]

# Normalização CRUCIAL para SVR
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_futuro_scaled = scaler.transform(X_futuro)

# Criando e treinando o modelo SVR com kernel RBF
modelo_svr = SVR(kernel='rbf', C=10.0, epsilon=0.1, gamma=0.1)
modelo_svr.fit(X_scaled, y)

# Fazendo previsões para os próximos dias
previsoes = modelo_svr.predict(X_futuro_scaled)

# Avaliando a performance do modelo
mae = mean_absolute_error(y_real_futuro, previsoes)
r2 = r2_score(y_real_futuro, previsoes)

print(f"📊 Métricas de performance:")
print(f"Erro absoluto médio: {mae:.2f} pontos")
print(f"R² Score: {r2:.3f}")

# Previsão para um dia específico
dia_especifico = [[115]]  # 15 dias no futuro
dia_especifico_scaled = scaler.transform(dia_especifico)
previsao_especifica = modelo_svr.predict(dia_especifico_scaled)

print(f"\n🔮 Previsão para o dia 115:")
print(f"Preço estimado: {previsao_especifica[0]:.2f}")

"""

Previsão de séries temporais com Support Vector Regression

Exemplo prático com dados do mercado financeiro

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.svm import SVR

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_absolute_error, r2_score

# Simulando dados de preços de ações (valores fictícios)

dias = np.arange(1, 101).reshape(-1, 1) # 100 dias de trading

# Preços com tendência de alta + sazonalidade + ruído

precos = 100 + 0.5 * dias.flatten() + 10 * np.sin(dias.flatten() * 0.5) + np.random.normal(0, 3, 100)

print("📈 PREVISÃO DE SÉRIES TEMPORAIS COM SVR")

print("=" * 50)

# Preparando os dados para treinamento

X = dias[:-20] # Usamos 80 primeiros dias para treinar

y = precos[:-20]

X_futuro = dias[-20:] # Últimos 20 dias para prever

y_real_futuro = precos[-20:]

# Normalização CRUCIAL para SVR

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

X_futuro_scaled = scaler.transform(X_futuro)

# Criando e treinando o modelo SVR com kernel RBF

modelo_svr = SVR(kernel='rbf', C=10.0, epsilon=0.1, gamma=0.1)

modelo_svr.fit(X_scaled, y)

# Fazendo previsões para os próximos dias

previsoes = modelo_svr.predict(X_futuro_scaled)

# Avaliando a performance do modelo

mae = mean_absolute_error(y_real_futuro, previsoes)

r2 = r2_score(y_real_futuro, previsoes)

print(f"📊 Métricas de performance:")

print(f"Erro absoluto médio: {mae:.2f} pontos")

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

# Previsão para um dia específico

dia_especifico = [[115]] # 15 dias no futuro

dia_especifico_scaled = scaler.transform(dia_especifico)

previsao_especifica = modelo_svr.predict(dia_especifico_scaled)

print(f"\n🔮 Previsão para o dia 115:")

print(f"Preço estimado: {previsao_especifica[0]:.2f}")

Os segredos por trás do poder do SVR

O verdadeiro poder do SVR está nos kernels – funções matemáticas que transformam dados complexos em formatos linearmente separáveis. Imagine tentando separar círculos concêntricos com uma reta – é impossível em duas dimensões, mas torna-se trivial em três dimensões. Os kernels fazem exatamente esta mágica, mapeando seus dados para espaços onde relações não-lineares se tornam evidentes e modeláveis.

Escolhendo o kernel certo para seu problema

Linear: ideal quando a relação é aproximadamente linear e você precisa de velocidade
RBF (Radial Basis Function): padrão ouro para a maioria dos casos, captura padrões complexos
Polinomial: excelente para dados com interações entre features específicas
Sigmoid: similar a redes neurais, útil para alguns problemas específicos

Perguntas que todo praticante de machine learning faz

Você deve estar se perguntando: “Quando devo escolher SVR em vez de redes neurais ou random forests?” O SVR brilha quando você tem datasets pequenos a médios e relações complexas não-lineares. Uma confusão comum é achar que SVR sempre performa melhor – na verdade, ele exige dados bem preparados e normalizados. Outra dúvida frequente: “Por que o parâmetro C é tão importante?” Ele controla o trade-off entre ajustar-se perfeitamente aos dados de treino versus generalizar para novos dados.

Armadilhas que sabotam seu modelo SVR

Esquecer de normalizar: SVR é extremamente sensível à escala das features
C muito alto: causa overfitting, o modelo memoriza o ruído
Gamma muito baixo: o modelo fica muito simples e underfits os dados
Ignorar o epsilon: define quanta margem de erro é aceitável

O momento “aha!” dos vetores de suporte

Quando você finalmente visualiza como os vetores de suporte funcionam, toda a elegância do SVR se revela. Apenas uma pequena fração dos pontos de treino realmente importa para o modelo final – aqueles que estão nas bordas da faixa de tolerância. Esta eficiência não apenas torna o modelo mais interpretável mas também mais rápido para fazer previsões, já que apenas os vetores de suporte influenciam o resultado.

Otimizando seu modelo como um expert

"""
Otimização de hiperparâmetros com Grid Search
Encontrando a combinação perfeita para seus dados
"""
from sklearn.model_selection import GridSearchCV

print("🎯 OTIMIZAÇÃO DE HIPERPARÂMETROS")
print("=" * 40)

# Definindo os parâmetros para testar
param_grid = {
    'C': [0.1, 1, 10, 100],
    'epsilon': [0.01, 0.1, 0.5, 1.0],
    'gamma': ['scale', 'auto', 0.1, 1]
}

# Buscando a melhor combinação
grid_search = GridSearchCV(SVR(kernel='rbf'), param_grid, cv=5, scoring='r2')
grid_search.fit(X_scaled, y)

print(f"Melhores parâmetros: {grid_search.best_params_}")
print(f"Melhor score R²: {grid_search.best_score_:.3f}")

# Usando o modelo otimizado
melhor_modelo = grid_search.best_estimator_
previsoes_otimizadas = melhor_modelo.predict(X_futuro_scaled)
r2_otimizado = r2_score(y_real_futuro, previsoes_otimizadas)

print(f"R² após otimização: {r2_otimizado:.3f}")
print(f"Melhoria: {r2_otimizado - r2:.3f}")

"""

Otimização de hiperparâmetros com Grid Search

Encontrando a combinação perfeita para seus dados

"""

from sklearn.model_selection import GridSearchCV

print("🎯 OTIMIZAÇÃO DE HIPERPARÂMETROS")

print("=" * 40)

# Definindo os parâmetros para testar

param_grid = {

'C': [0.1, 1, 10, 100],

'epsilon': [0.01, 0.1, 0.5, 1.0],

'gamma': ['scale', 'auto', 0.1, 1]

}

# Buscando a melhor combinação

grid_search = GridSearchCV(SVR(kernel='rbf'), param_grid, cv=5, scoring='r2')

grid_search.fit(X_scaled, y)

print(f"Melhores parâmetros: {grid_search.best_params_}")

print(f"Melhor score R²: {grid_search.best_score_:.3f}")

# Usando o modelo otimizado

melhor_modelo = grid_search.best_estimator_

previsoes_otimizadas = melhor_modelo.predict(X_futuro_scaled)

r2_otimizado = r2_score(y_real_futuro, previsoes_otimizadas)

print(f"R² após otimização: {r2_otimizado:.3f}")

print(f"Melhoria: {r2_otimizado - r2:.3f}")

Transformando conhecimento em resultados práticos

Comece aplicando SVR em problemas do mundo real como previsão de vendas, análise de sensores ou qualquer dataset com relações não-lineares. Practice ajustando manualmente os hiperparâmetros para desenvolver intuição sobre seu efeito no modelo. Posteriormente, automatize este processo com GridSearchCV para garantir que você está sempre usando a melhor configuração possível para seus dados específicos.

Indo além do básico

Análise de sensibilidade: entenda como cada feature impacta suas previsões
Ensemble methods: combine SVR com outros algoritmos para melhor performance
Feature engineering: crie features que maximizem o poder do kernel RBF
Visualização: use gráficos para entender como o modelo está tomando decisões

Para dominar completamente o SVR

Estes recursos oferecem desde fundamentos teóricos até aplicações avançadas, permitindo que você evolua de usuário básico para especialista em Support Vector Regression.