Arquivo de regressao-logistica

Modelos Lineares Generalizados: Regressão logística

19/12/202518/10/2025 Por antonino

Anteriormente exploramos diversos algoritmos de regressão linear. Analogamente, a Regressão Logística é uma técnica fundamental para problemas de classificação, apesar do nome sugerir regressão. Decerto, ela modela a probabilidade de uma observação pertencer a uma determinada classe.

Conceito Fundamental da Regressão Logística

Primordialmente, a regressão logística utiliza uma função sigmoide para mapear saídas lineares em probabilidades entre 0 e 1. Similarmente aos modelos lineares, ela encontra uma combinação linear das features, mas aplica uma transformação não-linear para produzir probabilidades.

Conforme a documentação do scikit-learn, a regressão logística é particularmente útil para problemas de classificação binária, mas também suporta classificação multiclasse através das abordagens “one-vs-rest” (OvR) e “multinomial”.

Formulação Matemática

Para classificação binária, a probabilidade é modelada como:

\(P(y=1|X) = \frac{1}{1 + e^{-(w^T X + b)}}\)

Onde:

X é o vetor de features
w são os coeficientes do modelo
b é o termo de intercept (bias)
e é a base do logaritmo natural

A função de custo (log loss) é definida como:

\(J(w) = -\frac{1}{n}\sum_{i=1}^n [y_i\log(p_i) + (1-y_i)\log(1-p_i)]\)

Implementações no Scikit-learn

Atualmente, o scikit-learn oferece implementações versáteis da regressão logística:

LogisticRegression: Implementação principal com vários solvers
LogisticRegressionCV: Versão com validação cruzada embutida

Solvers Disponíveis

Diferentes algoritmos de otimização estão disponíveis:

liblinear: Recomendado para datasets pequenos
lbfgs: Bom para problemas com muitas features
newton-cg: Usa método de Newton
sag: Gradiente descendente estocástico médio
saga: Extensão do SAG com suporte a L1

Exemplo Prático: Regressão Logística em Ação

Ademais, vejamos um exemplo completo demonstrando o uso da regressão logística:

