Arquivo de AM Supervisionado - Página 22 de 25

Logistica

25/04/202623/03/2026 Por antonino

1 – Supervisionado
1.1 – Regressao
1.1.5 – Logistica

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

quando a resposta é uma probabilidade

Regressão logística é um algoritmo de classificação apesar do nome sugerir regressão. Ela estima a probabilidade de um exemplo pertencer a uma determinada categoria. Diferente da regressão linear, a saída está sempre entre 0 e 1. Por exemplo, podemos estimar a probabilidade de um e-mail ser spam. Primeiramente, o modelo usa uma função sigmoide que transforma qualquer valor em probabilidade. Além disso, essa função tem formato de “S”, comprimindo valores extremos. A decisão final usa um limiar (geralmente 0,5) para classificar o resultado.

função sigmoide: o coração do modelo

A função sigmoide transforma combinações lineares de variáveis em probabilidades entre 0 e 1. Sua fórmula matemática é f(z) = 1 / (1 + e^{-z}), onde z é combinação linear. Primeiramente, valores de z muito negativos produzem probabilidades próximas de zero. Além disso, valores de z muito positivos produzem probabilidades próximas de um. Por exemplo, características que indicam spam produzem z positivo e probabilidade alta. O modelo aprende os coeficientes que melhor separam as duas classes. Essa curva em “S” é fundamental para o funcionamento do algoritmo.

fronteiras de decisão

Regressão logística cria fronteiras lineares que separam as diferentes classes no espaço. Para duas dimensões, essa fronteira é uma linha reta no plano cartesiano. Primeiramente, pontos de um lado recebem classificação 0 e do outro lado 1. Além disso, podemos usar transformações polinomiais para criar fronteiras não lineares. Por exemplo, adicionar termos como x² e y² gera círculos como fronteira. A fronteira de decisão ocorre onde a probabilidade prevista é exatamente 0,5. Essa visualização ajuda a entender como o modelo faz classificações.

avaliando classificadores binários

Avaliar regressão logística exige métricas específicas para classificação binária. Primeiramente, acurácia mede a proporção de acertos entre todas as previsões realizadas. Além disso, precisão indica quantos positivos previstos estavam corretos. Recall mostra quantos positivos reais conseguimos capturar corretamente. Curva ROC e AUC ajudam a avaliar o desempenho em diferentes limiares. Primeiramente, AUC próximo de 1 indica excelente capacidade de separação entre classes. Matriz de confusão organiza acertos e erros em quatro categorias distintas. Essas métricas oferecem visão completa do desempenho do modelo.

aplicações no mundo real

Regressão logística é amplamente utilizada em problemas de classificação binária diversos. Primeiramente, bancos usam para prever inadimplência em empréstimos concedidos a clientes. Além disso, hospitais empregam para diagnosticar doenças com base em exames. Marketing utiliza para prever quais clientes responderão a campanhas promocionais. Recursos humanos aplicam para prever rotatividade de funcionários na empresa. Sistemas antifraude usam para identificar transações suspeitas em tempo real. Para iniciantes, regressão logística é a porta de entrada para classificação supervisionada. É simples, interpretável e eficaz para muitos problemas práticos do cotidiano.

Contexto do Problema

Uma clínica médica deseja prever se um paciente tem diabetes com base em dois atributos: glicose (mg/dL) e IMC (kg/m²). Utilize a Regressão Logística para construir um modelo classificador.

Características do Modelo

Tipo: Modelo de classificação binária supervisionada
Função de ativação: Sigmóide (Logística)
Saída: Probabilidade entre 0 e 1
Decisão: Classe 1 se P ≥ 0.5, senão Classe 0
Limitação: Assume linearidade nos log-odds

Arquitetura do Modelo

A Regressão Logística é um modelo linear com uma única camada: \[ z = w_1 x_1 + w_2 x_2 + b \] \[ \hat{y} = \sigma(z) = \frac{1}{1 + e^{-z}} \] Onde:

\(x_1, x_2\): características de entrada (glicose, IMC)
\(w_1, w_2\): pesos do modelo
\(b\): viés (bias)
\(\hat{y}\): probabilidade prevista da classe positiva

Hiperparâmetros

C (regularização inversa): \(C = \frac{1}{\lambda}\) (padrão=1.0). Valores menores aumentam a regularização. Controle de overfitting através da regularização L2.
penalty: Tipo de regularização (‘l1’, ‘l2’, ‘elasticnet’ ou None)
max_iter: Número máximo de iterações para convergência (padrão=100)
solver: Algoritmo de otimização (‘lbfgs’, ‘liblinear’, ‘newton-cg’, ‘sag’, ‘saga’)
tol: Tolerância para critério de parada (padrão=1e-4)

Função de Custo (Log-Loss)

\[ J(\mathbf{w}) = -\frac{1}{m} \sum_{i=1}^{m} [y^{(i)} \log(\hat{y}^{(i)}) + (1-y^{(i)}) \log(1-\hat{y}^{(i)})] \]

Tarefa

Implemente um modelo de Regressão Logística para classificar pacientes com diabetes. Utilize os dados sintéticos fornecidos e avalie o modelo com acurácia e matriz de confusão. Visualize a fronteira de decisão no espaço 2D.

# Regressão Logística para Classificação de Diabetes
# Execute este código no Google Colab

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import seaborn as sns

# Configuração para gráficos bonitos
plt.style.use('seaborn-v0_8-darkgrid')
sns.set_palette("husl")

# ==================== 1. GERAR DADOS SINTÉTICOS ====================
print("="*50)
print("GERANDO DADOS SINTÉTICOS")
print("="*50)

np.random.seed(42)
n_samples = 300

