Arquivo de regressao - Página 2 de 4

Modelos Lineares Generalizados: Rede Elástica

19/12/202518/10/2025 Por antonino

Anteriormente exploramos o Lasso e Ridge como técnicas de regularização separadas. Analogamente, a Rede Elástica (Elastic Net) combina as penalidades L1 e L2, oferecendo os benefícios de ambas as abordagens em um único modelo.

Conceito Fundamental da Elastic Net

Primordialmente, a Elastic Net aborda algumas limitações do Lasso, especialmente quando lidamos com features altamente correlacionadas. Decerto, enquanto o Lasso tende a selecionar apenas uma feature de um grupo correlacionado, a Elastic Net pode selecionar todo o grupo.

Conforme a documentação do scikit-learn, a Elastic Net é particularmente útil quando o número de features é maior que o número de amostras, ou quando há alta correlação entre as features. Similarmente às outras técnicas de regularização, ela ajuda a prevenir overfitting.

Formulação Matemática

O objetivo da Elastic Net é minimizar a seguinte função:

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

Onde:

X é a matriz de features
y é o vetor target
w são os coeficientes do modelo
α é o parâmetro de regularização principal
ρ é a razão de mistura L1 (l1_ratio)
||w||₁ é a norma L1 (penalidade Lasso)
||w||₂² é a norma L2 ao quadrado (penalidade Ridge)

Características Principais

Inegavelmente, a Elastic Net combina as melhores propriedades do Lasso e Ridge:

Seleção de features: Herda a capacidade de zerar coeficientes do Lasso
Estabilidade com correlação: Herda a robustez do Ridge com features correlacionadas
Controle flexível: Parâmetro l1_ratio controla o balanceamento entre L1 e L2
Performance em high-dimension: Funciona bem quando p > n

Interpretação do Parâmetro l1_ratio

O parâmetro l1_ratio controla a mistura entre Lasso e Ridge:

l1_ratio = 1: Elastic Net se torna Lasso puro
l1_ratio = 0: Elastic Net se torna Ridge puro
0 < l1_ratio < 1: Combinação balanceada entre L1 e L2

Vantagens sobre Lasso e Ridge

Embora Lasso e Ridge sejam úteis, a Elastic Net oferece vantagens em cenários específicos:

Features correlacionadas: Lasso seleciona aleatoriamente, Elastic Net seleciona grupo
Seleção de variáveis: Mantém a capacidade de seleção do Lasso
Estabilidade: Mais estável que Lasso com alta correlação
Performance preditiva: Frequentemente supera ambos em prática

Exemplo Prático: Elastic Net em Ação

Ademais, vejamos um exemplo completo demonstrando o uso da Elastic Net:

'''
Aplicação da Elastic Net para Regressão
Este exemplo demonstra como a Elastic Net combina
as vantagens do Lasso e Ridge em diferentes cenários
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import ElasticNet, Lasso, Ridge
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 features correlacionadas
n_samples = 500
n_features = 20
n_informative = 8

print("Configuração do Dataset:")
print(f"Número de amostras: {n_samples}")
print(f"Número de features: {n_features}")
print(f"Features informativas: {n_informative}")

# Gerar dados com grupos de features correlacionadas
X, y, true_coef = make_regression(n_samples=n_samples, n_features=n_features,
                                 n_informative=n_informative, noise=20,
                                 coef=True, random_state=42)

# Adicionar correlação entre algumas features
rng = np.random.RandomState(42)
for i in range(0, n_informative, 2):
    if i + 1 < n_informative:
        X[:, i+1] = X[:, i] * 0.7 + rng.normal(0, 0.1, n_samples)

print(f"\nDimensões: X {X.shape}, y {y.shape}")

# 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
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"\n--- Comparação: Elastic Net vs Lasso vs Ridge ---")

# Elastic Net
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)
elastic_net.fit(X_train_scaled, y_train)
y_pred_en = elastic_net.predict(X_test_scaled)
mse_en = mean_squared_error(y_test, y_pred_en)
r2_en = r2_score(y_test, y_pred_en)

# Lasso
lasso = Lasso(alpha=0.1, max_iter=10000, random_state=42)
lasso.fit(X_train_scaled, y_train)
y_pred_lasso = lasso.predict(X_test_scaled)
mse_lasso = mean_squared_error(y_test, y_pred_lasso)
r2_lasso = r2_score(y_test, y_pred_lasso)

# Ridge
ridge = Ridge(alpha=0.1, random_state=42)
ridge.fit(X_train_scaled, y_train)
y_pred_ridge = ridge.predict(X_test_scaled)
mse_ridge = mean_squared_error(y_test, y_pred_ridge)
r2_ridge = r2_score(y_test, y_pred_ridge)

print(f"\nElastic Net:")
print(f"MSE: {mse_en:.2f}, R²: {r2_en:.4f}")
print(f"Features selecionadas: {np.sum(elastic_net.coef_ != 0)}")

print(f"\nLasso:")
print(f"MSE: {mse_lasso:.2f}, R²: {r2_lasso:.4f}")
print(f"Features selecionadas: {np.sum(lasso.coef_ != 0)}")

print(f"\nRidge:")
print(f"MSE: {mse_ridge:.2f}, R²: {r2_ridge:.4f}")
print(f"Features selecionadas: {np.sum(ridge.coef_ != 0)}")

# Otimização dos hiperparâmetros da Elastic Net
print(f"\n--- Otimização dos Hiperparâmetros da Elastic Net ---")

param_grid = {
    'alpha': [0.001, 0.01, 0.1, 1, 10],
    'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]
}

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

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

# Modelo Elastic Net otimizado
best_en = grid_search.best_estimator_
y_pred_best = best_en.predict(X_test_scaled)
final_mse = mean_squared_error(y_test, y_pred_best)
final_r2 = r2_score(y_test, y_pred_best)

print(f"\nElastic Net Otimizado:")
print(f"MSE: {final_mse:.2f}, R²: {final_r2:.4f}")
print(f"Features selecionadas: {np.sum(best_en.coef_ != 0)}")

# Visualização dos resultados
plt.figure(figsize=(15, 10))

# Plot 1: Comparação de coeficientes
plt.subplot(2, 3, 1)
features = range(len(true_coef))
plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=6)
plt.plot(features, elastic_net.coef_, 's-', label='Elastic Net', alpha=0.8)
plt.plot(features, lasso.coef_, '^-', label='Lasso', alpha=0.8)
plt.plot(features, ridge.coef_, 'd-', label='Ridge', alpha=0.8)
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
plt.subplot(2, 3, 2)
methods = ['Elastic Net', 'Lasso', 'Ridge']
n_selected = [np.sum(elastic_net.coef_ != 0),
              np.sum(lasso.coef_ != 0),
              np.sum(ridge.coef_ != 0)]

plt.bar(methods, n_selected, color=['lightcoral', 'lightgreen', 'skyblue'])
plt.ylabel('Número de Features Selecionadas')
plt.title('Seleção de Features')
plt.xticks(rotation=45)

# Plot 3: Comparação de performance
plt.subplot(2, 3, 3)
mses = [mse_en, mse_lasso, mse_ridge]
plt.bar(methods, mses, color=['lightcoral', 'lightgreen', 'skyblue'])
plt.ylabel('MSE')
plt.title('Comparação de Performance')
plt.xticks(rotation=45)

# Plot 4: Análise do parâmetro l1_ratio
plt.subplot(2, 3, 4)
l1_ratios = param_grid['l1_ratio']
cv_scores = []

for l1_ratio in l1_ratios:
    model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)
    model.fit(X_train_scaled, y_train)
    y_pred = model.predict(X_test_scaled)
    mse = mean_squared_error(y_test, y_pred)
    cv_scores.append(mse)

plt.plot(l1_ratios, cv_scores, 'o-', linewidth=2)
plt.xlabel('l1_ratio')
plt.ylabel('MSE')
plt.title('Performance vs l1_ratio (alpha=0.1)')
plt.grid(True, alpha=0.3)

# Plot 5: Esparsidade vs l1_ratio
plt.subplot(2, 3, 5)
sparsity_levels = []

for l1_ratio in l1_ratios:
    model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)
    model.fit(X_train_scaled, y_train)
    sparsity = np.sum(model.coef_ != 0)
    sparsity_levels.append(sparsity)

plt.plot(l1_ratios, sparsity_levels, 'o-', linewidth=2)
plt.xlabel('l1_ratio')
plt.ylabel('Features Não-Zero')
plt.title('Esparsidade vs l1_ratio')
plt.grid(True, alpha=0.3)

# Plot 6: Matriz de resultados do GridSearch
plt.subplot(2, 3, 6)
results = grid_search.cv_results_
scores = -results['mean_test_score']
alphas = results['param_alpha'].data
l1_ratios = results['param_l1_ratio'].data

# Encontrar melhor combinação
best_idx = np.argmin(scores)
best_alpha = alphas[best_idx]
best_l1_ratio = l1_ratios[best_idx]

plt.scatter(l1_ratios, scores, c=scores, cmap='viridis', s=100, alpha=0.7)
plt.colorbar(label='MSE')
plt.xlabel('l1_ratio')
plt.ylabel('MSE')
plt.title(f'GridSearch: Melhor alpha={best_alpha}, l1_ratio={best_l1_ratio}')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise de grupos correlacionados
print(f"\n--- Análise de Grupos Correlacionados ---")

# Identificar features correlacionadas
correlation_matrix = np.corrcoef(X_train_scaled.T)
high_correlation = np.sum(np.abs(correlation_matrix) > 0.6) - n_features

print(f"Pares de features com correlação > 0.6: {high_correlation//2}")

# Verificar como cada método lida com features correlacionadas
print(f"\nComportamento com Features Correlacionadas:")

# Encontrar pares correlacionados
correlated_pairs = []
for i in range(n_features):
    for j in range(i+1, n_features):
        if abs(correlation_matrix[i, j]) > 0.6:
            correlated_pairs.append((i, j))

for i, (idx1, idx2) in enumerate(correlated_pairs[:3]):  # Mostrar apenas os 3 primeiros
    print(f"\nPar {i+1}: Features {idx1} e {idx2}")
    print(f"  Elastic Net: {best_en.coef_[idx1]:.3f}, {best_en.coef_[idx2]:.3f}")
    print(f"  Lasso: {lasso.coef_[idx1]:.3f}, {lasso.coef_[idx2]:.3f}")
    print(f"  Ridge: {ridge.coef_[idx1]:.3f}, {ridge.coef_[idx2]:.3f}")

# Resumo final
print(f"\n--- Resumo Final ---")
print(f"Melhor modelo: Elastic Net com l1_ratio={grid_search.best_params_['l1_ratio']}")
print(f"Melhoria sobre Lasso: {(mse_lasso - final_mse)/mse_lasso*100:.1f}%")
print(f"Melhoria sobre Ridge: {(mse_ridge - final_mse)/mse_ridge*100:.1f}%")
print(f"Features corretamente identificadas: {np.sum((best_en.coef_ != 0) == (true_coef != 0))}/{n_features}")

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

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

'''