'''
Aplicação da Regressão Logística para Classificação
Este exemplo demonstra o uso da regressão logística
para problemas de classificação binária e multiclasse
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification, load_iris
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import (accuracy_score, classification_report, 
                           confusion_matrix, ConfusionMatrixDisplay, 
                           roc_curve, auc)

# Exemplo 1: Classificação Binária
print("=== CLASSIFICAÇÃO BINÁRIA ===")

# Gerar dataset binário
X_bin, y_bin = make_classification(n_samples=1000, n_features=20, 
                                  n_informative=10, n_redundant=5,
                                  n_clusters_per_class=1, 
                                  random_state=42)

print("Configuração do Dataset Binário:")
print(f"Número de amostras: {X_bin.shape[0]}")
print(f"Número de features: {X_bin.shape[1]}")
print(f"Distribuição das classes: {np.bincount(y_bin)}")

# Dividir em treino e teste
X_train_bin, X_test_bin, y_train_bin, y_test_bin = train_test_split(
    X_bin, y_bin, test_size=0.3, random_state=42, stratify=y_bin)

# Normalizar os dados
scaler_bin = StandardScaler()
X_train_bin_scaled = scaler_bin.fit_transform(X_train_bin)
X_test_bin_scaled = scaler_bin.transform(X_test_bin)

# Regressão Logística com validação cruzada
logreg_cv = LogisticRegressionCV(cv=5, random_state=42, max_iter=1000)
logreg_cv.fit(X_train_bin_scaled, y_train_bin)

# Regressão Logística padrão
logreg = LogisticRegression(random_state=42, max_iter=1000)
logreg.fit(X_train_bin_scaled, y_train_bin)

# Fazer previsões
y_pred_bin_cv = logreg_cv.predict(X_test_bin_scaled)
y_pred_bin = logreg.predict(X_test_bin_scaled)

# Calcular probabilidades (para curva ROC)
y_prob_bin_cv = logreg_cv.predict_proba(X_test_bin_scaled)[:, 1]
y_prob_bin = logreg.predict_proba(X_test_bin_scaled)[:, 1]

print(f"\nResultados - Classificação Binária:")
print(f"LogisticRegressionCV - Acurácia: {accuracy_score(y_test_bin, y_pred_bin_cv):.4f}")
print(f"LogisticRegression - Acurácia: {accuracy_score(y_test_bin, y_pred_bin):.4f}")
print(f"Melhor C (validação cruzada): {logreg_cv.C_[0]:.6f}")

# Exemplo 2: Classificação Multiclasse
print(f"\n=== CLASSIFICAÇÃO MULTICLASSE ===")

# Carregar dataset Iris
iris = load_iris()
X_multi, y_multi = iris.data, iris.target

print("Dataset Iris - Informações:")
print(f"Número de amostras: {X_multi.shape[0]}")
print(f"Número de features: {X_multi.shape[1]}")
print(f"Classes: {iris.target_names}")
print(f"Distribuição: {np.bincount(y_multi)}")

# Dividir em treino e teste
X_train_multi, X_test_multi, y_train_multi, y_test_multi = train_test_split(
    X_multi, y_multi, test_size=0.3, random_state=42, stratify=y_multi)

# Normalizar
scaler_multi = StandardScaler()
X_train_multi_scaled = scaler_multi.fit_transform(X_train_multi)
X_test_multi_scaled = scaler_multi.transform(X_test_multi)

# Regressão Logística multiclasse
logreg_multi = LogisticRegression(random_state=42, max_iter=1000, 
                                 multi_class='multinomial')
logreg_multi.fit(X_train_multi_scaled, y_train_multi)

y_pred_multi = logreg_multi.predict(X_test_multi_scaled)
y_prob_multi = logreg_multi.predict_proba(X_test_multi_scaled)

print(f"\nResultados - Classificação Multiclasse:")
print(f"Acurácia: {accuracy_score(y_test_multi, y_pred_multi):.4f}")
print(f"\nRelatório de Classificação:")
print(classification_report(y_test_multi, y_pred_multi, 
                          target_names=iris.target_names))

# Visualização dos resultados
plt.figure(figsize=(18, 12))

# Gráfico 1: Curva ROC (Binária)
plt.subplot(3, 4, 1)
fpr_cv, tpr_cv, _ = roc_curve(y_test_bin, y_prob_bin_cv)
fpr, tpr, _ = roc_curve(y_test_bin, y_prob_bin)
roc_auc_cv = auc(fpr_cv, tpr_cv)
roc_auc = auc(fpr, tpr)

plt.plot(fpr_cv, tpr_cv, label=f'CV (AUC = {roc_auc_cv:.3f})', linewidth=2)
plt.plot(fpr, tpr, label=f'Padrão (AUC = {roc_auc:.3f})', linewidth=2, linestyle='--')
plt.plot([0, 1], [0, 1], 'k--', alpha=0.5)
plt.xlabel('Taxa de Falsos Positivos')
plt.ylabel('Taxa de Verdadeiros Positivos')
plt.title('Curva ROC - Classificação Binária')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 2: Coeficientes do modelo (Binário)
plt.subplot(3, 4, 2)
coef_bin = logreg_cv.coef_[0]
plt.bar(range(len(coef_bin)), coef_bin, alpha=0.7)
plt.xlabel('Índice da Feature')
plt.ylabel('Valor do Coeficiente')
plt.title('Coeficientes - Modelo Binário')
plt.grid(True, alpha=0.3)

# Gráfico 3: Matriz de Confusão (Binária)
plt.subplot(3, 4, 3)
cm_bin = confusion_matrix(y_test_bin, y_pred_bin_cv)
disp_bin = ConfusionMatrixDisplay(confusion_matrix=cm_bin, 
                                 display_labels=['Classe 0', 'Classe 1'])
disp_bin.plot(ax=plt.gca(), cmap='Blues')
plt.title('Matriz de Confusão - Binária')

# Gráfico 4: Distribuição de probabilidades (Binária)
plt.subplot(3, 4, 4)
plt.hist(y_prob_bin_cv[y_test_bin == 0], bins=20, alpha=0.7, 
         label='Classe 0', color='red')
plt.hist(y_prob_bin_cv[y_test_bin == 1], bins=20, alpha=0.7, 
         label='Classe 1', color='blue')
plt.xlabel('Probabilidade da Classe 1')
plt.ylabel('Frequência')
plt.title('Distribuição de Probabilidades')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 5: Coeficientes do modelo multiclasse
plt.subplot(3, 4, 5)
coef_multi = logreg_multi.coef_
for i, class_name in enumerate(iris.target_names):
    plt.plot(coef_multi[i], 'o-', label=class_name, alpha=0.7)
plt.xlabel('Índice da Feature')
plt.ylabel('Valor do Coeficiente')
plt.title('Coeficientes - Modelo Multiclasse')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 6: Matriz de Confusão (Multiclasse)
plt.subplot(3, 4, 6)
cm_multi = confusion_matrix(y_test_multi, y_pred_multi)
disp_multi = ConfusionMatrixDisplay(confusion_matrix=cm_multi, 
                                   display_labels=iris.target_names)
disp_multi.plot(ax=plt.gca(), cmap='Blues')
plt.title('Matriz de Confusão - Multiclasse')

# Gráfico 7: Probabilidades por classe (Multiclasse)
plt.subplot(3, 4, 7)
for i, class_name in enumerate(iris.target_names):
    class_probs = y_prob_multi[y_test_multi == i, i]
    plt.hist(class_probs, bins=15, alpha=0.6, label=class_name)
plt.xlabel('Probabilidade da Classe Correta')
plt.ylabel('Frequência')
plt.title('Probabilidades por Classe')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 8: Comparação de diferentes valores de C
plt.subplot(3, 4, 8)
C_values = [0.001, 0.01, 0.1, 1, 10, 100, 1000]
cv_scores = []

for C in C_values:
    logreg_temp = LogisticRegression(C=C, random_state=42, max_iter=1000)
    scores = cross_val_score(logreg_temp, X_train_bin_scaled, y_train_bin, 
                           cv=5, scoring='accuracy')
    cv_scores.append(scores.mean())

plt.semilogx(C_values, cv_scores, 'o-', linewidth=2)
plt.axvline(x=logreg_cv.C_[0], color='red', linestyle='--', 
            label=f'Melhor C: {logreg_cv.C_[0]:.3f}')
plt.xlabel('Valor de C (Inverso da Regularização)')
plt.ylabel('Acurácia (Validação Cruzada)')
plt.title('Performance vs Parâmetro C')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 9: Comparação de solvers
plt.subplot(3, 4, 9)
solvers = ['liblinear', 'lbfgs', 'newton-cg', 'sag', 'saga']
solver_scores = []

for solver in solvers:
    try:
        logreg_solver = LogisticRegression(solver=solver, random_state=42, 
                                         max_iter=1000)
        scores = cross_val_score(logreg_solver, X_train_bin_scaled, y_train_bin, 
                               cv=5, scoring='accuracy')
        solver_scores.append(scores.mean())
    except:
        solver_scores.append(0)  # Para solvers não suportados

plt.bar(solvers, solver_scores, alpha=0.7)
plt.ylabel('Acurácia (Validação Cruzada)')
plt.title('Comparação de Solvers')
plt.xticks(rotation=45)
for i, v in enumerate(solver_scores):
    plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')

# Gráfico 10: Regularização L1 vs L2
plt.subplot(3, 4, 10)
penalties = ['l1', 'l2']
penalty_scores = []

for penalty in penalties:
    try:
        logreg_penalty = LogisticRegression(penalty=penalty, solver='liblinear',
                                          random_state=42, max_iter=1000)
        scores = cross_val_score(logreg_penalty, X_train_bin_scaled, y_train_bin, 
                               cv=5, scoring='accuracy')
        penalty_scores.append(scores.mean())
    except:
        penalty_scores.append(0)

plt.bar(penalties, penalty_scores, alpha=0.7, color=['lightcoral', 'lightgreen'])
plt.ylabel('Acurácia (Validação Cruzada)')
plt.title('L1 vs L2 Regularization')
for i, v in enumerate(penalty_scores):
    plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')

# Gráfico 11: Features mais importantes
plt.subplot(3, 4, 11)
feature_importance = np.abs(logreg_cv.coef_[0])
top_features = np.argsort(feature_importance)[-10:]  # Top 10 features
plt.barh(range(len(top_features)), feature_importance[top_features])
plt.yticks(range(len(top_features)), [f'Feature {i}' for i in top_features])
plt.xlabel('Importância (Valor Absoluto)')
plt.title('Top 10 Features Mais Importantes')

# Gráfico 12: Limite de decisão (para 2 features)
plt.subplot(3, 4, 12)
# Usar apenas duas primeiras features para visualização
X_2d = X_train_bin_scaled[:, :2]
logreg_2d = LogisticRegression(random_state=42, max_iter=1000)
logreg_2d.fit(X_2d, y_train_bin)

# Criar mesh para plotar limite de decisão
h = 0.02
x_min, x_max = X_2d[:, 0].min() - 0.5, X_2d[:, 0].max() + 0.5
y_min, y_max = X_2d[:, 1].min() - 0.5, X_2d[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                    np.arange(y_min, y_max, h))

Z = logreg_2d.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.coolwarm)
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y_train_bin, cmap=plt.cm.coolwarm, 
           edgecolors='k', alpha=0.7)
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Limite de Decisão (2 Features)')

plt.tight_layout()
plt.show()

# Análise final
print(f"\n=== ANÁLISE FINAL ===")
print(f"Melhor solver para este dataset: {solvers[np.argmax(solver_scores)]}")
print(f"Melhor tipo de regularização: {penalties[np.argmax(penalty_scores)]}")
print(f"Features mais importantes: {top_features[-3:][::-1]}")  # Top 3
print(f"Acurácia final (binária): {accuracy_score(y_test_bin, y_pred_bin_cv):.4f}")
print(f"Acurácia final (multiclasse): {accuracy_score(y_test_multi, y_pred_multi):.4f}")

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

'''