# Glicose (mg/dL) - normal: 70-100, diabético: >126
glicose_diabetico = np.random.normal(150, 25, n_samples//2)
glicose_normal = np.random.normal(95, 15, n_samples//2)

# IMC (kg/m²) - normal: 18.5-24.9, diabético: >25
imc_diabetico = np.random.normal(30, 4, n_samples//2)
imc_normal = np.random.normal(22, 3, n_samples//2)

# Combinar dados
X = np.vstack([np.column_stack([glicose_diabetico, imc_diabetico]),
               np.column_stack([glicose_normal, imc_normal])])

y = np.array([1]* (n_samples//2) + [0]* (n_samples//2))

# Embaralhar os dados
indices = np.random.permutation(n_samples)
X, y = X[indices], y[indices]

print(f"Total de amostras: {n_samples}")
print(f"Pacientes diabéticos (classe 1): {sum(y)}")
print(f"Pacientes não-diabéticos (classe 0): {len(y)-sum(y)}")
print(f"\nEstatísticas:")
print(f"Glicose - Média: {X[:,0].mean():.1f}, Desvio: {X[:,0].std():.1f}")
print(f"IMC - Média: {X[:,1].mean():.1f}, Desvio: {X[:,1].std():.1f}")

# ==================== 2. PRÉ-PROCESSAMENTO ====================
# Padronização dos dados (importante para Regressão Logística)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Divisão treino/teste
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.3, random_state=42, stratify=y
)

print(f"\nDivisão dos dados:")
print(f"Treino: {len(X_train)} amostras")
print(f"Teste: {len(X_test)} amostras")

# ==================== 3. TREINAR REGRESSÃO LOGÍSTICA ====================
print("\n" + "="*50)
print("TREINANDO REGRESSÃO LOGÍSTICA")
print("="*50)

# Hiperparâmetros configuráveis
# C: inverso da regularização (menor C = mais regularização)
# penalty: tipo de regularização
# solver: algoritmo de otimização

model = LogisticRegression(
    C=1.0,           # Regularização padrão
    penalty='l2',    # Regularização L2
    solver='lbfgs',  # Algoritmo de otimização
    max_iter=1000,   # Máximo de iterações
    random_state=42
)

model.fit(X_train, y_train)

print(f"Coeficientes (pesos) do modelo:")
print(f"w1 (Glicose): {model.coef_[0][0]:.3f}")
print(f"w2 (IMC): {model.coef_[0][1]:.3f}")
print(f"bias (intercepto): {model.intercept_[0]:.3f}")

# ==================== 4. AVALIAÇÃO DO MODELO ====================
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]

accuracy = accuracy_score(y_test, y_pred)
print(f"\nAcurácia no teste: {accuracy:.3f} ({accuracy*100:.1f}%)")

print("\nRelatório de Classificação:")
print(classification_report(y_test, y_pred, target_names=['Não-diabético', 'Diabético']))

# Matriz de Confusão
cm = confusion_matrix(y_test, y_pred)
print("\nMatriz de Confusão:")
print(cm)

# ==================== 5. VISUALIZAÇÕES ====================
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Gráfico 1: Dados originais
ax1 = axes[0, 0]
colors = ['blue' if y_i == 0 else 'red' for y_i in y]
ax1.scatter(X[:, 0], X[:, 1], c=colors, alpha=0.6, edgecolors='k', s=50)
ax1.set_xlabel('Glicose (mg/dL)', fontsize=12)
ax1.set_ylabel('IMC (kg/m²)', fontsize=12)
ax1.set_title('Dados Originais: Pacientes com e sem Diabetes', fontsize=14)
from matplotlib.patches import Patch
legend_elements = [Patch(facecolor='blue', label='Não-diabético (0)'),
                   Patch(facecolor='red', label='Diabético (1)')]
ax1.legend(handles=legend_elements, loc='upper left')

# Gráfico 2: Fronteira de Decisão
ax2 = axes[0, 1]
# Criar grid para fronteira de decisão
x_min, x_max = X_scaled[:, 0].min() - 0.5, X_scaled[:, 0].max() + 0.5
y_min, y_max = X_scaled[:, 1].min() - 0.5, X_scaled[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200),
                     np.linspace(y_min, y_max, 200))

# Prever probabilidades no grid
Z = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = Z.reshape(xx.shape)

# Plotar fronteira de decisão
contour = ax2.contourf(xx, yy, Z, levels=20, alpha=0.7, cmap='RdBu_r')
ax2.contour(xx, yy, Z, levels=[0.5], colors='black', linewidths=2, linestyles='-')
ax2.scatter(X_train[:, 0], X_train[:, 1], 
           c=y_train, cmap='RdBu_r', edgecolors='k', s=40, alpha=0.8)
ax2.set_xlabel('Glicose (padronizada)', fontsize=12)
ax2.set_ylabel('IMC (padronizado)', fontsize=12)
ax2.set_title('Fronteira de Decisão do Modelo\n(Probabilidade = 0.5)', fontsize=14)
plt.colorbar(contour, ax=ax2, label='Probabilidade de Diabetes')

# Gráfico 3: Matriz de Confusão
ax3 = axes[1, 0]
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax3,
            xticklabels=['Não-diabético', 'Diabético'],
            yticklabels=['Não-diabético', 'Diabético'])
ax3.set_xlabel('Predito', fontsize=12)
ax3.set_ylabel('Real', fontsize=12)
ax3.set_title('Matriz de Confusão', fontsize=14)

# Gráfico 4: Curva de Probabilidades
ax4 = axes[1, 1]
# Separar predições corretas e incorretas
correct_idx = y_pred == y_test
incorrect_idx = y_pred != y_test

ax4.scatter(range(len(y_prob[correct_idx])), y_prob[correct_idx], 
           c='green', alpha=0.6, s=50, label='Corretos', marker='o')
ax4.scatter(range(len(y_prob[incorrect_idx])), y_prob[incorrect_idx], 
           c='red', alpha=0.8, s=80, label='Incorretos', marker='X')
ax4.axhline(y=0.5, color='black', linestyle='--', linewidth=2, label='Limite (0.5)')
ax4.set_xlabel('Amostras de Teste', fontsize=12)
ax4.set_ylabel('Probabilidade de Diabetes', fontsize=12)
ax4.set_title('Probabilidades Previstas - Amostras de Teste', fontsize=14)
ax4.legend()
ax4.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ==================== 6. ANÁLISE DE HIPERPARÂMETROS ====================
print("\n" + "="*50)
print("ANÁLISE DE HIPERPARÂMETROS")
print("="*50)

# Testar diferentes valores de C (regularização)
C_values = [0.001, 0.01, 0.1, 1, 10, 100]
train_scores = []
test_scores = []

for C in C_values:
    model_c = LogisticRegression(C=C, max_iter=1000, random_state=42)
    model_c.fit(X_train, y_train)
    train_scores.append(accuracy_score(y_train, model_c.predict(X_train)))
    test_scores.append(accuracy_score(y_test, model_c.predict(X_test)))

# Plotar efeito da regularização
fig, ax = plt.subplots(figsize=(10, 6))
ax.semilogx(C_values, train_scores, 'o-', label='Treino', linewidth=2, markersize=8)
ax.semilogx(C_values, test_scores, 's-', label='Teste', linewidth=2, markersize=8)
ax.set_xlabel('C (Inverso da Regularização)', fontsize=12)
ax.set_ylabel('Acurácia', fontsize=12)
ax.set_title('Efeito da Regularização na Performance do Modelo', fontsize=14)
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_xticks(C_values)
ax.set_xticklabels([f'{c}' for c in C_values])
plt.tight_layout()
plt.show()

print("\nMelhor C: {} (acurácia teste: {:.3f})".format(
    C_values[np.argmax(test_scores)], max(test_scores)
))

# ==================== 7. EXEMPLO DE PREDIÇÃO ====================
print("\n" + "="*50)
print("EXEMPLO DE PREDIÇÃO PARA UM NOVO PACIENTE")
print("="*50)

# Novo paciente: Glicose=130, IMC=28
novo_paciente = np.array([[130, 28]])
novo_paciente_scaled = scaler.transform(novo_paciente)
probabilidade = model.predict_proba(novo_paciente_scaled)[0][1]
predicao = model.predict(novo_paciente_scaled)[0]

print(f"Novo paciente:")
print(f"Glicose: 130 mg/dL")
print(f"IMC: 28 kg/m²")
print(f"\nProbabilidade de ter diabetes: {probabilidade:.3f} ({probabilidade*100:.1f}%)")
print(f"Classificação: {'DIABÉTICO' if predicao == 1 else 'NÃO-DIABÉTICO'}")

if probabilidade >= 0.7:
    print("Alto risco de diabetes - Recomendar consulta médica")
elif probabilidade >= 0.5:
    print("Risco moderado - Recomendar exames adicionais")
else:
    print("Baixo risco - Manter hábitos saudáveis")

print("\n" + "="*50)
print("FIM DA ANÁLISE")
print("="*50)

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

# Regressão Logística para Classificação de Diabetes

# Execute este código no Google Colab

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

import seaborn as sns

# Configuração para gráficos bonitos

plt.style.use('seaborn-v0_8-darkgrid')

sns.set_palette("husl")

# ==================== 1. GERAR DADOS SINTÉTICOS ====================

print("="*50)

print("GERANDO DADOS SINTÉTICOS")

print("="*50)

np.random.seed(42)

n_samples = 300

# Glicose (mg/dL) - normal: 70-100, diabético: >126

glicose_diabetico = np.random.normal(150, 25, n_samples//2)

glicose_normal = np.random.normal(95, 15, n_samples//2)

# IMC (kg/m²) - normal: 18.5-24.9, diabético: >25

imc_diabetico = np.random.normal(30, 4, n_samples//2)

imc_normal = np.random.normal(22, 3, n_samples//2)

# Combinar dados

X = np.vstack([np.column_stack([glicose_diabetico, imc_diabetico]),

np.column_stack([glicose_normal, imc_normal])])

y = np.array([1]* (n_samples//2) + [0]* (n_samples//2))

# Embaralhar os dados

indices = np.random.permutation(n_samples)

X, y = X[indices], y[indices]

print(f"Total de amostras: {n_samples}")

print(f"Pacientes diabéticos (classe 1): {sum(y)}")

print(f"Pacientes não-diabéticos (classe 0): {len(y)-sum(y)}")

print(f"\nEstatísticas:")

print(f"Glicose - Média: {X[:,0].mean():.1f}, Desvio: {X[:,0].std():.1f}")

print(f"IMC - Média: {X[:,1].mean():.1f}, Desvio: {X[:,1].std():.1f}")

# ==================== 2. PRÉ-PROCESSAMENTO ====================

# Padronização dos dados (importante para Regressão Logística)

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Divisão treino/teste

X_train, X_test, y_train, y_test = train_test_split(

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

)

print(f"\nDivisão dos dados:")

print(f"Treino: {len(X_train)} amostras")

print(f"Teste: {len(X_test)} amostras")

# ==================== 3. TREINAR REGRESSÃO LOGÍSTICA ====================

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

print("TREINANDO REGRESSÃO LOGÍSTICA")

print("="*50)

# Hiperparâmetros configuráveis

# C: inverso da regularização (menor C = mais regularização)

# penalty: tipo de regularização

# solver: algoritmo de otimização

model = LogisticRegression(

C=1.0, # Regularização padrão

penalty='l2', # Regularização L2

solver='lbfgs', # Algoritmo de otimização

max_iter=1000, # Máximo de iterações

random_state=42

)

model.fit(X_train, y_train)

print(f"Coeficientes (pesos) do modelo:")

print(f"w1 (Glicose): {model.coef_[0][0]:.3f}")

print(f"w2 (IMC): {model.coef_[0][1]:.3f}")

print(f"bias (intercepto): {model.intercept_[0]:.3f}")

# ==================== 4. AVALIAÇÃO DO MODELO ====================

y_pred = model.predict(X_test)

y_prob = model.predict_proba(X_test)[:, 1]

accuracy = accuracy_score(y_test, y_pred)

print(f"\nAcurácia no teste: {accuracy:.3f} ({accuracy*100:.1f}%)")

print("\nRelatório de Classificação:")

print(classification_report(y_test, y_pred, target_names=['Não-diabético', 'Diabético']))

# Matriz de Confusão

cm = confusion_matrix(y_test, y_pred)

print("\nMatriz de Confusão:")

print(cm)

# ==================== 5. VISUALIZAÇÕES ====================

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Gráfico 1: Dados originais

ax1 = axes[0, 0]

colors = ['blue' if y_i == 0 else 'red' for y_i in y]

ax1.scatter(X[:, 0], X[:, 1], c=colors, alpha=0.6, edgecolors='k', s=50)

ax1.set_xlabel('Glicose (mg/dL)', fontsize=12)

ax1.set_ylabel('IMC (kg/m²)', fontsize=12)

ax1.set_title('Dados Originais: Pacientes com e sem Diabetes', fontsize=14)

from matplotlib.patches import Patch

legend_elements = [Patch(facecolor='blue', label='Não-diabético (0)'),

Patch(facecolor='red', label='Diabético (1)')]

ax1.legend(handles=legend_elements, loc='upper left')

# Gráfico 2: Fronteira de Decisão

ax2 = axes[0, 1]

# Criar grid para fronteira de decisão

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

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

xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200),

np.linspace(y_min, y_max, 200))

# Prever probabilidades no grid

Z = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

Z = Z.reshape(xx.shape)

# Plotar fronteira de decisão

contour = ax2.contourf(xx, yy, Z, levels=20, alpha=0.7, cmap='RdBu_r')

ax2.contour(xx, yy, Z, levels=[0.5], colors='black', linewidths=2, linestyles='-')

ax2.scatter(X_train[:, 0], X_train[:, 1],

c=y_train, cmap='RdBu_r', edgecolors='k', s=40, alpha=0.8)

ax2.set_xlabel('Glicose (padronizada)', fontsize=12)

ax2.set_ylabel('IMC (padronizado)', fontsize=12)

ax2.set_title('Fronteira de Decisão do Modelo\n(Probabilidade = 0.5)', fontsize=14)

plt.colorbar(contour, ax=ax2, label='Probabilidade de Diabetes')

# Gráfico 3: Matriz de Confusão

ax3 = axes[1, 0]

sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax3,

xticklabels=['Não-diabético', 'Diabético'],

yticklabels=['Não-diabético', 'Diabético'])

ax3.set_xlabel('Predito', fontsize=12)

ax3.set_ylabel('Real', fontsize=12)

ax3.set_title('Matriz de Confusão', fontsize=14)

# Gráfico 4: Curva de Probabilidades

ax4 = axes[1, 1]

# Separar predições corretas e incorretas

correct_idx = y_pred == y_test

incorrect_idx = y_pred != y_test

ax4.scatter(range(len(y_prob[correct_idx])), y_prob[correct_idx],

c='green', alpha=0.6, s=50, label='Corretos', marker='o')

ax4.scatter(range(len(y_prob[incorrect_idx])), y_prob[incorrect_idx],

c='red', alpha=0.8, s=80, label='Incorretos', marker='X')

ax4.axhline(y=0.5, color='black', linestyle='--', linewidth=2, label='Limite (0.5)')

ax4.set_xlabel('Amostras de Teste', fontsize=12)

ax4.set_ylabel('Probabilidade de Diabetes', fontsize=12)

ax4.set_title('Probabilidades Previstas - Amostras de Teste', fontsize=14)

ax4.legend()

ax4.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# ==================== 6. ANÁLISE DE HIPERPARÂMETROS ====================

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

print("ANÁLISE DE HIPERPARÂMETROS")

print("="*50)

# Testar diferentes valores de C (regularização)

C_values = [0.001, 0.01, 0.1, 1, 10, 100]

train_scores = []

test_scores = []

for C in C_values:

model_c = LogisticRegression(C=C, max_iter=1000, random_state=42)

model_c.fit(X_train, y_train)

train_scores.append(accuracy_score(y_train, model_c.predict(X_train)))

test_scores.append(accuracy_score(y_test, model_c.predict(X_test)))

# Plotar efeito da regularização

fig, ax = plt.subplots(figsize=(10, 6))

ax.semilogx(C_values, train_scores, 'o-', label='Treino', linewidth=2, markersize=8)

ax.semilogx(C_values, test_scores, 's-', label='Teste', linewidth=2, markersize=8)

ax.set_xlabel('C (Inverso da Regularização)', fontsize=12)

ax.set_ylabel('Acurácia', fontsize=12)

ax.set_title('Efeito da Regularização na Performance do Modelo', fontsize=14)

ax.legend()

ax.grid(True, alpha=0.3)

ax.set_xticks(C_values)

ax.set_xticklabels([f'{c}' for c in C_values])

plt.tight_layout()

plt.show()

print("\nMelhor C: {} (acurácia teste: {:.3f})".format(

C_values[np.argmax(test_scores)], max(test_scores)

))

# ==================== 7. EXEMPLO DE PREDIÇÃO ====================

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

print("EXEMPLO DE PREDIÇÃO PARA UM NOVO PACIENTE")

print("="*50)

# Novo paciente: Glicose=130, IMC=28

novo_paciente = np.array([[130, 28]])

novo_paciente_scaled = scaler.transform(novo_paciente)

probabilidade = model.predict_proba(novo_paciente_scaled)[0][1]

predicao = model.predict(novo_paciente_scaled)[0]

print(f"Novo paciente:")

print(f"Glicose: 130 mg/dL")

print(f"IMC: 28 kg/m²")

print(f"\nProbabilidade de ter diabetes: {probabilidade:.3f} ({probabilidade*100:.1f}%)")

print(f"Classificação: {'DIABÉTICO' if predicao == 1 else 'NÃO-DIABÉTICO'}")

if probabilidade >= 0.7:

print("Alto risco de diabetes - Recomendar consulta médica")

elif probabilidade >= 0.5:

print("Risco moderado - Recomendar exames adicionais")

else:

print("Baixo risco - Manter hábitos saudáveis")

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

print("FIM DA ANÁLISE")

print("="*50)

Regressão Linear Regularizada (Ridg, Lasso e Elastic Net)

25/04/202623/03/2026 Por antonino

1 – Supervisionado
1.1 – Regressao
1.1.4 – Ridge, Lasso, Elastic Net

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

O que é regressão linear e por que regularizar?

Primeiramente, imagine desenhar uma linha reta entre vários pontos. Por conseguinte, essa linha tenta prever um valor (como o preço de uma casa). Esse método chama-se regressão linear simples. Contudo, dados reais costumam ser bagunçados e cheios de variáveis. Assim, o modelo pode ficar complexo demais para os dados. Esse problema é conhecido como overfitting (sobreajuste). Para evitar isso, usamos técnicas de regularização. Dessa forma, elas aplicam “punições” aos coeficientes do modelo. Além disso, o modelo fica mais simples e generalizável. Três métodos populares são Ridge, Lasso e Elastic Net. Cada um age de maneira diferente nos coeficientes. Especialistas usam esses métodos em aprendizado de máquina. Seu principal benefício é melhorar previsões em novos dados. Portanto, a regularização é essencial para modelos confiáveis.

Ridge: encolhendo coeficientes sem zerar

Ridge é a primeira técnica que vamos explorar. Ela adiciona uma penalidade ao quadrado dos coeficientes. Os profissionais chamam essa penalidade de norma L2. O objetivo é encolher todos os coeficientes, mas sem zerá-los. Assim, nenhuma variável sai completamente do modelo. Isso é útil quando todas as variáveis importam um pouco. Por exemplo, dados genéticos ou de sensores se beneficiam disso. A força da penalidade depende de um parâmetro (alpha). Consequentemente, alpha maior produz coeficientes menores. Isso resulta em modelo mais simples e robusto. Uma desvantagem é que Ridge mantém variáveis irrelevantes. Elas ficam perto de zero, mas não exatamente zero. Portanto, isso pode dificultar a interpretação do modelo final. Ainda assim, Ridge evita overfitting severo com eficiência. Muitas situações práticas se beneficiam dessa abordagem.

Lasso: escolhendo variáveis importantes

Lasso usa uma penalidade diferente, chamada norma L1. Ela soma os valores absolutos dos coeficientes. O resultado é que alguns coeficientes viram exatamente zero. Desse modo, Lasso faz seleção automática de variáveis. Variáveis zeradas saem do modelo final completamente. Isso torna o modelo mais simples e fácil de explicar. Por exemplo, marketing com 100 possíveis canais de venda. Lasso descobre quais canais realmente influenciam as vendas. Contudo, Lasso tem uma limitação importante. Se duas variáveis forem muito correlacionadas, ele escolhe uma. A outra variável fica zerada, mesmo que ambas sejam úteis. Além disso, poucos dados podem deixar Lasso instável. A escolha do alpha também exige cuidado e testes. Apesar disso, Lasso é muito usado em dados de alta dimensão.

Elastic Net: o melhor dos dois mundos

Elastic Net combina Ridge e Lasso em um só método. Sua penalidade mistura norma L1 e norma L2. Dois parâmetros controlam essa mistura: alpha e l1ratio. O alpha controla a força total da regularização. Já o l1ratio decide quanto de L1 versus L2 usar. Quando l1ratio é 1, Elastic Net vira Lasso puro. Quando l1ratio é 0, Elastic Net vira Ridge puro. Valores intermediários trazem benefícios de ambos. Por exemplo, ele encolhe coeficientes como Ridge. Mas também zera variáveis menos importantes como Lasso. Além disso, Elastic Net funciona bem com variáveis correlacionadas. Ele mantém grupos de variáveis relevantes juntos normalmente. Por essa razão, os especialistas preferem esse método. Em muitos projetos, Elastic Net supera Ridge e Lasso. Portanto, sua flexibilidade representa uma grande vantagem prática.

Como aplicar esses métodos na prática

Primeiramente, padronize os dados antes de tudo. Isso significa colocar todas as variáveis na mesma escala. Caso contrário, as penalidades seriam aplicadas de forma injusta. Use StandardScaler da biblioteca scikit-learn para isso. Depois, divida os dados em treino e teste. A regularização depende apenas dos dados de treino. Escolha o parâmetro alpha (e l1_ratio) com cuidado. Uma técnica comum é a validação cruzada (cross-validation). Ela testa vários valores e seleciona o melhor. No scikit-learn, existem RidgeCV, LassoCV e ElasticNetCV. Essas classes já implementam a busca automática. Avalie modelos regularizados pelo R² ou MSE. Sempre compare com uma regressão linear sem regularização. Isso mostra se a regularização realmente ajudou. Por fim, interprete os coeficientes com atenção. Eles indicam o impacto de cada variável no resultado. Lembre-se: regularização não resolve todos os problemas. Dados mal coletados ou com poucos exemplos continuam sendo um desafio. Portanto, combine sempre boas práticas de coleta e limpeza. Com esses passos, você estará pronto para usar Ridge, Lasso e Elastic Net.

enunciado: previsão de eficiência energética

Você recebeu um conjunto de dados sobre edifícios. O objetivo é prever a carga de aquecimento (variável alvo). Existem oito características disponíveis:

Área relativa do edifício
Área do telhado
Altura do edifício
Tamanho do vidro
Distribuição do vidro
Orientação (codificada)
Área da superfície do telhado
Área da superfície da parede

Seu trabalho é construir um modelo de regressão linear regularizado. O modelo deve aprender a relação entre as características e a carga de aquecimento. A arquitetura do modelo é simples: uma combinação linear das entradas. A fórmula da regressão linear é: \(\hat{y} = w_1 x_1 + w_2 x_2 + … + w_n x_n + b\) Onde \(w_i\) são os pesos e \(b\) é o intercepto. A regularização Ridge adiciona uma penalidade à soma dos quadrados dos pesos. Para Ridge, a função de custo é: \(J(w) = \text{MSE}(w) + \alpha \sum_{i=1}^{n} w_i^2\) Para Lasso, a penalidade usa o valor absoluto dos pesos: \(J(w) = \text{MSE}(w) + \alpha \sum_{i=1}^{n} |w_i|\) Elastic Net combina ambas as penalidades: \(J(w) = \text{MSE}(w) + \alpha \cdot \text{l1\_ratio} \sum |w_i| + \alpha \cdot (1 – \text{l1\_ratio}) \sum w_i^2\) Hiperparâmetros importantes:

alpha – controla a força da regularização. Quanto maior, mais simples o modelo.
l1_ratio (Elastic Net) – mistura entre Lasso (1) e Ridge (0).
max_iter – número máximo de iterações para convergência.
tol – tolerância para parar o treinamento.

Use validação cruzada para escolher o melhor alpha. Avalie o modelo com o erro quadrático médio (MSE) e o R². Compare os três métodos (Ridge, Lasso, Elastic Net).

Exemplo com Ridge

# Ridge Regression com visualizações
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import RidgeCV, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_openml

# Configurar estilo dos gráficos
sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados
print("Carregando dados...")
data = fetch_openml(data_id=487, as_frame=True)
X = data.data
y_temp = data.target.to_numpy()
if y_temp.ndim == 2:
    y = y_temp[:, 0]
else:
    y = y_temp

# 2. Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Padronizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Treinar Ridge com diferentes alphas para análise
alphas = np.logspace(-3, 3, 50)
ridge_model = RidgeCV(alphas=alphas, store_cv_values=True, scoring='neg_mean_squared_error')
ridge_model.fit(X_train_scaled, y_train)

# 5. Resultados
print(f"Melhor alpha: {ridge_model.alpha_:.4f}")

# 6. Previsões
y_pred_ridge = ridge_model.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"MSE no teste: {mse_ridge:.4f}")
print(f"R² no teste: {r2_ridge:.4f}")

# 7. Comparação com Linear Regression
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)
mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")
print(f"Ridge reduziu MSE em {(mse_lr - mse_ridge)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Valores Reais
plt.subplot(1, 2, 1)
plt.scatter(y_test, y_pred_ridge, alpha=0.6, edgecolors='k', linewidth=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Valores Reais')
plt.ylabel('Previsões')
plt.title(f'Ridge: Previsões vs Real\nR² = {r2_ridge:.3f}')

# Gráfico 2: Distribuição dos Erros
plt.subplot(1, 2, 2)
erros = y_test - y_pred_ridge
sns.histplot(erros, bins=30, kde=True)
plt.xlabel('Erro (Real - Previsto)')
plt.ylabel('Frequência')
plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}, Std = {erros.std():.3f}')
plt.tight_layout()
plt.show()

# Gráfico 3: Comparação de Coeficientes
plt.figure(figsize=(10, 5))
coef_ridge = ridge_model.coef_
coef_lr = lr.coef_
x_pos = np.arange(len(X.columns))
width = 0.35

plt.bar(x_pos - width/2, coef_lr, width, label='Linear Regression', alpha=0.7)
plt.bar(x_pos + width/2, coef_ridge, width, label=f'Ridge (alpha={ridge_model.alpha_:.3f})', alpha=0.7)
plt.xlabel('Características')
plt.ylabel('Coeficiente')
plt.title('Comparação dos Coeficientes')
plt.xticks(x_pos, X.columns, rotation=45, ha='right')
plt.legend()
plt.tight_layout()
plt.show()

# Gráfico 4: Efeito do alpha na validação cruzada
cv_mse = -ridge_model.cv_values_.mean(axis=0)  # Média do MSE por alpha
plt.figure(figsize=(8, 5))
plt.semilogx(alphas, cv_mse, 'b-o', linewidth=2, markersize=6)
plt.axvline(ridge_model.alpha_, color='r', linestyle='--', label=f'Melhor alpha = {ridge_model.alpha_:.4f}')
plt.xlabel('Alpha (escala logarítmica)')
plt.ylabel('MSE médio (validação cruzada)')
plt.title('Escolha do Alpha por Validação Cruzada')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

100

101

102

103

104

105

106

107

108

# Ridge Regression com visualizações

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.linear_model import RidgeCV, LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.datasets import fetch_openml

# Configurar estilo dos gráficos

sns.set_style("whitegrid")

plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados

print("Carregando dados...")

data = fetch_openml(data_id=487, as_frame=True)

X = data.data

y_temp = data.target.to_numpy()

if y_temp.ndim == 2:

y = y_temp[:, 0]

else:

y = y_temp

# 2. Dividir dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

# 3. Padronizar

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# 4. Treinar Ridge com diferentes alphas para análise

alphas = np.logspace(-3, 3, 50)

ridge_model = RidgeCV(alphas=alphas, store_cv_values=True, scoring='neg_mean_squared_error')

ridge_model.fit(X_train_scaled, y_train)

# 5. Resultados

print(f"Melhor alpha: {ridge_model.alpha_:.4f}")

# 6. Previsões

y_pred_ridge = ridge_model.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"MSE no teste: {mse_ridge:.4f}")

print(f"R² no teste: {r2_ridge:.4f}")

# 7. Comparação com Linear Regression

lr = LinearRegression()

lr.fit(X_train_scaled, y_train)

y_pred_lr = lr.predict(X_test_scaled)

mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")

print(f"Ridge reduziu MSE em {(mse_lr - mse_ridge)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Valores Reais

plt.subplot(1, 2, 1)

plt.scatter(y_test, y_pred_ridge, alpha=0.6, edgecolors='k', linewidth=0.5)

plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel('Valores Reais')

plt.ylabel('Previsões')

plt.title(f'Ridge: Previsões vs Real\nR² = {r2_ridge:.3f}')

# Gráfico 2: Distribuição dos Erros

plt.subplot(1, 2, 2)

erros = y_test - y_pred_ridge

sns.histplot(erros, bins=30, kde=True)

plt.xlabel('Erro (Real - Previsto)')

plt.ylabel('Frequência')

plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}, Std = {erros.std():.3f}')

plt.tight_layout()

plt.show()

# Gráfico 3: Comparação de Coeficientes

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

coef_ridge = ridge_model.coef_

coef_lr = lr.coef_

x_pos = np.arange(len(X.columns))

width = 0.35

plt.bar(x_pos - width/2, coef_lr, width, label='Linear Regression', alpha=0.7)

plt.bar(x_pos + width/2, coef_ridge, width, label=f'Ridge (alpha={ridge_model.alpha_:.3f})', alpha=0.7)

plt.xlabel('Características')

plt.ylabel('Coeficiente')

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

plt.xticks(x_pos, X.columns, rotation=45, ha='right')

plt.legend()

plt.tight_layout()

plt.show()

# Gráfico 4: Efeito do alpha na validação cruzada

cv_mse = -ridge_model.cv_values_.mean(axis=0) # Média do MSE por alpha

plt.figure(figsize=(8, 5))

plt.semilogx(alphas, cv_mse, 'b-o', linewidth=2, markersize=6)

plt.axvline(ridge_model.alpha_, color='r', linestyle='--', label=f'Melhor alpha = {ridge_model.alpha_:.4f}')

plt.xlabel('Alpha (escala logarítmica)')

plt.ylabel('MSE médio (validação cruzada)')

plt.title('Escolha do Alpha por Validação Cruzada')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

Exemplo com Lasso

# Lasso Regression com visualizações
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LassoCV, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados
print("Carregando dados...")
data = fetch_openml(data_id=487, as_frame=True)
X = data.data
y_temp = data.target.to_numpy()
if y_temp.ndim == 2:
    y = y_temp[:, 0]
else:
    y = y_temp

# 2. Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Padronizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Treinar Lasso
alphas = np.logspace(-4, 2, 50)
lasso_model = LassoCV(alphas=alphas, cv=5, random_state=42, max_iter=10000)
lasso_model.fit(X_train_scaled, y_train)

# 5. Resultados
print(f"Melhor alpha: {lasso_model.alpha_:.6f}")
print(f"Coeficientes zerados: {np.sum(lasso_model.coef_ == 0)} de {len(lasso_model.coef_)}")

# 6. Previsões
y_pred_lasso = lasso_model.predict(X_test_scaled)
mse_lasso = mean_squared_error(y_test, y_pred_lasso)
r2_lasso = r2_score(y_test, y_pred_lasso)

print(f"MSE no teste: {mse_lasso:.4f}")
print(f"R² no teste: {r2_lasso:.4f}")

# 7. Comparação
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)
mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")
print(f"Lasso reduziu MSE em {(mse_lr - mse_lasso)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real
plt.subplot(1, 2, 1)
plt.scatter(y_test, y_pred_lasso, alpha=0.6, edgecolors='k', linewidth=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Valores Reais')
plt.ylabel('Previsões Lasso')
plt.title(f'Lasso: Previsões vs Real\nR² = {r2_lasso:.3f}')

# Gráfico 2: Distribuição dos Erros
plt.subplot(1, 2, 2)
erros = y_test - y_pred_lasso
sns.histplot(erros, bins=30, kde=True)
plt.xlabel('Erro (Real - Previsto)')
plt.ylabel('Frequência')
plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}')
plt.tight_layout()
plt.show()

# Gráfico 3: Coeficientes do Lasso (destacando zerados)
plt.figure(figsize=(10, 5))
cores = ['red' if c == 0 else 'steelblue' for c in lasso_model.coef_]
plt.bar(range(len(lasso_model.coef_)), lasso_model.coef_, color=cores, alpha=0.7)
plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)
plt.xlabel('Características')
plt.ylabel('Coeficiente')
plt.title(f'Coeficientes do Lasso (alpha={lasso_model.alpha_:.5f})\nVermelho = zerados')
plt.xticks(range(len(X.columns)), X.columns, rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Gráfico 4: Caminho de regularização
print("\nCalculando caminho de regularização...")
alphas_path = np.logspace(-4, 2, 100)
coefs = []
for a in alphas_path:
    from sklearn.linear_model import Lasso
    lasso_temp = Lasso(alpha=a, max_iter=10000)
    lasso_temp.fit(X_train_scaled, y_train)
    coefs.append(lasso_temp.coef_)

coefs = np.array(coefs)
plt.figure(figsize=(10, 5))
for i in range(coefs.shape[1]):
    plt.semilogx(alphas_path, coefs[:, i], label=X.columns[i], linewidth=2)
plt.axvline(lasso_model.alpha_, color='black', linestyle='--', label=f'Alpha escolhido = {lasso_model.alpha_:.5f}')
plt.xlabel('Alpha (log scale)')
plt.ylabel('Coeficientes')
plt.title('Caminho de Regularização do Lasso')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

# Lasso Regression com visualizações

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LassoCV, LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")

plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados

print("Carregando dados...")

data = fetch_openml(data_id=487, as_frame=True)

X = data.data

y_temp = data.target.to_numpy()

if y_temp.ndim == 2:

y = y_temp[:, 0]

else:

y = y_temp

# 2. Dividir dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

# 3. Padronizar

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# 4. Treinar Lasso

alphas = np.logspace(-4, 2, 50)

lasso_model = LassoCV(alphas=alphas, cv=5, random_state=42, max_iter=10000)

lasso_model.fit(X_train_scaled, y_train)

# 5. Resultados

print(f"Melhor alpha: {lasso_model.alpha_:.6f}")

print(f"Coeficientes zerados: {np.sum(lasso_model.coef_ == 0)} de {len(lasso_model.coef_)}")

# 6. Previsões

y_pred_lasso = lasso_model.predict(X_test_scaled)

mse_lasso = mean_squared_error(y_test, y_pred_lasso)

r2_lasso = r2_score(y_test, y_pred_lasso)

print(f"MSE no teste: {mse_lasso:.4f}")

print(f"R² no teste: {r2_lasso:.4f}")

# 7. Comparação

lr = LinearRegression()

lr.fit(X_train_scaled, y_train)

y_pred_lr = lr.predict(X_test_scaled)

mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")

print(f"Lasso reduziu MSE em {(mse_lr - mse_lasso)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real

plt.subplot(1, 2, 1)

plt.scatter(y_test, y_pred_lasso, alpha=0.6, edgecolors='k', linewidth=0.5)

plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel('Valores Reais')

plt.ylabel('Previsões Lasso')

plt.title(f'Lasso: Previsões vs Real\nR² = {r2_lasso:.3f}')

# Gráfico 2: Distribuição dos Erros

plt.subplot(1, 2, 2)

erros = y_test - y_pred_lasso

sns.histplot(erros, bins=30, kde=True)

plt.xlabel('Erro (Real - Previsto)')

plt.ylabel('Frequência')

plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}')

plt.tight_layout()

plt.show()

# Gráfico 3: Coeficientes do Lasso (destacando zerados)

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

cores = ['red' if c == 0 else 'steelblue' for c in lasso_model.coef_]

plt.bar(range(len(lasso_model.coef_)), lasso_model.coef_, color=cores, alpha=0.7)

plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)

plt.xlabel('Características')

plt.ylabel('Coeficiente')

plt.title(f'Coeficientes do Lasso (alpha={lasso_model.alpha_:.5f})\nVermelho = zerados')

plt.xticks(range(len(X.columns)), X.columns, rotation=45, ha='right')

plt.tight_layout()

plt.show()

# Gráfico 4: Caminho de regularização

print("\nCalculando caminho de regularização...")

alphas_path = np.logspace(-4, 2, 100)

coefs = []

for a in alphas_path:

from sklearn.linear_model import Lasso

lasso_temp = Lasso(alpha=a, max_iter=10000)

lasso_temp.fit(X_train_scaled, y_train)

coefs.append(lasso_temp.coef_)

coefs = np.array(coefs)

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

for i in range(coefs.shape[1]):

plt.semilogx(alphas_path, coefs[:, i], label=X.columns[i], linewidth=2)

plt.axvline(lasso_model.alpha_, color='black', linestyle='--', label=f'Alpha escolhido = {lasso_model.alpha_:.5f}')

plt.xlabel('Alpha (log scale)')

plt.ylabel('Coeficientes')

plt.title('Caminho de Regularização do Lasso')

plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

Exemplo com Elastic Net

# Elastic Net Regression com visualizações
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import ElasticNetCV, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (14, 6)

# 1. Carregar dados
print("Carregando dados...")
data = fetch_openml(data_id=487, as_frame=True)
X = data.data
y_temp = data.target.to_numpy()
if y_temp.ndim == 2:
    y = y_temp[:, 0]
else:
    y = y_temp

# 2. Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Padronizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Treinar Elastic Net
alphas = np.logspace(-4, 2, 30)
l1_ratios = np.linspace(0.1, 0.9, 9)
elastic_model = ElasticNetCV(
    l1_ratio=l1_ratios,
    alphas=alphas,
    cv=5,
    random_state=42,
    max_iter=10000
)
elastic_model.fit(X_train_scaled, y_train)

# 5. Resultados
print(f"Melhor alpha: {elastic_model.alpha_:.6f}")
print(f"Melhor l1_ratio: {elastic_model.l1_ratio_:.3f}")
print(f"Coeficientes zerados: {np.sum(elastic_model.coef_ == 0)} de {len(elastic_model.coef_)}")

# 6. Previsões
y_pred_elastic = elastic_model.predict(X_test_scaled)
mse_elastic = mean_squared_error(y_test, y_pred_elastic)
r2_elastic = r2_score(y_test, y_pred_elastic)

print(f"MSE no teste: {mse_elastic:.4f}")
print(f"R² no teste: {r2_elastic:.4f}")

# 7. Comparação
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)
mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")
print(f"Elastic Net reduziu MSE em {(mse_lr - mse_elastic)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real
plt.subplot(1, 2, 1)
plt.scatter(y_test, y_pred_elastic, alpha=0.6, edgecolors='k', linewidth=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Valores Reais')
plt.ylabel('Previsões Elastic Net')
plt.title(f'Elastic Net: Previsões vs Real\nR² = {r2_elastic:.3f}')

# Gráfico 2: Distribuição dos Erros
plt.subplot(1, 2, 2)
erros = y_test - y_pred_elastic
sns.histplot(erros, bins=30, kde=True)
plt.xlabel('Erro (Real - Previsto)')
plt.ylabel('Frequência')
plt.title(f'Distribuição dos Erros\nStd = {erros.std():.3f}')
plt.tight_layout()
plt.show()

# Gráfico 3: Coeficientes dos três métodos
plt.figure(figsize=(12, 5))
x_pos = np.arange(len(X.columns))
width = 0.25

# Re-treinar Ridge e Lasso para comparação justa
from sklearn.linear_model import Ridge, Lasso
ridge_comp = Ridge(alpha=elastic_model.alpha_)
lasso_comp = Lasso(alpha=elastic_model.alpha_, max_iter=10000)
ridge_comp.fit(X_train_scaled, y_train)
lasso_comp.fit(X_train_scaled, y_train)

plt.bar(x_pos - width, ridge_comp.coef_, width, label='Ridge', alpha=0.7)
plt.bar(x_pos, lasso_comp.coef_, width, label='Lasso', alpha=0.7)
plt.bar(x_pos + width, elastic_model.coef_, width, label=f'Elastic Net (l1_ratio={elastic_model.l1_ratio_:.2f})', alpha=0.7)

plt.xlabel('Características')
plt.ylabel('Coeficiente')
plt.title('Comparação de Coeficientes entre Métodos')
plt.xticks(x_pos, X.columns, rotation=45, ha='right')
plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)
plt.legend()
plt.tight_layout()
plt.show()

# Gráfico 4: Heatmap do desempenho por alpha e l1_ratio
print("\nGerando heatmap da validação cruzada...")
mse_matrix = elastic_model.mse_path_.mean(axis=2)  # média dos folds

plt.figure(figsize=(10, 6))
im = plt.imshow(mse_matrix, aspect='auto', cmap='viridis_r', origin='lower')
plt.colorbar(im, label='MSE médio')
plt.xlabel('Índice de alpha')
plt.ylabel('Índice de l1_ratio')
plt.title('Desempenho da Validação Cruzada - Elastic Net')
yticks = range(len(l1_ratios))
yticklabels = [f'{r:.2f}' for r in l1_ratios]
plt.yticks(yticks, yticklabels)
plt.tight_layout()
plt.show()

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

# Elastic Net Regression com visualizações

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.linear_model import ElasticNetCV, LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")

plt.rcParams['figure.figsize'] = (14, 6)

# 1. Carregar dados

print("Carregando dados...")

data = fetch_openml(data_id=487, as_frame=True)

X = data.data

y_temp = data.target.to_numpy()

if y_temp.ndim == 2:

y = y_temp[:, 0]

else:

y = y_temp

# 2. Dividir dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

# 3. Padronizar

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# 4. Treinar Elastic Net

alphas = np.logspace(-4, 2, 30)

l1_ratios = np.linspace(0.1, 0.9, 9)

elastic_model = ElasticNetCV(

l1_ratio=l1_ratios,

alphas=alphas,

cv=5,

random_state=42,

max_iter=10000

)

elastic_model.fit(X_train_scaled, y_train)

# 5. Resultados

print(f"Melhor alpha: {elastic_model.alpha_:.6f}")

print(f"Melhor l1_ratio: {elastic_model.l1_ratio_:.3f}")

print(f"Coeficientes zerados: {np.sum(elastic_model.coef_ == 0)} de {len(elastic_model.coef_)}")

# 6. Previsões

y_pred_elastic = elastic_model.predict(X_test_scaled)

mse_elastic = mean_squared_error(y_test, y_pred_elastic)

r2_elastic = r2_score(y_test, y_pred_elastic)

print(f"MSE no teste: {mse_elastic:.4f}")

print(f"R² no teste: {r2_elastic:.4f}")

# 7. Comparação

lr = LinearRegression()

lr.fit(X_train_scaled, y_train)

y_pred_lr = lr.predict(X_test_scaled)

mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")

print(f"Elastic Net reduziu MSE em {(mse_lr - mse_elastic)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real

plt.subplot(1, 2, 1)

plt.scatter(y_test, y_pred_elastic, alpha=0.6, edgecolors='k', linewidth=0.5)

plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel('Valores Reais')

plt.ylabel('Previsões Elastic Net')

plt.title(f'Elastic Net: Previsões vs Real\nR² = {r2_elastic:.3f}')

# Gráfico 2: Distribuição dos Erros

plt.subplot(1, 2, 2)

erros = y_test - y_pred_elastic

sns.histplot(erros, bins=30, kde=True)

plt.xlabel('Erro (Real - Previsto)')

plt.ylabel('Frequência')

plt.title(f'Distribuição dos Erros\nStd = {erros.std():.3f}')

plt.tight_layout()

plt.show()

# Gráfico 3: Coeficientes dos três métodos

plt.figure(figsize=(12, 5))

x_pos = np.arange(len(X.columns))

width = 0.25

# Re-treinar Ridge e Lasso para comparação justa

from sklearn.linear_model import Ridge, Lasso

ridge_comp = Ridge(alpha=elastic_model.alpha_)

lasso_comp = Lasso(alpha=elastic_model.alpha_, max_iter=10000)

ridge_comp.fit(X_train_scaled, y_train)

lasso_comp.fit(X_train_scaled, y_train)

plt.bar(x_pos - width, ridge_comp.coef_, width, label='Ridge', alpha=0.7)

plt.bar(x_pos, lasso_comp.coef_, width, label='Lasso', alpha=0.7)

plt.bar(x_pos + width, elastic_model.coef_, width, label=f'Elastic Net (l1_ratio={elastic_model.l1_ratio_:.2f})', alpha=0.7)

plt.xlabel('Características')

plt.ylabel('Coeficiente')

plt.title('Comparação de Coeficientes entre Métodos')

plt.xticks(x_pos, X.columns, rotation=45, ha='right')

plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)

plt.legend()

plt.tight_layout()

plt.show()

# Gráfico 4: Heatmap do desempenho por alpha e l1_ratio

print("\nGerando heatmap da validação cruzada...")

mse_matrix = elastic_model.mse_path_.mean(axis=2) # média dos folds

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

im = plt.imshow(mse_matrix, aspect='auto', cmap='viridis_r', origin='lower')

plt.colorbar(im, label='MSE médio')

plt.xlabel('Índice de alpha')

plt.ylabel('Índice de l1_ratio')

plt.title('Desempenho da Validação Cruzada - Elastic Net')

yticks = range(len(l1_ratios))

yticklabels = [f'{r:.2f}' for r in l1_ratios]

plt.yticks(yticks, yticklabels)

plt.tight_layout()

plt.show()