Aplicação da Elastic Net para Regressão

Este exemplo demonstra como a Elastic Net combina

as vantagens do Lasso e Ridge em diferentes cenários

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import ElasticNet, Lasso, Ridge

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 features correlacionadas

n_samples = 500

n_features = 20

n_informative = 8

print("Configuração do Dataset:")

print(f"Número de amostras: {n_samples}")

print(f"Número de features: {n_features}")

print(f"Features informativas: {n_informative}")

# Gerar dados com grupos de features correlacionadas

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

n_informative=n_informative, noise=20,

coef=True, random_state=42)

# Adicionar correlação entre algumas features

rng = np.random.RandomState(42)

for i in range(0, n_informative, 2):

if i + 1 < n_informative:

X[:, i+1] = X[:, i] * 0.7 + rng.normal(0, 0.1, n_samples)

print(f"\nDimensões: X {X.shape}, y {y.shape}")

# 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

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(f"\n--- Comparação: Elastic Net vs Lasso vs Ridge ---")

# Elastic Net

elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)

elastic_net.fit(X_train_scaled, y_train)

y_pred_en = elastic_net.predict(X_test_scaled)

mse_en = mean_squared_error(y_test, y_pred_en)

r2_en = r2_score(y_test, y_pred_en)

# Lasso

lasso = Lasso(alpha=0.1, max_iter=10000, random_state=42)

lasso.fit(X_train_scaled, y_train)

y_pred_lasso = lasso.predict(X_test_scaled)

mse_lasso = mean_squared_error(y_test, y_pred_lasso)

r2_lasso = r2_score(y_test, y_pred_lasso)

# Ridge

ridge = Ridge(alpha=0.1, random_state=42)

ridge.fit(X_train_scaled, y_train)

y_pred_ridge = ridge.predict(X_test_scaled)

mse_ridge = mean_squared_error(y_test, y_pred_ridge)

r2_ridge = r2_score(y_test, y_pred_ridge)

print(f"\nElastic Net:")

print(f"MSE: {mse_en:.2f}, R²: {r2_en:.4f}")

print(f"Features selecionadas: {np.sum(elastic_net.coef_ != 0)}")

print(f"\nLasso:")

print(f"MSE: {mse_lasso:.2f}, R²: {r2_lasso:.4f}")

print(f"Features selecionadas: {np.sum(lasso.coef_ != 0)}")

print(f"\nRidge:")

print(f"MSE: {mse_ridge:.2f}, R²: {r2_ridge:.4f}")

print(f"Features selecionadas: {np.sum(ridge.coef_ != 0)}")

# Otimização dos hiperparâmetros da Elastic Net

print(f"\n--- Otimização dos Hiperparâmetros da Elastic Net ---")

param_grid = {

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

'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]

}

grid_search = GridSearchCV(ElasticNet(max_iter=10000, random_state=42),

param_grid, cv=5, scoring='neg_mean_squared_error',

n_jobs=-1)

grid_search.fit(X_train_scaled, y_train)

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

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

# Modelo Elastic Net otimizado

best_en = grid_search.best_estimator_

y_pred_best = best_en.predict(X_test_scaled)

final_mse = mean_squared_error(y_test, y_pred_best)

final_r2 = r2_score(y_test, y_pred_best)