Aplicação da Regressão Logística para Classificação

Este exemplo demonstra o uso da regressão logística

para problemas de classificação binária e multiclasse

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_classification, load_iris

from sklearn.linear_model import LogisticRegression, LogisticRegressionCV

from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import (accuracy_score, classification_report,

confusion_matrix, ConfusionMatrixDisplay,

roc_curve, auc)

# Exemplo 1: Classificação Binária

print("=== CLASSIFICAÇÃO BINÁRIA ===")

# Gerar dataset binário

X_bin, y_bin = make_classification(n_samples=1000, n_features=20,

n_informative=10, n_redundant=5,

n_clusters_per_class=1,

random_state=42)

print("Configuração do Dataset Binário:")

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

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

print(f"Distribuição das classes: {np.bincount(y_bin)}")

# Dividir em treino e teste

X_train_bin, X_test_bin, y_train_bin, y_test_bin = train_test_split(

X_bin, y_bin, test_size=0.3, random_state=42, stratify=y_bin)

# Normalizar os dados

scaler_bin = StandardScaler()

X_train_bin_scaled = scaler_bin.fit_transform(X_train_bin)

X_test_bin_scaled = scaler_bin.transform(X_test_bin)

# Regressão Logística com validação cruzada

logreg_cv = LogisticRegressionCV(cv=5, random_state=42, max_iter=1000)

logreg_cv.fit(X_train_bin_scaled, y_train_bin)

# Regressão Logística padrão

logreg = LogisticRegression(random_state=42, max_iter=1000)

logreg.fit(X_train_bin_scaled, y_train_bin)

# Fazer previsões

y_pred_bin_cv = logreg_cv.predict(X_test_bin_scaled)

y_pred_bin = logreg.predict(X_test_bin_scaled)

# Calcular probabilidades (para curva ROC)

y_prob_bin_cv = logreg_cv.predict_proba(X_test_bin_scaled)[:, 1]

y_prob_bin = logreg.predict_proba(X_test_bin_scaled)[:, 1]

print(f"\nResultados - Classificação Binária:")

print(f"LogisticRegressionCV - Acurácia: {accuracy_score(y_test_bin, y_pred_bin_cv):.4f}")

print(f"LogisticRegression - Acurácia: {accuracy_score(y_test_bin, y_pred_bin):.4f}")

print(f"Melhor C (validação cruzada): {logreg_cv.C_[0]:.6f}")

# Exemplo 2: Classificação Multiclasse

print(f"\n=== CLASSIFICAÇÃO MULTICLASSE ===")

# Carregar dataset Iris

iris = load_iris()

X_multi, y_multi = iris.data, iris.target

print("Dataset Iris - Informações:")

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

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

print(f"Classes: {iris.target_names}")

print(f"Distribuição: {np.bincount(y_multi)}")

# Dividir em treino e teste

X_train_multi, X_test_multi, y_train_multi, y_test_multi = train_test_split(

X_multi, y_multi, test_size=0.3, random_state=42, stratify=y_multi)

# Normalizar

scaler_multi = StandardScaler()

X_train_multi_scaled = scaler_multi.fit_transform(X_train_multi)

X_test_multi_scaled = scaler_multi.transform(X_test_multi)

# Regressão Logística multiclasse

logreg_multi = LogisticRegression(random_state=42, max_iter=1000,

multi_class='multinomial')

logreg_multi.fit(X_train_multi_scaled, y_train_multi)

y_pred_multi = logreg_multi.predict(X_test_multi_scaled)

y_prob_multi = logreg_multi.predict_proba(X_test_multi_scaled)

print(f"\nResultados - Classificação Multiclasse:")

print(f"Acurácia: {accuracy_score(y_test_multi, y_pred_multi):.4f}")

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

print(classification_report(y_test_multi, y_pred_multi,

target_names=iris.target_names))

# Visualização dos resultados

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

# Gráfico 1: Curva ROC (Binária)

plt.subplot(3, 4, 1)

fpr_cv, tpr_cv, _ = roc_curve(y_test_bin, y_prob_bin_cv)

fpr, tpr, _ = roc_curve(y_test_bin, y_prob_bin)

roc_auc_cv = auc(fpr_cv, tpr_cv)

roc_auc = auc(fpr, tpr)

plt.plot(fpr_cv, tpr_cv, label=f'CV (AUC = {roc_auc_cv:.3f})', linewidth=2)

plt.plot(fpr, tpr, label=f'Padrão (AUC = {roc_auc:.3f})', linewidth=2, linestyle='--')

plt.plot([0, 1], [0, 1], 'k--', alpha=0.5)

plt.xlabel('Taxa de Falsos Positivos')

plt.ylabel('Taxa de Verdadeiros Positivos')

plt.title('Curva ROC - Classificação Binária')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 2: Coeficientes do modelo (Binário)

plt.subplot(3, 4, 2)

coef_bin = logreg_cv.coef_[0]

plt.bar(range(len(coef_bin)), coef_bin, alpha=0.7)

plt.xlabel('Índice da Feature')

plt.ylabel('Valor do Coeficiente')

plt.title('Coeficientes - Modelo Binário')

plt.grid(True, alpha=0.3)

# Gráfico 3: Matriz de Confusão (Binária)

plt.subplot(3, 4, 3)

cm_bin = confusion_matrix(y_test_bin, y_pred_bin_cv)

disp_bin = ConfusionMatrixDisplay(confusion_matrix=cm_bin,

display_labels=['Classe 0', 'Classe 1'])

disp_bin.plot(ax=plt.gca(), cmap='Blues')

plt.title('Matriz de Confusão - Binária')

# Gráfico 4: Distribuição de probabilidades (Binária)

plt.subplot(3, 4, 4)

plt.hist(y_prob_bin_cv[y_test_bin == 0], bins=20, alpha=0.7,

label='Classe 0', color='red')

plt.hist(y_prob_bin_cv[y_test_bin == 1], bins=20, alpha=0.7,

label='Classe 1', color='blue')

plt.xlabel('Probabilidade da Classe 1')

plt.ylabel('Frequência')

plt.title('Distribuição de Probabilidades')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 5: Coeficientes do modelo multiclasse

plt.subplot(3, 4, 5)

coef_multi = logreg_multi.coef_

for i, class_name in enumerate(iris.target_names):

plt.plot(coef_multi[i], 'o-', label=class_name, alpha=0.7)

plt.xlabel('Índice da Feature')

plt.ylabel('Valor do Coeficiente')

plt.title('Coeficientes - Modelo Multiclasse')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 6: Matriz de Confusão (Multiclasse)

plt.subplot(3, 4, 6)

cm_multi = confusion_matrix(y_test_multi, y_pred_multi)

disp_multi = ConfusionMatrixDisplay(confusion_matrix=cm_multi,

display_labels=iris.target_names)

disp_multi.plot(ax=plt.gca(), cmap='Blues')

plt.title('Matriz de Confusão - Multiclasse')

# Gráfico 7: Probabilidades por classe (Multiclasse)

plt.subplot(3, 4, 7)

for i, class_name in enumerate(iris.target_names):

class_probs = y_prob_multi[y_test_multi == i, i]

plt.hist(class_probs, bins=15, alpha=0.6, label=class_name)

plt.xlabel('Probabilidade da Classe Correta')

plt.ylabel('Frequência')

plt.title('Probabilidades por Classe')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 8: Comparação de diferentes valores de C

plt.subplot(3, 4, 8)

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

cv_scores = []

for C in C_values:

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

scores = cross_val_score(logreg_temp, X_train_bin_scaled, y_train_bin,

cv=5, scoring='accuracy')

cv_scores.append(scores.mean())

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

plt.axvline(x=logreg_cv.C_[0], color='red', linestyle='--',

label=f'Melhor C: {logreg_cv.C_[0]:.3f}')