print(f"\nElastic Net Otimizado:")

print(f"MSE: {final_mse:.2f}, R²: {final_r2:.4f}")

print(f"Features selecionadas: {np.sum(best_en.coef_ != 0)}")

# Visualização dos resultados

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

# Plot 1: Comparação de coeficientes

plt.subplot(2, 3, 1)

features = range(len(true_coef))

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

plt.plot(features, elastic_net.coef_, 's-', label='Elastic Net', alpha=0.8)

plt.plot(features, lasso.coef_, '^-', label='Lasso', alpha=0.8)

plt.plot(features, ridge.coef_, 'd-', label='Ridge', alpha=0.8)

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

plt.subplot(2, 3, 2)

methods = ['Elastic Net', 'Lasso', 'Ridge']

n_selected = [np.sum(elastic_net.coef_ != 0),

np.sum(lasso.coef_ != 0),

np.sum(ridge.coef_ != 0)]

plt.bar(methods, n_selected, color=['lightcoral', 'lightgreen', 'skyblue'])

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

plt.title('Seleção de Features')

plt.xticks(rotation=45)

# Plot 3: Comparação de performance

plt.subplot(2, 3, 3)

mses = [mse_en, mse_lasso, mse_ridge]

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

plt.ylabel('MSE')

plt.title('Comparação de Performance')

plt.xticks(rotation=45)

# Plot 4: Análise do parâmetro l1_ratio

plt.subplot(2, 3, 4)

l1_ratios = param_grid['l1_ratio']

cv_scores = []

for l1_ratio in l1_ratios:

model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)

model.fit(X_train_scaled, y_train)

y_pred = model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

cv_scores.append(mse)

plt.plot(l1_ratios, cv_scores, 'o-', linewidth=2)

plt.xlabel('l1_ratio')

plt.ylabel('MSE')

plt.title('Performance vs l1_ratio (alpha=0.1)')

plt.grid(True, alpha=0.3)

# Plot 5: Esparsidade vs l1_ratio

plt.subplot(2, 3, 5)

sparsity_levels = []

for l1_ratio in l1_ratios:

model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)

model.fit(X_train_scaled, y_train)

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

sparsity_levels.append(sparsity)

plt.plot(l1_ratios, sparsity_levels, 'o-', linewidth=2)

plt.xlabel('l1_ratio')

plt.ylabel('Features Não-Zero')

plt.title('Esparsidade vs l1_ratio')

plt.grid(True, alpha=0.3)

# Plot 6: Matriz de resultados do GridSearch

plt.subplot(2, 3, 6)

results = grid_search.cv_results_

scores = -results['mean_test_score']

alphas = results['param_alpha'].data

l1_ratios = results['param_l1_ratio'].data

# Encontrar melhor combinação

best_idx = np.argmin(scores)

best_alpha = alphas[best_idx]

best_l1_ratio = l1_ratios[best_idx]

plt.scatter(l1_ratios, scores, c=scores, cmap='viridis', s=100, alpha=0.7)

plt.colorbar(label='MSE')

plt.xlabel('l1_ratio')

plt.ylabel('MSE')

plt.title(f'GridSearch: Melhor alpha={best_alpha}, l1_ratio={best_l1_ratio}')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise de grupos correlacionados

print(f"\n--- Análise de Grupos Correlacionados ---")

# Identificar features correlacionadas

correlation_matrix = np.corrcoef(X_train_scaled.T)

high_correlation = np.sum(np.abs(correlation_matrix) > 0.6) - n_features

print(f"Pares de features com correlação > 0.6: {high_correlation//2}")

# Verificar como cada método lida com features correlacionadas

print(f"\nComportamento com Features Correlacionadas:")

# Encontrar pares correlacionados

correlated_pairs = []

for i in range(n_features):

for j in range(i+1, n_features):

if abs(correlation_matrix[i, j]) > 0.6:

correlated_pairs.append((i, j))

for i, (idx1, idx2) in enumerate(correlated_pairs[:3]): # Mostrar apenas os 3 primeiros

print(f"\nPar {i+1}: Features {idx1} e {idx2}")

print(f" Elastic Net: {best_en.coef_[idx1]:.3f}, {best_en.coef_[idx2]:.3f}")

print(f" Lasso: {lasso.coef_[idx1]:.3f}, {lasso.coef_[idx2]:.3f}")

print(f" Ridge: {ridge.coef_[idx1]:.3f}, {ridge.coef_[idx2]:.3f}")

# Resumo final

print(f"\n--- Resumo Final ---")

print(f"Melhor modelo: Elastic Net com l1_ratio={grid_search.best_params_['l1_ratio']}")

print(f"Melhoria sobre Lasso: {(mse_lasso - final_mse)/mse_lasso*100:.1f}%")

print(f"Melhoria sobre Ridge: {(mse_ridge - final_mse)/mse_ridge*100:.1f}%")

print(f"Features corretamente identificadas: {np.sum((best_en.coef_ != 0) == (true_coef != 0))}/{n_features}")

Casos de Uso Recomendados

A Elastic Net é particularmente eficaz em:

Features altamente correlacionadas: Quando o Lasso falha em selecionar grupos
Problemas de alta dimensionalidade: Quando p > n
Seleção de variáveis com estabilidade: Combinando sparsity e robustez
Quando não se sabe qual regularização usar: Elastic Net como abordagem padrão

Considerações Práticas

Algumas recomendações importantes para uso eficaz:

Sempre normalize os dados antes de usar Elastic Net
Use GridSearchCV ou RandomizedSearchCV para otimizar alpha e l1_ratio
Comece com l1_ratio=0.5 como ponto de partida
Considere a complexidade computacional para datasets muito grandes

Variantes da Elastic Net

O scikit-learn também oferece variantes especializadas:

ElasticNetCV: Com validação cruzada embutida para seleção de parâmetros
MultiTaskElasticNet: Para problemas com múltiplos targets

Enfim, a Elastic Net representa uma abordagem robusta e flexível que combina os pontos fortes do Lasso e Ridge, tornando-se frequentemente a escolha preferida para problemas de regressão regularizada na prática.

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

Máquinas de Vetores de Suporte: Problemas Desbalanceados

19/12/202518/10/2025 Por antonino

Continuando nossa exploração detalhada das Máquinas de Vetores de Suporte, abordaremos agora o desafio crucial dos problemas desbalanceados. Primordialmente, datasets com distribuição desigual de classes representam um cenário comum em aplicações do mundo real, onde estratégias específicas são necessárias para garantir performance adequada.

O Desafio do Desbalanceamento

Analogamente aos problemas balanceados que discutimos anteriormente, os datasets desbalanceados apresentam desafios únicos para classificadores SVM. Conforme observamos na implementação padrão, as SVM buscam maximizar a margem global, o que pode levar a viés em favor da classe majoritária quando as distribuições são assimétricas.

Impacto no Hiperplano de Decisão

Em problemas desbalanceados, o hiperplano ótimo tende a ser deslocado em direção à classe minoritária:

\(w^T x + b = 0\)

Onde o viés b é influenciado pela distribuição desbalanceada das classes.

Estratégias para Lidar com Desbalanceamento

Parâmetro class_weight