plt.xlabel('Valor de C (Inverso da Regularização)')

plt.ylabel('Acurácia (Validação Cruzada)')

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

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 9: Comparação de solvers

plt.subplot(3, 4, 9)

solvers = ['liblinear', 'lbfgs', 'newton-cg', 'sag', 'saga']

solver_scores = []

for solver in solvers:

try:

logreg_solver = LogisticRegression(solver=solver, random_state=42,

max_iter=1000)

scores = cross_val_score(logreg_solver, X_train_bin_scaled, y_train_bin,

cv=5, scoring='accuracy')

solver_scores.append(scores.mean())

except:

solver_scores.append(0) # Para solvers não suportados

plt.bar(solvers, solver_scores, alpha=0.7)

plt.ylabel('Acurácia (Validação Cruzada)')

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

plt.xticks(rotation=45)

for i, v in enumerate(solver_scores):

plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')

# Gráfico 10: Regularização L1 vs L2

plt.subplot(3, 4, 10)

penalties = ['l1', 'l2']

penalty_scores = []

for penalty in penalties:

try:

logreg_penalty = LogisticRegression(penalty=penalty, solver='liblinear',

random_state=42, max_iter=1000)

scores = cross_val_score(logreg_penalty, X_train_bin_scaled, y_train_bin,

cv=5, scoring='accuracy')

penalty_scores.append(scores.mean())

except:

penalty_scores.append(0)

plt.bar(penalties, penalty_scores, alpha=0.7, color=['lightcoral', 'lightgreen'])

plt.ylabel('Acurácia (Validação Cruzada)')

plt.title('L1 vs L2 Regularization')

for i, v in enumerate(penalty_scores):

plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')

# Gráfico 11: Features mais importantes

plt.subplot(3, 4, 11)

feature_importance = np.abs(logreg_cv.coef_[0])

top_features = np.argsort(feature_importance)[-10:] # Top 10 features

plt.barh(range(len(top_features)), feature_importance[top_features])

plt.yticks(range(len(top_features)), [f'Feature {i}' for i in top_features])

plt.xlabel('Importância (Valor Absoluto)')

plt.title('Top 10 Features Mais Importantes')

# Gráfico 12: Limite de decisão (para 2 features)

plt.subplot(3, 4, 12)

# Usar apenas duas primeiras features para visualização

X_2d = X_train_bin_scaled[:, :2]

logreg_2d = LogisticRegression(random_state=42, max_iter=1000)

logreg_2d.fit(X_2d, y_train_bin)

# Criar mesh para plotar limite de decisão

h = 0.02

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

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

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

np.arange(y_min, y_max, h))

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

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.coolwarm)

plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y_train_bin, cmap=plt.cm.coolwarm,

edgecolors='k', alpha=0.7)

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title('Limite de Decisão (2 Features)')

plt.tight_layout()

plt.show()

# Análise final

print(f"\n=== ANÁLISE FINAL ===")

print(f"Melhor solver para este dataset: {solvers[np.argmax(solver_scores)]}")

print(f"Melhor tipo de regularização: {penalties[np.argmax(penalty_scores)]}")

print(f"Features mais importantes: {top_features[-3:][::-1]}") # Top 3

print(f"Acurácia final (binária): {accuracy_score(y_test_bin, y_pred_bin_cv):.4f}")

print(f"Acurácia final (multiclasse): {accuracy_score(y_test_multi, y_pred_multi):.4f}")

Vantagens da Regressão Logística

Embora existam algoritmos mais complexos, a regressão logística mantém popularidade devido a:

Vantagens Principais

Interpretabilidade: Coeficientes fornecem insights sobre importância das features
Probabilidades calibradas: Saídas são probabilidades bem calibradas
Eficiência computacional: Treinamento rápido mesmo com muitas features
Regularização: Suporte nativo a L1 e L2 para evitar overfitting

Casos de Uso Recomendados

A regressão logística é particularmente eficaz em:

Problemas de classificação binária: Como detecção de spam, diagnóstico médico
Quando interpretabilidade é importante: Aplicações onde precisa explicar decisões
Baseline para classificação: Ponto de partida para modelos mais complexos
Dados tabulares: Com features numéricas e categóricas

Considerações Práticas

Algumas recomendações importantes para uso eficaz:

Normalize os dados para melhor performance e convergência
Use LogisticRegressionCV para seleção automática do parâmetro C
Escolha o solver apropriado baseado no tamanho do dataset e tipo de regularização
Para problemas desbalanceados, use class_weight=’balanced’

Enfim, a regressão logística representa uma ferramenta fundamental no arsenal de machine learning, combinando simplicidade, interpretabilidade e performance robusta para uma ampla gama de problemas de classificação.

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

Lasso LARS e a fusão entre Regularização L1 e Abordagem Geométric

19/12/202517/10/2025 Por antonino

Introdução ao Lasso LARS

O Lasso LARS constitui uma implementação eficiente que combina as vantagens da regressão Lasso com o algoritmo Least Angle Regression. Primordialmente, esta abordagem permite computar a solução completa do caminho Lasso de forma computacionalmente eficiente, sem a necessidade de otimização convexa iterativa.

Princípio de Funcionamento

O Lasso LARS opera através de um processo sequencial similar ao LARS tradicional, mas com uma modificação crucial: quando um coeficiente atinge zero, a feature correspondente é removida do conjunto ativo. Esta simples alteração garante que as soluções produzidas sejam idênticas às do Lasso convencional.

Diferenciação do LARS Clássico

Enquanto o LARS tradicional sempre mantém as features no modelo uma vez selecionadas, o Lasso LARS permite a remoção de features quando seus coeficientes se tornam zero. Isto produz modelos mais esparsos e alinhados com a filosofia de seleção de features do Lasso.

Vantagens Computacionais

Computação eficiente de todo o caminho de regularização
Menor custo computacional para problemas com muitas features
Estabilidade numérica superior em comparação com métodos baseados em descida de gradiente
Capacidade de lidar com situações onde número de features excede número de amostras

Formulação Matemática

O Lasso LARS resolve o mesmo problema de otimização do Lasso tradicional:

\(\min_{w} \frac{1}{2n_{\text{samples}}} ||X w – y||_2^2 + \alpha ||w||_1\)

Contudo, a estratégia de solução é fundamentalmente diferente. Ao invés de otimização convexa, utiliza-se uma abordagem geométrica baseada em direções equiangulares.

Algoritmo Lasso LARS

Iniciar com coeficientes zero e resíduo igual ao target
Encontrar a feature mais correlacionada com o resíduo
Mover na direção desta feature até que outra feature tenha correlação igual
Continuar na direção equiangular entre features ativas
Se algum coeficiente atingir zero, remover a feature do conjunto ativo
Repetir até inclusão de todas as features relevantes

Cenários de Aplicação Ideal

O Lasso LARS é particularmente adequado para:

Problemas com número de features maior que número de amostras (p > n)
Análise exploratória onde se deseja examinar todo o caminho de regularização
Situações que requerem seleção eficiente de features
Aplicações onde a estabilidade numérica é crítica

Implementação no scikit-learn

No scikit-learn, a classe LassoLars implementa esta técnica. Ademais, LassoLarsCV fornece seleção automática do parâmetro alpha através de validação cruzada.

Parâmetros Principais

alpha: Parâmetro de regularização (constante ou array)
fit_intercept: Cálculo do termo intercepto
verbose: Nível de detalhe durante execução
normalize: Normalização prévia dos dados
max_iter: Número máximo de iterações

Exemplo Prático: Comparação com Outras Abordagens

O exemplo a seguir demonstra o uso do Lasso LARS e sua comparação com implementações alternativas do Lasso:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LassoLars, Lasso, LassoLarsIC
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler
import time

print("=" * 60)
print("COMPARAÇÃO: LASSO LARS VS LASSO TRADICIONAL")
print("=" * 60)

# Gerar dados com alta dimensionalidade (p > n scenario)
X, y = make_regression(n_samples=80, n_features=50, n_informative=10, 
                       noise=0.3, random_state=42)

# Normalizar os dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
y_centered = y - np.mean(y)

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

print(f"Cenário p > n: {X.shape[1]} features, {X.shape[0]} amostras")
print(f"Features informativas verdadeiras: 10")

# 1. Lasso LARS com alpha fixo
print("\n1. LASSO LARS (ALPHA=0.1)")
start_time = time.time()
lasso_lars = LassoLars(alpha=0.1)
lasso_lars.fit(X_train, y_train)
lars_time = time.time() - start_time

y_pred_lars = lasso_lars.predict(X_test)
coef_nao_nulos_lars = np.sum(lasso_lars.coef_ != 0)

print(f"Tempo de execução: {lars_time:.4f} segundos")
print(f"Coeficientes não nulos: {coef_nao_nulos_lars}/50")
print(f"MSE: {mean_squared_error(y_test, y_pred_lars):.4f}")
print(f"R²: {r2_score(y_test, y_pred_lars):.4f}")

# 2. Lasso tradicional
print("\n2. LASSO TRADICIONAL (ALPHA=0.1)")
start_time = time.time()
lasso_trad = Lasso(alpha=0.1, max_iter=10000, random_state=42)
lasso_trad.fit(X_train, y_train)
lasso_time = time.time() - start_time

y_pred_trad = lasso_trad.predict(X_test)
coef_nao_nulos_trad = np.sum(lasso_trad.coef_ != 0)

print(f"Tempo de execução: {lasso_time:.4f} segundos")
print(f"Coeficientes não nulos: {coef_nao_nulos_trad}/50")
print(f"MSE: {mean_squared_error(y_test, y_pred_trad):.4f}")
print(f"R²: {r2_score(y_test, y_pred_trad):.4f}")

# 3. Lasso LARS com critério de informação
print("\n3. LASSO LARS COM CRITÉRIO AIC")
lasso_lars_aic = LassoLarsIC(criterion='aic')
lasso_lars_aic.fit(X_train, y_train)
y_pred_aic = lasso_lars_aic.predict(X_test)

print(f"Alpha selecionado (AIC): {lasso_lars_aic.alpha_:.6f}")
print(f"Coeficientes não nulos: {np.sum(lasso_lars_aic.coef_ != 0)}/50")
print(f"MSE: {mean_squared_error(y_test, y_pred_aic):.4f}")

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

# Gráfico 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
coeficientes = [lasso_lars.coef_, lasso_trad.coef_, lasso_lars_aic.coef_]
nomes = ['LassoLars', 'Lasso Trad', 'LassoLars AIC']
cores = ['blue', 'red', 'green']

for i, (coef, nome) in enumerate(zip(coeficientes, nomes)):
    plt.bar(np.arange(50) + i*0.25, coef, width=0.23, 
            label=nome, alpha=0.7, color=cores[i])

plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes - Cenário p > n')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 2: Caminho de regularização LassoLars
plt.subplot(2, 2, 2)
# Calcular caminho completo com alpha zero
lars_path = LassoLars(alpha=0)
lars_path.fit(X_train, y_train)