O scikit-learn oferece o parâmetro class_weight que permite atribuir pesos diferentes às classes:

class_weight='balanced': Pesos inversamente proporcionais às frequências das classes
class_weight={0: w0, 1: w1}: Pesos customizados para cada classe

Cálculo dos Pesos Automáticos

Quando class_weight='balanced', os pesos são calculados como:

\(w_j = \frac{n}{k \cdot n_j}\)

Onde n é o número total de amostras, k o número de classes, e n_j o número de amostras na classe j.

Modificação da Função Objetivo

Com pesos de classe, a função objetivo do SVM torna-se:

\(\min_{w, b, \xi} \frac{1}{2} \|w\|^2 + C \sum_{i=1}^n w_{y_i} \xi_i\)

Sujeito a:

\(y_i(w^T x_i + b) \geq 1 – \xi_i \quad \text{e} \quad \xi_i \geq 0\)

Onde w_{y_i} é o peso associado à classe da amostra i.

Técnicas Complementares

Ampliação de Dados (Oversampling)

SMOTE: Synthetic Minority Over-sampling Technique
ADASYN: Adaptive Synthetic Sampling
Random Oversampling: Duplicação de amostras da classe minoritária

Redução de Dados (Undersampling)

Random Undersampling: Remoção aleatória de amostras da classe majoritária
Cluster Centroids: Baseado em agrupamento
Tomek Links: Remoção de pares de amostras próximas de classes diferentes

Métricas de Avaliação para Desbalanceamento

Similarmente às métricas padrão que exploramos anteriormente, problemas desbalanceados requerem avaliação mais sofisticada:

Precision: TP / (TP + FP)
Recall: TP / (TP + FN)
F1-Score: Média harmônica entre precision e recall
ROC-AUC: Área sob a curva ROC
Precision-Recall AUC: Área sob a curva Precision-Recall

Implementação no scikit-learn

Parâmetros Relevantes

class_weight: Controle de pesos por classe
C: Parâmetro de regularização (pode ser ajustado)
kernel: Escolha do kernel (RBF geralmente mais robusto)

Integração com Técnicas de Amostragem

O scikit-learn oferece classes para amostragem através do módulo imbalanced-learn (não nativo):

RandomOverSampler
SMOTE
RandomUnderSampler

Conexões com Tópicos Anteriores

Analogamente aos conceitos que exploramos em classificação balanceada, o tratamento de desbalanceamento:

Mantém os princípios fundamentais de maximização de margem
Estende a formulação matemática através de pesos
Preserva a interpretação dos vetores de suporte
Requer avaliação mais cuidadosa similar a problemas complexos

Exemplo Prático em Python

Para ilustrar as estratégias de tratamento de problemas desbalanceados com SVM, implementemos um estudo comparativo detalhado:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score
from sklearn.datasets import make_classification
from sklearn.preprocessing import StandardScaler
import warnings
warnings.filterwarnings('ignore')
 
'''
Estudo comparativo de estratégias para problemas desbalanceados com SVM
'''
 
print("=== PROBLEMAS DESBALANCEADOS COM SVM ===")
 
# Criando datasets com diferentes níveis de desbalanceamento
print("\n1. CONFIGURAÇÃO DOS CENÁRIOS DESBALANCEADOS")
 
# Cenário 1: Desbalanceamento moderado (80-20)
X_moderado, y_moderado = make_classification(
    n_samples=1000, n_features=2, n_informative=2, n_redundant=0,
    n_clusters_per_class=1, weights=[0.8, 0.2], random_state=42
)
 
# Cenário 2: Desbalanceamento severo (90-10)
X_severo, y_severo = make_classification(
    n_samples=1000, n_features=2, n_informative=2, n_redundant=0,
    n_clusters_per_class=1, weights=[0.9, 0.1], random_state=42
)
 
# Cenário 3: Desbalanceamento extremo (95-5)
X_extremo, y_extremo = make_classification(
    n_samples=1000, n_features=2, n_informative=2, n_redundant=0,
    n_clusters_per_class=1, weights=[0.95, 0.05], random_state=42
)
 
cenarios = [
    ('Moderado (80-20)', X_moderado, y_moderado),
    ('Severo (90-10)', X_severo, y_severo),
    ('Extremo (95-5)', X_extremo, y_extremo)
]
 
'''
Configuração das estratégias de tratamento
'''
print("\n2. CONFIGURAÇÃO DAS ESTRATÉGIAS")
 
# Diferentes abordagens para comparação
estrategias = {
    'SVC Padrão': SVC(kernel='rbf', random_state=42),
    'SVC Class Weight Balanced': SVC(kernel='rbf', class_weight='balanced', random_state=42),
    'SVC Class Weight Custom': SVC(kernel='rbf', class_weight={0: 1, 1: 5}, random_state=42),
    'SVC Ajustado C': SVC(kernel='rbf', C=0.1, class_weight='balanced', random_state=42)
}
 
'''
Avaliação sistemática por cenário
'''
print("\n3. AVALIAÇÃO DAS ESTRATÉGIAS POR CENÁRIO")
 
resultados_completos = {}
 
for cenario_nome, X, y in cenarios:
    print(f"\n--- {cenario_nome} ---")
    
    # Estatísticas do dataset
    unique, counts = np.unique(y, return_counts=True)
    n_total = len(y)
    ratios = {cls: count/n_total for cls, count in zip(unique, counts)}
    
    print(f"Distribuição: Classe 0: {counts[0]} ({ratios[0]:.1%}), "
          f"Classe 1: {counts[1]} ({ratios[1]:.1%})")
    
    # Padronização
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # Divisão treino-teste estratificada
    X_train, X_test, y_train, y_test = train_test_split(
        X_scaled, y, test_size=0.3, random_state=42, stratify=y
    )
    
    cenario_resultados = {}
    
    for estrategia_nome, estrategia_model in estrategias.items():
        print(f"  Avaliando {estrategia_nome}...")
        
        try:
            # Treinamento
            estrategia_model.fit(X_train, y_train)
            
            # Previsões
            y_pred = estrategia_model.predict(X_test)
            
            # Métricas básicas
            accuracy = accuracy_score(y_test, y_pred)
            precision = precision_score(y_test, y_pred)
            recall = recall_score(y_test, y_pred)
            f1 = f1_score(y_test, y_pred)
            
            # Probabilidades para AUC (se disponível)
            if hasattr(estrategia_model, 'predict_proba'):
                y_proba = estrategia_model.predict_proba(X_test)[:, 1]
                roc_auc = roc_auc_score(y_test, y_proba)
            else:
                # Usar decision function como proxy
                decision_scores = estrategia_model.decision_function(X_test)
                roc_auc = roc_auc_score(y_test, decision_scores)
            
            # Coletar informações
            model_info = {
                'model': estrategia_model,
                'accuracy': accuracy,
                'precision': precision,
                'recall': recall,
                'f1_score': f1,
                'roc_auc': roc_auc,
                'predictions': y_pred
            }
            
            # Vetores de suporte por classe
            if hasattr(estrategia_model, 'support_vectors_'):
                support_indices = estrategia_model.support_
                support_by_class = []
                for cls in unique:
                    class_support = np.sum(y_train[support_indices] == cls)
                    support_by_class.append(class_support)
                model_info['support_by_class'] = support_by_class
            
            cenario_resultados[estrategia_nome] = model_info
            
            print(f"    Accuracy: {accuracy:.3f}, Precision: {precision:.3f}, "
                  f"Recall: {recall:.3f}, F1: {f1:.3f}, AUC: {roc_auc:.3f}")
            
        except Exception as e:
            print(f"    ERRO: {e}")
            cenario_resultados[estrategia_nome] = {'error': str(e)}
    
    resultados_completos[cenario_nome] = cenario_resultados
 