# Extrair alphas ao longo do caminho
alphas = lars_path.alphas_
coef_path = lars_path.coef_path_

# Plotar caminho para primeiras 15 features
for i in range(min(15, coef_path.shape[0])):
    plt.plot(alphas, coef_path[i], label=f'F{i+1}', linewidth=1.5)

plt.xlabel('Alpha')
plt.ylabel('Valor do Coeficiente')
plt.title('Caminho LassoLars - Evolução com Alpha')
plt.xscale('log')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)

# Gráfico 3: Comparação de esparsidade
plt.subplot(2, 2, 3)
features_nao_nulas = [np.sum(coef != 0) for coef in coeficientes]
plt.bar(nomes, features_nao_nulas, color=cores, alpha=0.7)
plt.ylabel('Número de Features Selecionadas')
plt.title('Comparação de Esparsidade')
for i, v in enumerate(features_nao_nulas):
    plt.text(i, v + 0.5, str(v), ha='center', va='bottom')
plt.grid(True, alpha=0.3)

# Gráfico 4: Comparação de performance
plt.subplot(2, 2, 4)
mse_valores = [
    mean_squared_error(y_test, y_pred_lars),
    mean_squared_error(y_test, y_pred_trad),
    mean_squared_error(y_test, y_pred_aic)
]
tempos = [lars_time, lasso_time, 0]  # AIC não tem tempo separado

x_pos = np.arange(len(nomes))
width = 0.35

plt.bar(x_pos - width/2, mse_valores, width, label='MSE', alpha=0.7, color='blue')
plt.bar(x_pos + width/2, tempos, width, label='Tempo (s)', alpha=0.7, color='orange')
plt.xlabel('Método')
plt.ylabel('MSE / Tempo (s)')
plt.title('Performance e Eficiência Computacional')
plt.xticks(x_pos, nomes)
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise de concordância na seleção de features
print("\n4. ANÁLISE DE CONCORDÂNCIA NA SELEÇÃO")
print("Feature | LassoLars | LassoTrad | Concordância")
print("-" * 50)
concordancia_total = 0
for i in range(50):
    selecionada_lars = lasso_lars.coef_[i] != 0
    selecionada_trad = lasso_trad.coef_[i] != 0
    concordancia = "SIM" if selecionada_lars == selecionada_trad else "NÃO"
    if selecionada_lars == selecionada_trad:
        concordancia_total += 1
    
    status_lars = "SEL" if selecionada_lars else "---"
    status_trad = "SEL" if selecionada_trad else "---"
    print(f"F{i+1:2d}     |    {status_lars}    |    {status_trad}    |     {concordancia}")

print(f"\nTaxa de concordância: {concordancia_total/50*100:.1f}%")

# Análise adicional do caminho LassoLars
print("\n5. INFORMAÇÕES DO CAMINHO LASSO LARS")
print(f"Número de iterações: {len(lars_path.alphas_)}")
print(f"Alpha máximo: {lars_path.alphas_[0]:.6f}")
print(f"Alpha mínimo: {lars_path.alphas_[-1]:.6f}")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LassoLars, Lasso, LassoLarsIC

from sklearn.datasets import make_regression

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.preprocessing import StandardScaler

import time

print("=" * 60)

print("COMPARAÇÃO: LASSO LARS VS LASSO TRADICIONAL")

print("=" * 60)

# Gerar dados com alta dimensionalidade (p > n scenario)

X, y = make_regression(n_samples=80, n_features=50, n_informative=10,

noise=0.3, random_state=42)

# Normalizar os dados

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

y_centered = y - np.mean(y)

# Dividir em treino e teste

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_centered,

test_size=0.3, random_state=42)

print(f"Cenário p > n: {X.shape[1]} features, {X.shape[0]} amostras")

print(f"Features informativas verdadeiras: 10")

# 1. Lasso LARS com alpha fixo

print("\n1. LASSO LARS (ALPHA=0.1)")

start_time = time.time()

lasso_lars = LassoLars(alpha=0.1)

lasso_lars.fit(X_train, y_train)

lars_time = time.time() - start_time

y_pred_lars = lasso_lars.predict(X_test)

coef_nao_nulos_lars = np.sum(lasso_lars.coef_ != 0)

print(f"Tempo de execução: {lars_time:.4f} segundos")

print(f"Coeficientes não nulos: {coef_nao_nulos_lars}/50")

print(f"MSE: {mean_squared_error(y_test, y_pred_lars):.4f}")

print(f"R²: {r2_score(y_test, y_pred_lars):.4f}")

# 2. Lasso tradicional

print("\n2. LASSO TRADICIONAL (ALPHA=0.1)")

start_time = time.time()

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

lasso_trad.fit(X_train, y_train)

lasso_time = time.time() - start_time

y_pred_trad = lasso_trad.predict(X_test)

coef_nao_nulos_trad = np.sum(lasso_trad.coef_ != 0)

print(f"Tempo de execução: {lasso_time:.4f} segundos")

print(f"Coeficientes não nulos: {coef_nao_nulos_trad}/50")

print(f"MSE: {mean_squared_error(y_test, y_pred_trad):.4f}")

print(f"R²: {r2_score(y_test, y_pred_trad):.4f}")

# 3. Lasso LARS com critério de informação

print("\n3. LASSO LARS COM CRITÉRIO AIC")

lasso_lars_aic = LassoLarsIC(criterion='aic')

lasso_lars_aic.fit(X_train, y_train)