'''
Visualização das fronteiras de decisão
'''
print("\n4. VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO")
 
for cenario_nome, X, y in cenarios:
    print(f"\nVisualizando {cenario_nome}...")
    
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # Criar mesh
    h = 0.02
    x_min, x_max = X_scaled[:, 0].min() - 1, X_scaled[:, 0].max() + 1
    y_min, y_max = X_scaled[:, 1].min() - 1, X_scaled[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    
    # Configurar subplots
    estrategias_visuais = list(estrategias.keys())
    n_strategies = len(estrategias_visuais)
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
    axes = axes.flatten()
    
    # Dados originais
    scatter = axes[0].scatter(X_scaled[:, 0], X_scaled[:, 1], c=y, cmap='coolwarm', alpha=0.8)
    axes[0].set_title(f'{cenario_nome}\nDados Originais')
    axes[0].set_xlabel('Feature 1')
    axes[0].set_ylabel('Feature 2')
    plt.colorbar(scatter, ax=axes[0])
    
    # Estratégias
    for idx, estrategia_nome in enumerate(estrategias_visuais, 1):
        if idx >= len(axes):
            break
            
        if estrategia_nome in resultados_completos[cenario_nome]:
            resultados = resultados_completos[cenario_nome][estrategia_nome]
            model = resultados['model']
            
            # Prever no mesh
            Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
            Z = Z.reshape(xx.shape)
            
            # Plot
            contour = axes[idx].contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')
            axes[idx].scatter(X_scaled[:, 0], X_scaled[:, 1], c=y, cmap='coolwarm', alpha=0.8)
            
            # Adicionar métricas no título
            f1 = resultados['f1_score']
            recall = resultados['recall']
            title = f'{estrategia_nome}\nF1: {f1:.3f}, Recall: {recall:.3f}'
            axes[idx].set_title(title)
            axes[idx].set_xlabel('Feature 1')
            axes[idx].set_ylabel('Feature 2')
    
    # Remover subplots não utilizados
    for i in range(len(estrategias_visuais) + 1, len(axes)):
        fig.delaxes(axes[i])
    
    plt.tight_layout()
    plt.show()
 
'''
Análise detalhada do recall por classe - VERSÃO CORRIGIDA
'''
print("\n5. ANÁLISE DETALHADA DO RECALL")

for cenario_nome, X, y in cenarios:
    print(f"\n{cenario_nome}:")
    print("="*80)
    print(f"{'Estratégia':<25} {'Recall Classe 0':<15} {'Recall Classe 1':<15} {'Diferença':<12}")
    print("="*80)
    
    if cenario_nome in resultados_completos:
        # CORREÇÃO: Recalcular y_test para cada cenário
        scaler = StandardScaler()
        X_scaled = scaler.fit_transform(X)
        X_train, X_test_correto, y_train, y_test_correto = train_test_split(
            X_scaled, y, test_size=0.3, random_state=42, stratify=y
        )
        
        for estrategia_nome, resultados in resultados_completos[cenario_nome].items():
            if 'error' not in resultados:
                # CORREÇÃO: Usar y_test_correto em vez de tentar recuperar do dicionário
                y_pred = resultados['predictions']
                
                # Verificar se os tamanhos são compatíveis
                if len(y_pred) == len(y_test_correto):
                    recall_0 = recall_score(y_test_correto, y_pred, pos_label=0)
                    recall_1 = recall_score(y_test_correto, y_pred, pos_label=1)
                    diferenca = abs(recall_0 - recall_1)
                    
                    print(f"{estrategia_nome:<25} {recall_0:<15.3f} {recall_1:<15.3f} {diferenca:<12.3f}")
                else:
                    print(f"{estrategia_nome:<25} {'Tamanho incompatível':<45}")

'''
Análise dos vetores de suporte - VERSÃO CORRIGIDA
'''
print("\n6. ANÁLISE DOS VETORES DE SUPORTE")

for cenario_nome, X, y in cenarios:
    print(f"\n{cenario_nome} - Distribuição dos Vetores de Suporte:")
    print("="*60)
    
    if cenario_nome in resultados_completos:
        for estrategia_nome, resultados in resultados_completos[cenario_nome].items():
            if 'error' not in resultados and 'support_by_class' in resultados:
                support_by_class = resultados['support_by_class']
                total_support = sum(support_by_class)
                
                if total_support > 0:
                    ratios = [s/total_support for s in support_by_class]
                    print(f"{estrategia_nome:<25}: Classe 0: {support_by_class[0]} ({ratios[0]:.1%}), "
                          f"Classe 1: {support_by_class[1]} ({ratios[1]:.1%})")

'''
Comparação de performance geral - VERSÃO CORRIGIDA
'''
print("\n7. COMPARAÇÃO DE PERFORMANCE GERAL")

print("\nTabela Comparativa - F1-Score por Cenário e Estratégia:")
print("\n" + "="*90)
header = f"{'Cenário':<20} {'SVC Padrão':<12} {'SVC Balanced':<12} {'SVC Custom':<12} {'SVC Ajustado':<12}"
print(header)
print("="*90)

for cenario_nome, X, y in cenarios:
    if cenario_nome in resultados_completos:
        row = f"{cenario_nome:<20}"
        
        for estrategia in ['SVC Padrão', 'SVC Class Weight Balanced', 
                          'SVC Class Weight Custom', 'SVC Ajustado C']:
            if (estrategia in resultados_completos[cenario_nome] and 
                'error' not in resultados_completos[cenario_nome][estrategia]):
                
                f1 = resultados_completos[cenario_nome][estrategia]['f1_score']
                row += f" {f1:<11.3f}"
            else:
                row += f" {'N/A':<11}"
        print(row)

'''
Análise do trade-off precision-recall - VERSÃO CORRIGIDA
'''
print("\n8. ANÁLISE DO TRADE-OFF PRECISION-RECALL")

for cenario_nome, X, y in cenarios:
    print(f"\n{cenario_nome} - Trade-off Precision vs Recall:")
    
    if cenario_nome in resultados_completos:
        for estrategia_nome, resultados in resultados_completos[cenario_nome].items():
            if 'error' not in resultados:
                precision = resultados['precision']
                recall = resultados['recall']
                f1 = resultados['f1_score']
                
                print(f"  {estrategia_nome:<25}: Precision={precision:.3f}, "
                      f"Recall={recall:.3f}, F1={f1:.3f}")

# CORREÇÃO: Adicionar análise de matriz de confusão
print("\n9. ANÁLISE DAS MATRIZES DE CONFUSÃO")

for cenario_nome, X, y in cenarios:
    print(f"\n{cenario_nome} - Matrizes de Confusão:")
    print("="*50)
    
    if cenario_nome in resultados_completos:
        # Recalcular split para este cenário
        scaler = StandardScaler()
        X_scaled = scaler.fit_transform(X)
        X_train, X_test_conf, y_train, y_test_conf = train_test_split(
            X_scaled, y, test_size=0.3, random_state=42, stratify=y
        )
        
        for estrategia_nome, resultados in resultados_completos[cenario_nome].items():
            if 'error' not in resultados:
                y_pred = resultados['predictions']
                
                if len(y_pred) == len(y_test_conf):
                    cm = confusion_matrix(y_test_conf, y_pred)
                    print(f"\n{estrategia_nome}:")
                    print(cm)
                    
                    # Adicionar interpretação
                    tn, fp, fn, tp = cm.ravel()
                    print(f"  TN: {tn}, FP: {fp}, FN: {fn}, TP: {tp}")
                else:
                    print(f"\n{estrategia_nome}: Tamanhos incompatíveis para matriz de confusão")

'''
Recomendações práticas para problemas desbalanceados - VERSÃO ATUALIZADA
'''
print("\n10. RECOMENDAÇÕES PRÁTICAS")

print("\nBaseado na análise experimental:")

print("\nEscolha da Estratégia por Nível de Desbalanceamento:")
print("  - Desbalanceamento leve (< 70-30): SVC padrão pode ser suficiente")
print("  - Desbalanceamento moderado (70-30 a 85-15): class_weight='balanced'")
print("  - Desbalanceamento severo (> 85-15): Pesos customizados + ajuste de C")

print("\nConfiguração de Pesos:")
print("  - 'balanced': Boa opção padrão para maioria dos casos")
print("  - Customizado: Quando se conhece os custos de erro por classe")
print("  - Baseado em dados: Calcular pesos baseados na distribuição real")

print("\nAjuste de Hiperparâmetros:")
print("  - Reduzir C para aumentar regularização em dados desbalanceados")
print("  - Kernel RBF geralmente mais robusto que linear")
print("  - Validar com validação cruzada estratificada")

print("\nMétricas de Avaliação:")
print("  - F1-Score: Métrica balanceada para comparação geral")
print("  - Recall: Crítico para detecção da classe minoritária")
print("  - Precision-Recall AUC: Melhor que ROC-AUC para desbalanceamento")
print("  - Matriz de confusão: Para análise detalhada dos erros")

print("\nTécnicas Complementares:")
print("  - Amostragem: SMOTE para oversampling inteligente")
print("  - Ensemble: Combinar múltiplas estratégias")
print("  - Threshold moving: Ajustar limiar de decisão pós-treinamento")

print("\nConsiderações por Domínio:")
print("  - Médico: Alta recall para detecção de doenças raras")
print("  - Fraude: Balancear recall e precision baseado em custos")
print("  - Manutenção: Recall crítico para detecção de falhas")
print("  - Marketing: Precision importante para custo de aquisição")

print("\nBoas Práticas:")
print("  - Sempre usar validação estratificada")
print("  - Reportar múltiplas métricas, não apenas acurácia")
print("  - Considerar custos de negócio na escolha da estratégia")
print("  - Documentar a distribuição das classes no dataset")
print("  - Testar diferentes abordagens antes de decidir")

# CORREÇÃO: Adicionar resumo dos resultados principais
print("\n11. RESUMO DOS RESULTADOS PRINCIPAIS")

print("\nPrincipais Insights Obtidos:")
for cenario_nome, X, y in cenarios:
    if cenario_nome in resultados_completos:
        print(f"\n{cenario_nome}:")
        
        # Encontrar melhor estratégia por F1-Score
        melhor_estrategia = None
        melhor_f1 = 0
        
        for estrategia_nome, resultados in resultados_completos[cenario_nome].items():
            if 'error' not in resultados and resultados['f1_score'] > melhor_f1:
                melhor_f1 = resultados['f1_score']
                melhor_estrategia = estrategia_nome
        
        if melhor_estrategia:
            melhor_resultado = resultados_completos[cenario_nome][melhor_estrategia]
            print(f"  Melhor estratégia: {melhor_estrategia} (F1: {melhor_f1:.3f})")
            print(f"  Precision: {melhor_resultado['precision']:.3f}, "
                  f"Recall: {melhor_resultado['recall']:.3f}, "
                  f"AUC: {melhor_resultado['roc_auc']:.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

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

import numpy as np

import matplotlib.pyplot as plt

from sklearn.svm import SVC

from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score

from sklearn.datasets import make_classification

from sklearn.preprocessing import StandardScaler

import warnings

warnings.filterwarnings('ignore')

'''

Estudo comparativo de estratégias para problemas desbalanceados com SVM

'''

print("=== PROBLEMAS DESBALANCEADOS COM SVM ===")

# Criando datasets com diferentes níveis de desbalanceamento

print("\n1. CONFIGURAÇÃO DOS CENÁRIOS DESBALANCEADOS")

# Cenário 1: Desbalanceamento moderado (80-20)

X_moderado, y_moderado = make_classification(

n_samples=1000, n_features=2, n_informative=2, n_redundant=0,

n_clusters_per_class=1, weights=[0.8, 0.2], random_state=42

)

# Cenário 2: Desbalanceamento severo (90-10)

X_severo, y_severo = make_classification(

n_samples=1000, n_features=2, n_informative=2, n_redundant=0,

n_clusters_per_class=1, weights=[0.9, 0.1], random_state=42

)

# Cenário 3: Desbalanceamento extremo (95-5)

X_extremo, y_extremo = make_classification(

n_samples=1000, n_features=2, n_informative=2, n_redundant=0,

n_clusters_per_class=1, weights=[0.95, 0.05], random_state=42

)

cenarios = [

('Moderado (80-20)', X_moderado, y_moderado),

('Severo (90-10)', X_severo, y_severo),

('Extremo (95-5)', X_extremo, y_extremo)

]

'''

Configuração das estratégias de tratamento

'''

print("\n2. CONFIGURAÇÃO DAS ESTRATÉGIAS")

# Diferentes abordagens para comparação

estrategias = {

'SVC Padrão': SVC(kernel='rbf', random_state=42),

'SVC Class Weight Balanced': SVC(kernel='rbf', class_weight='balanced', random_state=42),

'SVC Class Weight Custom': SVC(kernel='rbf', class_weight={0: 1, 1: 5}, random_state=42),

'SVC Ajustado C': SVC(kernel='rbf', C=0.1, class_weight='balanced', random_state=42)

}

'''

Avaliação sistemática por cenário

'''

print("\n3. AVALIAÇÃO DAS ESTRATÉGIAS POR CENÁRIO")

resultados_completos = {}

for cenario_nome, X, y in cenarios:

print(f"\n--- {cenario_nome} ---")

# Estatísticas do dataset

unique, counts = np.unique(y, return_counts=True)

n_total = len(y)

ratios = {cls: count/n_total for cls, count in zip(unique, counts)}

print(f"Distribuição: Classe 0: {counts[0]} ({ratios[0]:.1%}), "

f"Classe 1: {counts[1]} ({ratios[1]:.1%})")

# Padronização

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Divisão treino-teste estratificada

X_train, X_test, y_train, y_test = train_test_split(

X_scaled, y, test_size=0.3, random_state=42, stratify=y

)

cenario_resultados = {}

for estrategia_nome, estrategia_model in estrategias.items():

print(f" Avaliando {estrategia_nome}...")

try:

# Treinamento

estrategia_model.fit(X_train, y_train)

# Previsões

y_pred = estrategia_model.predict(X_test)

# Métricas básicas

accuracy = accuracy_score(y_test, y_pred)

precision = precision_score(y_test, y_pred)

recall = recall_score(y_test, y_pred)

f1 = f1_score(y_test, y_pred)

# Probabilidades para AUC (se disponível)

if hasattr(estrategia_model, 'predict_proba'):

y_proba = estrategia_model.predict_proba(X_test)[:, 1]

roc_auc = roc_auc_score(y_test, y_proba)

else:

# Usar decision function como proxy

decision_scores = estrategia_model.decision_function(X_test)

roc_auc = roc_auc_score(y_test, decision_scores)

# Coletar informações

model_info = {

'model': estrategia_model,

'accuracy': accuracy,

'precision': precision,

'recall': recall,

'f1_score': f1,

'roc_auc': roc_auc,

'predictions': y_pred

}

# Vetores de suporte por classe

if hasattr(estrategia_model, 'support_vectors_'):

support_indices = estrategia_model.support_

support_by_class = []

for cls in unique:

class_support = np.sum(y_train[support_indices] == cls)

support_by_class.append(class_support)

model_info['support_by_class'] = support_by_class

cenario_resultados[estrategia_nome] = model_info

print(f" Accuracy: {accuracy:.3f}, Precision: {precision:.3f}, "

f"Recall: {recall:.3f}, F1: {f1:.3f}, AUC: {roc_auc:.3f}")

except Exception as e:

print(f" ERRO: {e}")

cenario_resultados[estrategia_nome] = {'error': str(e)}

resultados_completos[cenario_nome] = cenario_resultados

'''

Visualização das fronteiras de decisão

'''

print("\n4. VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO")

for cenario_nome, X, y in cenarios:

print(f"\nVisualizando {cenario_nome}...")

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Criar mesh

h = 0.02

x_min, x_max = X_scaled[:, 0].min() - 1, X_scaled[:, 0].max() + 1

y_min, y_max = X_scaled[:, 1].min() - 1, X_scaled[:, 1].max() + 1

xx, yy = np.meshgrid(np.arange(x_min, x_max, h),

np.arange(y_min, y_max, h))

# Configurar subplots

estrategias_visuais = list(estrategias.keys())

n_strategies = len(estrategias_visuais)

fig, axes = plt.subplots(2, 2, figsize=(15, 12))

axes = axes.flatten()

# Dados originais

scatter = axes[0].scatter(X_scaled[:, 0], X_scaled[:, 1], c=y, cmap='coolwarm', alpha=0.8)

axes[0].set_title(f'{cenario_nome}\nDados Originais')

axes[0].set_xlabel('Feature 1')

axes[0].set_ylabel('Feature 2')

plt.colorbar(scatter, ax=axes[0])

# Estratégias

for idx, estrategia_nome in enumerate(estrategias_visuais, 1):

if idx >= len(axes):

break

if estrategia_nome in resultados_completos[cenario_nome]:

resultados = resultados_completos[cenario_nome][estrategia_nome]

model = resultados['model']

# Prever no mesh

Z = model.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

# Plot

contour = axes[idx].contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')

axes[idx].scatter(X_scaled[:, 0], X_scaled[:, 1], c=y, cmap='coolwarm', alpha=0.8)

# Adicionar métricas no título

f1 = resultados['f1_score']

recall = resultados['recall']

title = f'{estrategia_nome}\nF1: {f1:.3f}, Recall: {recall:.3f}'

axes[idx].set_title(title)

axes[idx].set_xlabel('Feature 1')

axes[idx].set_ylabel('Feature 2')

# Remover subplots não utilizados

for i in range(len(estrategias_visuais) + 1, len(axes)):

fig.delaxes(axes[i])

plt.tight_layout()

plt.show()

'''

Análise detalhada do recall por classe - VERSÃO CORRIGIDA

'''

print("\n5. ANÁLISE DETALHADA DO RECALL")

for cenario_nome, X, y in cenarios:

print(f"\n{cenario_nome}:")

print("="*80)

print(f"{'Estratégia':<25} {'Recall Classe 0':<15} {'Recall Classe 1':<15} {'Diferença':<12}")

print("="*80)

if cenario_nome in resultados_completos:

# CORREÇÃO: Recalcular y_test para cada cenário

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

X_train, X_test_correto, y_train, y_test_correto = train_test_split(

X_scaled, y, test_size=0.3, random_state=42, stratify=y

)

for estrategia_nome, resultados in resultados_completos[cenario_nome].items():

if 'error' not in resultados:

# CORREÇÃO: Usar y_test_correto em vez de tentar recuperar do dicionário

y_pred = resultados['predictions']

# Verificar se os tamanhos são compatíveis

if len(y_pred) == len(y_test_correto):

recall_0 = recall_score(y_test_correto, y_pred, pos_label=0)

recall_1 = recall_score(y_test_correto, y_pred, pos_label=1)

diferenca = abs(recall_0 - recall_1)

print(f"{estrategia_nome:<25} {recall_0:<15.3f} {recall_1:<15.3f} {diferenca:<12.3f}")

else:

print(f"{estrategia_nome:<25} {'Tamanho incompatível':<45}")

'''

Análise dos vetores de suporte - VERSÃO CORRIGIDA

'''

print("\n6. ANÁLISE DOS VETORES DE SUPORTE")

for cenario_nome, X, y in cenarios:

print(f"\n{cenario_nome} - Distribuição dos Vetores de Suporte:")

print("="*60)

if cenario_nome in resultados_completos:

for estrategia_nome, resultados in resultados_completos[cenario_nome].items():

if 'error' not in resultados and 'support_by_class' in resultados:

support_by_class = resultados['support_by_class']

total_support = sum(support_by_class)

if total_support > 0:

ratios = [s/total_support for s in support_by_class]

print(f"{estrategia_nome:<25}: Classe 0: {support_by_class[0]} ({ratios[0]:.1%}), "

f"Classe 1: {support_by_class[1]} ({ratios[1]:.1%})")

'''

Comparação de performance geral - VERSÃO CORRIGIDA

'''

print("\n7. COMPARAÇÃO DE PERFORMANCE GERAL")

print("\nTabela Comparativa - F1-Score por Cenário e Estratégia:")

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

header = f"{'Cenário':<20} {'SVC Padrão':<12} {'SVC Balanced':<12} {'SVC Custom':<12} {'SVC Ajustado':<12}"

print(header)

print("="*90)

for cenario_nome, X, y in cenarios:

if cenario_nome in resultados_completos:

row = f"{cenario_nome:<20}"

for estrategia in ['SVC Padrão', 'SVC Class Weight Balanced',

'SVC Class Weight Custom', 'SVC Ajustado C']:

if (estrategia in resultados_completos[cenario_nome] and

'error' not in resultados_completos[cenario_nome][estrategia]):

f1 = resultados_completos[cenario_nome][estrategia]['f1_score']

row += f" {f1:<11.3f}"

else:

row += f" {'N/A':<11}"

print(row)

'''

Análise do trade-off precision-recall - VERSÃO CORRIGIDA

'''

print("\n8. ANÁLISE DO TRADE-OFF PRECISION-RECALL")

for cenario_nome, X, y in cenarios:

print(f"\n{cenario_nome} - Trade-off Precision vs Recall:")

if cenario_nome in resultados_completos:

for estrategia_nome, resultados in resultados_completos[cenario_nome].items():

if 'error' not in resultados:

precision = resultados['precision']

recall = resultados['recall']

f1 = resultados['f1_score']

print(f" {estrategia_nome:<25}: Precision={precision:.3f}, "

f"Recall={recall:.3f}, F1={f1:.3f}")

# CORREÇÃO: Adicionar análise de matriz de confusão

print("\n9. ANÁLISE DAS MATRIZES DE CONFUSÃO")

for cenario_nome, X, y in cenarios:

print(f"\n{cenario_nome} - Matrizes de Confusão:")

print("="*50)

if cenario_nome in resultados_completos:

# Recalcular split para este cenário

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

X_train, X_test_conf, y_train, y_test_conf = train_test_split(

X_scaled, y, test_size=0.3, random_state=42, stratify=y

)

for estrategia_nome, resultados in resultados_completos[cenario_nome].items():

if 'error' not in resultados:

y_pred = resultados['predictions']

if len(y_pred) == len(y_test_conf):

cm = confusion_matrix(y_test_conf, y_pred)

print(f"\n{estrategia_nome}:")

print(cm)

# Adicionar interpretação

tn, fp, fn, tp = cm.ravel()

print(f" TN: {tn}, FP: {fp}, FN: {fn}, TP: {tp}")

else:

print(f"\n{estrategia_nome}: Tamanhos incompatíveis para matriz de confusão")

'''

Recomendações práticas para problemas desbalanceados - VERSÃO ATUALIZADA

'''

print("\n10. RECOMENDAÇÕES PRÁTICAS")

print("\nBaseado na análise experimental:")

print("\nEscolha da Estratégia por Nível de Desbalanceamento:")

print(" - Desbalanceamento leve (< 70-30): SVC padrão pode ser suficiente")

print(" - Desbalanceamento moderado (70-30 a 85-15): class_weight='balanced'")

print(" - Desbalanceamento severo (> 85-15): Pesos customizados + ajuste de C")

print("\nConfiguração de Pesos:")

print(" - 'balanced': Boa opção padrão para maioria dos casos")

print(" - Customizado: Quando se conhece os custos de erro por classe")

print(" - Baseado em dados: Calcular pesos baseados na distribuição real")

print("\nAjuste de Hiperparâmetros:")

print(" - Reduzir C para aumentar regularização em dados desbalanceados")

print(" - Kernel RBF geralmente mais robusto que linear")

print(" - Validar com validação cruzada estratificada")

print("\nMétricas de Avaliação:")

print(" - F1-Score: Métrica balanceada para comparação geral")

print(" - Recall: Crítico para detecção da classe minoritária")

print(" - Precision-Recall AUC: Melhor que ROC-AUC para desbalanceamento")

print(" - Matriz de confusão: Para análise detalhada dos erros")

print("\nTécnicas Complementares:")

print(" - Amostragem: SMOTE para oversampling inteligente")

print(" - Ensemble: Combinar múltiplas estratégias")

print(" - Threshold moving: Ajustar limiar de decisão pós-treinamento")

print("\nConsiderações por Domínio:")

print(" - Médico: Alta recall para detecção de doenças raras")

print(" - Fraude: Balancear recall e precision baseado em custos")

print(" - Manutenção: Recall crítico para detecção de falhas")

print(" - Marketing: Precision importante para custo de aquisição")

print("\nBoas Práticas:")

print(" - Sempre usar validação estratificada")

print(" - Reportar múltiplas métricas, não apenas acurácia")

print(" - Considerar custos de negócio na escolha da estratégia")

print(" - Documentar a distribuição das classes no dataset")

print(" - Testar diferentes abordagens antes de decidir")

# CORREÇÃO: Adicionar resumo dos resultados principais

print("\n11. RESUMO DOS RESULTADOS PRINCIPAIS")

print("\nPrincipais Insights Obtidos:")

for cenario_nome, X, y in cenarios:

if cenario_nome in resultados_completos:

print(f"\n{cenario_nome}:")

# Encontrar melhor estratégia por F1-Score

melhor_estrategia = None

melhor_f1 = 0

for estrategia_nome, resultados in resultados_completos[cenario_nome].items():

if 'error' not in resultados and resultados['f1_score'] > melhor_f1:

melhor_f1 = resultados['f1_score']

melhor_estrategia = estrategia_nome

if melhor_estrategia:

melhor_resultado = resultados_completos[cenario_nome][melhor_estrategia]

print(f" Melhor estratégia: {melhor_estrategia} (F1: {melhor_f1:.3f})")

print(f" Precision: {melhor_resultado['precision']:.3f}, "

f"Recall: {melhor_resultado['recall']:.3f}, "

f"AUC: {melhor_resultado['roc_auc']:.3f}")

Interpretação dos Resultados

Analisando os experimentos com problemas desbalanceados, podemos observar padrões importantes:

O SVM padrão tende a favorecer a classe majoritária, resultando em alto recall para a classe 0 mas baixo recall para a classe 1
O uso de class_weight='balanced' equilibra significativamente o recall entre classes
Estratégias customizadas permitem ajuste fino baseado em custos específicos de erro
O ajuste do parâmetro C em conjunto com pesos de classe pode melhorar ainda mais a performance

Considerações para Aplicações Práticas

Seleção da Estratégia Ótima

Inegavelmente, a escolha da estratégia depende do contexto específico do problema:

Acurácia balanceada: Quando todas as classes são igualmente importantes
Recall da classe minoritária: Para detecção de eventos raros ou críticos
Precision da classe minoritária: Quando falsos positivos são custosos
F1-Score: Para balanceamento geral entre precision e recall

Avaliação de Custo-Benefício

Para aplicações reais, a escolha deve considerar os custos associados a diferentes tipos de erro:

Custo de falsos negativos (não detectar a classe minoritária)
Custo de falsos positivos (alarmes falsos)
Benefício de verdadeiros positivos
Impacto operacional das decisões erradas

Conclusão

O tratamento adequado de problemas desbalanceados representa uma habilidade essencial para praticantes de machine learning. Embora as SVM sejam classificadores poderosos, seu desempenho em datasets desbalanceados depende criticamente da escolha apropriada de estratégias de ponderação e configuração de parâmetros.

Portanto, o domínio dessas técnicas permite extrair o máximo valor dos classificadores SVM em cenários do mundo real, onde distribuições desbalanceadas são a regra rather than a exceção, garantindo modelos robustos e alinhados com os objetivos de negócio específicos.

Referência

Este post explora o item 1.4.1.3. Problemas desbalanceados da documentação do scikit-learn:

https://scikit-learn.org/0.21/modules/svm.html#unbalanced-problems