y_pred_aic = lasso_lars_aic.predict(X_test)

print(f"Alpha selecionado (AIC): {lasso_lars_aic.alpha_:.6f}")

print(f"Coeficientes não nulos: {np.sum(lasso_lars_aic.coef_ != 0)}/50")

print(f"MSE: {mean_squared_error(y_test, y_pred_aic):.4f}")

# Visualização comparativa

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

# Gráfico 1: Comparação de coeficientes

plt.subplot(2, 2, 1)

coeficientes = [lasso_lars.coef_, lasso_trad.coef_, lasso_lars_aic.coef_]

nomes = ['LassoLars', 'Lasso Trad', 'LassoLars AIC']

cores = ['blue', 'red', 'green']

for i, (coef, nome) in enumerate(zip(coeficientes, nomes)):

plt.bar(np.arange(50) + i*0.25, coef, width=0.23,

label=nome, alpha=0.7, color=cores[i])

plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

plt.title('Comparação dos Coeficientes - Cenário p > n')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 2: Caminho de regularização LassoLars

plt.subplot(2, 2, 2)

# Calcular caminho completo com alpha zero

lars_path = LassoLars(alpha=0)

lars_path.fit(X_train, y_train)

# Extrair alphas ao longo do caminho

alphas = lars_path.alphas_

coef_path = lars_path.coef_path_

# Plotar caminho para primeiras 15 features

for i in range(min(15, coef_path.shape[0])):

plt.plot(alphas, coef_path[i], label=f'F{i+1}', linewidth=1.5)

plt.xlabel('Alpha')

plt.ylabel('Valor do Coeficiente')

plt.title('Caminho LassoLars - Evolução com Alpha')

plt.xscale('log')

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

plt.grid(True, alpha=0.3)

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

plt.subplot(2, 2, 3)

features_nao_nulas = [np.sum(coef != 0) for coef in coeficientes]

plt.bar(nomes, features_nao_nulas, color=cores, alpha=0.7)

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

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

for i, v in enumerate(features_nao_nulas):

plt.text(i, v + 0.5, str(v), ha='center', va='bottom')

plt.grid(True, alpha=0.3)

# Gráfico 4: Comparação de performance

plt.subplot(2, 2, 4)

mse_valores = [

mean_squared_error(y_test, y_pred_lars),

mean_squared_error(y_test, y_pred_trad),

mean_squared_error(y_test, y_pred_aic)

]

tempos = [lars_time, lasso_time, 0] # AIC não tem tempo separado

x_pos = np.arange(len(nomes))

width = 0.35

plt.bar(x_pos - width/2, mse_valores, width, label='MSE', alpha=0.7, color='blue')

plt.bar(x_pos + width/2, tempos, width, label='Tempo (s)', alpha=0.7, color='orange')

plt.xlabel('Método')

plt.ylabel('MSE / Tempo (s)')

plt.title('Performance e Eficiência Computacional')

plt.xticks(x_pos, nomes)

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise de concordância na seleção de features

print("\n4. ANÁLISE DE CONCORDÂNCIA NA SELEÇÃO")

print("Feature | LassoLars | LassoTrad | Concordância")

print("-" * 50)

concordancia_total = 0

for i in range(50):

selecionada_lars = lasso_lars.coef_[i] != 0

selecionada_trad = lasso_trad.coef_[i] != 0

concordancia = "SIM" if selecionada_lars == selecionada_trad else "NÃO"

if selecionada_lars == selecionada_trad:

concordancia_total += 1

status_lars = "SEL" if selecionada_lars else "---"

status_trad = "SEL" if selecionada_trad else "---"

print(f"F{i+1:2d} | {status_lars} | {status_trad} | {concordancia}")

print(f"\nTaxa de concordância: {concordancia_total/50*100:.1f}%")

# Análise adicional do caminho LassoLars

print("\n5. INFORMAÇÕES DO CAMINHO LASSO LARS")

print(f"Número de iterações: {len(lars_path.alphas_)}")

print(f"Alpha máximo: {lars_path.alphas_[0]:.6f}")

print(f"Alpha mínimo: {lars_path.alphas_[-1]:.6f}")

Considerações sobre Estabilidade Numérica

O Lasso LARS demonstra particular robustez em situações numericamente desafiadoras. Por utilizar decomposições matriciais estáveis e evitar problemas de convergência associados a métodos iterativos, frequentemente produz resultados mais confiáveis em problemas mal condicionados.

Limitações e Considerações

Embora poderoso, o Lasso LARS apresenta algumas limitações:

Pode ser menos eficiente quando número de amostras é muito grande
Implementação atual não suporta sparse matrices de forma nativa
Menos flexível para personalização em comparação com abordagens baseadas em otimização

Considerações Finais

Inegavelmente, o Lasso LARS representa uma fusão elegante entre a intuitividade geométrica do LARS e o poder de seleção de features do Lasso. Sua capacidade de computar eficientemente todo o caminho de regularização o torna invaluable para análise exploratória e seleção de modelos.

Decerto, em cenários de alta dimensionalidade (p > n), o Lasso LARS frequentemente supera implementações tradicionais do Lasso tanto em termos de eficiência computacional quanto de estabilidade numérica. Ademais, fornece insights valiosos sobre a ordem de importância das features através do exame do caminho de regularização.

Analogamente a outras técnicas de regularização, a escolha do parâmetro alpha permanece crucial. Portanto, a combinação do Lasso LARS com métodos de validação cruzada ou critérios de informação constitui uma abordagem robusta para problemas práticos de machine learning.