Arquivo de Aprendizado de Máquina - Página 8 de 12

Regressão Polinomial: Estendendo Modelos Lineares com Funções de Base

19/12/202518/10/2025 Por antonino

Continuando nossa análise do guia do scikit-learn, chegamos a um conceito fundamental para expandir a flexibilidade dos modelos lineares: a regressão polinomial. Primordialmente, esta técnica permite capturar relações não-lineares entre variáveis enquanto mantém a estrutura linear do modelo.

O Conceito Fundamental

Conforme observamos anteriormente com os modelos de regressão linear, frequentemente nos deparamos com situações onde a relação entre as variáveis não é estritamente linear. Analogamente, a regressão polinomial surge como uma extensão natural que preserva a linearidade nos parâmetros, mas introduz não-linearidade nas features.

Base Matemática

Enquanto um modelo linear simples segue a forma:

\(y = \beta_0 + \beta_1x + \epsilon\)

A regressão polinomial de grau d expande esta representação para:

\(y = \beta_0 + \beta_1x + \beta_2x^2 + \beta_3x^3 + \cdots + \beta_dx^d + \epsilon\)

Implementação no scikit-learn

No scikit-learn, a regressão polinomial é implementada através de dois componentes principais:

PolynomialFeatures: Transforma features originais em features polinomiais
Um estimador linear (como LinearRegression, Ridge, ou Lasso)

PolynomialFeatures

Esta classe gera novas features criando todas as combinações polinomiais até o grau especificado. Por exemplo, para duas features [a, b] e grau 2, obtemos:

[1, a, b, a², ab, b²]

Inegavelmente, esta abordagem mantém a linearidade nos parâmetros enquanto expande significativamente a capacidade de representação do modelo.

Vantagens e Considerações

Benefícios Principais

Capacidade de capturar relações não-lineares complexas
Mantém as propriedades de estimação dos modelos lineares
Interpretabilidade relativa dos coeficientes
Computacionalmente eficiente comparado a outros métodos não-lineares

Desafios e Cuidados

Embora poderosa, a regressão polinomial requer atenção a alguns aspectos:

Risco de overfitting com graus muito altos
Problemas de condicionamento numérico
Crescimento combinatório do número de features
Necessidade de regularização em muitos casos

Escolha do Grau Polinomial

A seleção do grau apropriado é crucial. Certamente, graus muito baixos podem underfitting, enquanto graus muito altos levam a overfitting. Estratégias comuns incluem:

Validação cruzada para seleção do grau ótimo
Análise de curvas de aprendizado
Uso de regularização (Ridge, Lasso) para controlar complexidade

Exemplo Prático em Python

Para ilustrar a aplicação da regressão polinomial, vejamos um exemplo completo:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

'''
Demonstração de regressão polinomial com diferentes graus
e comparação entre modelos regularizados e não-regularizados
'''

# Gerando dados com relação não-linear verdadeira
np.random.seed(42)
n_samples = 100
X = np.random.uniform(-3, 3, n_samples).reshape(-1, 1)
y_true = np.sin(X.ravel()) + 0.1 * X.ravel()**2
y = y_true + 0.2 * np.random.randn(n_samples)  # Adicionando ruído

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

'''
Configurando pipelines para diferentes graus polinomiais
e tipos de regularização
'''
degrees = [1, 3, 5, 10]
models = {}

for degree in degrees:
    # Modelo sem regularização
    poly_reg = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('linear', LinearRegression())
    ])
    
    # Modelo com regularização Ridge
    poly_ridge = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('ridge', Ridge(alpha=1.0))
    ])
    
    # Treinando os modelos
    poly_reg.fit(X_train, y_train)
    poly_ridge.fit(X_train, y_train)
    
    # Fazendo previsões
    y_pred_reg = poly_reg.predict(X_test)
    y_pred_ridge = poly_ridge.predict(X_test)
    
    # Calculando métricas
    mse_reg = mean_squared_error(y_test, y_pred_reg)
    mse_ridge = mean_squared_error(y_test, y_pred_ridge)
    
    models[degree] = {
        'linear': {'model': poly_reg, 'mse': mse_reg, 'predictions': y_pred_reg},
        'ridge': {'model': poly_ridge, 'mse': mse_ridge, 'predictions': y_pred_ridge}
    }

'''
Visualizando os resultados para diferentes graus
'''
plt.figure(figsize=(15, 10))

# Ordenando pontos para visualização suave
X_plot = np.linspace(-3, 3, 300).reshape(-1, 1)
y_plot_true = np.sin(X_plot.ravel()) + 0.1 * X_plot.ravel()**2

for i, degree in enumerate(degrees, 1):
    plt.subplot(2, 2, i)
    
    # Pontos de treino
    plt.scatter(X_train, y_train, alpha=0.6, label='Dados treino', color='blue')
    plt.scatter(X_test, y_test, alpha=0.6, label='Dados teste', color='green')
    
    # Curva verdadeira
    plt.plot(X_plot, y_plot_true, 'k-', linewidth=2, label='Relação verdadeira')
    
    # Previsões dos modelos
    y_plot_reg = models[degree]['linear']['model'].predict(X_plot)
    y_plot_ridge = models[degree]['ridge']['model'].predict(X_plot)
    
    plt.plot(X_plot, y_plot_reg, 'r-', linewidth=2, 
             label=f'Poly (MSE: {models[degree]["linear"]["mse"]:.3f})')
    plt.plot(X_plot, y_plot_ridge, 'g--', linewidth=2, 
             label=f'Poly+Ridge (MSE: {models[degree]["ridge"]["mse"]:.3f})')
    
    plt.title(f'Grau {degree}')
    plt.legend()
    plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

'''
Análise dos coeficientes para entender o efeito da regularização
'''
print("Análise dos coeficientes para grau 5:")
degree_5_model = models[5]['linear']['model']
degree_5_ridge = models[5]['ridge']['model']

coef_linear = degree_5_model.named_steps['linear'].coef_
coef_ridge = degree_5_ridge.named_steps['ridge'].coef_

print(f"Número de coeficientes: {len(coef_linear)}")
print(f"Norma L2 dos coeficientes (Linear): {np.linalg.norm(coef_linear):.4f}")
print(f"Norma L2 dos coeficientes (Ridge): {np.linalg.norm(coef_ridge):.4f}")

100

101

102

103

104

105

106

107

108

import numpy as np

import matplotlib.pyplot as plt

from sklearn.preprocessing import PolynomialFeatures

from sklearn.linear_model import LinearRegression, Ridge

from sklearn.pipeline import Pipeline

from sklearn.metrics import mean_squared_error

from sklearn.model_selection import train_test_split

'''

Demonstração de regressão polinomial com diferentes graus

e comparação entre modelos regularizados e não-regularizados

'''

# Gerando dados com relação não-linear verdadeira

np.random.seed(42)

n_samples = 100

X = np.random.uniform(-3, 3, n_samples).reshape(-1, 1)

y_true = np.sin(X.ravel()) + 0.1 * X.ravel()**2

y = y_true + 0.2 * np.random.randn(n_samples) # Adicionando ruído

# Dividindo em treino e teste

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

'''

Configurando pipelines para diferentes graus polinomiais

e tipos de regularização

'''

degrees = [1, 3, 5, 10]

models = {}

for degree in degrees:

# Modelo sem regularização

poly_reg = Pipeline([

('poly', PolynomialFeatures(degree=degree)),

('linear', LinearRegression())

])

# Modelo com regularização Ridge

poly_ridge = Pipeline([

('poly', PolynomialFeatures(degree=degree)),

('ridge', Ridge(alpha=1.0))

])

# Treinando os modelos

poly_reg.fit(X_train, y_train)

poly_ridge.fit(X_train, y_train)

# Fazendo previsões

y_pred_reg = poly_reg.predict(X_test)

y_pred_ridge = poly_ridge.predict(X_test)

# Calculando métricas

mse_reg = mean_squared_error(y_test, y_pred_reg)

mse_ridge = mean_squared_error(y_test, y_pred_ridge)

models[degree] = {

'linear': {'model': poly_reg, 'mse': mse_reg, 'predictions': y_pred_reg},

'ridge': {'model': poly_ridge, 'mse': mse_ridge, 'predictions': y_pred_ridge}

}

'''

Visualizando os resultados para diferentes graus

'''

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

# Ordenando pontos para visualização suave

X_plot = np.linspace(-3, 3, 300).reshape(-1, 1)

y_plot_true = np.sin(X_plot.ravel()) + 0.1 * X_plot.ravel()**2

for i, degree in enumerate(degrees, 1):

plt.subplot(2, 2, i)

# Pontos de treino

plt.scatter(X_train, y_train, alpha=0.6, label='Dados treino', color='blue')

plt.scatter(X_test, y_test, alpha=0.6, label='Dados teste', color='green')

# Curva verdadeira

plt.plot(X_plot, y_plot_true, 'k-', linewidth=2, label='Relação verdadeira')

# Previsões dos modelos

y_plot_reg = models[degree]['linear']['model'].predict(X_plot)

y_plot_ridge = models[degree]['ridge']['model'].predict(X_plot)

plt.plot(X_plot, y_plot_reg, 'r-', linewidth=2,

label=f'Poly (MSE: {models[degree]["linear"]["mse"]:.3f})')

plt.plot(X_plot, y_plot_ridge, 'g--', linewidth=2,

label=f'Poly+Ridge (MSE: {models[degree]["ridge"]["mse"]:.3f})')

plt.title(f'Grau {degree}')

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

'''

Análise dos coeficientes para entender o efeito da regularização

'''

print("Análise dos coeficientes para grau 5:")

degree_5_model = models[5]['linear']['model']

degree_5_ridge = models[5]['ridge']['model']

coef_linear = degree_5_model.named_steps['linear'].coef_

coef_ridge = degree_5_ridge.named_steps['ridge'].coef_

print(f"Número de coeficientes: {len(coef_linear)}")

print(f"Norma L2 dos coeficientes (Linear): {np.linalg.norm(coef_linear):.4f}")

print(f"Norma L2 dos coeficientes (Ridge): {np.linalg.norm(coef_ridge):.4f}")

Interpretação dos Resultados

Analisando o exemplo, podemos observar que:

Graus muito baixos (1) mostram underfitting evidente
Graus intermediários (3-5) capturam bem a relação não-linear
Graus muito altos (10) podem mostrar overfitting, especialmente sem regularização
A regularização Ridge ajuda a suavizar as previsões e melhorar generalização

Considerações Finais

A regressão polinomial representa uma ponte elegante entre modelos lineares simples e abordagens não-lineares complexas. Embora expanda significativamente a capacidade de modelagem, requer cuidado na seleção do grau polinomial e, frequentemente, beneficia-se de técnicas de regularização.

Portanto, ao aplicar esta técnica na prática, recomenda-se sempre usar validação cruzada para seleção de hiperparâmetros e considerar a combinação com métodos de regularização para obter modelos robustos e generalizáveis.

Regressão Logística: Fundamentos e Aplicações em Classificação

19/12/202517/10/2025 Por antonino

Analogamente a um sistema de decisão que calcula probabilidades, a Regressão Logística constitui um dos algoritmos mais populares para problemas de classificação. Ademais, conforme documentado no scikit-learn, esta técnica modela a probabilidade de pertencimento a classes através de uma função logística.

Fundamentação Matemática da Regressão Logística

Primordialmente, a Regressão Logística utiliza a função sigmoide para transformar saídas lineares em probabilidades. Certamente, a função sigmoide é definida como:

\(\sigma(z) = \frac{1}{1 + e^{-z}}\)

Onde \(z = w^T x + b\) representa a combinação linear das features. Similarmente a um limiar de decisão, valores acima de 0.5 indicam uma classe, enquanto valores abaixo indicam a outra.

Função de Custo e Otimização

A Regressão Logística minimiza a entropia cruzada (cross-entropy), que mede a dissimilaridade entre distribuições de probabilidade:

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

Esta função é convexa, garantindo convergência para um mínimo global através de algoritmos como gradient descent.

Tipos de Regressão Logística no Scikit-Learn

Classificação Binária

Para problemas com duas classes, o scikit-learn oferece LogisticRegression com parâmetro multi_class=’ovr’. Decerto, esta abordagem é adequada para a maioria dos problemas de classificação binária.

Classificação Multiclasse

Para problemas com múltiplas classes, duas estratégias estão disponíveis:

One-vs-Rest (OvR): Treina um classificador binário para cada classe
Multinomial: Treina um único classificador para todas as classes

Regularização

Embora seja um classificador, a Regressão Logística suporta regularização L1 e L2 para prevenir overfitting. Contudo, a escolha do parâmetro C (inverso da força de regularização) é crucial para o desempenho.

Exemplo Prático: Classificação Binária e Multiclasse

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

print("=" * 60)
print("REGRESSÃO LOGÍSTICA - CLASSIFICAÇÃO BINÁRIA E MULTICLASSE")
print("=" * 60)

# 1. CLASSIFICAÇÃO BINÁRIA
print("\n" + "=" * 50)
print("1. CLASSIFICAÇÃO BINÁRIA")
print("=" * 50)

# Gerar dados para classificação binária
X_bin, y_bin = make_classification(
    n_samples=1000,
    n_features=2,
    n_redundant=0,
    n_informative=2,
    n_clusters_per_class=1,
    random_state=42
)

print(f"Dados binários: {X_bin.shape[0]} amostras, {X_bin.shape[1]} features")
print(f"Distribuição das classes: {np.unique(y_bin, return_counts=True)}")

# Dividir e normalizar dados
X_bin_train, X_bin_test, y_bin_train, y_bin_test = train_test_split(
    X_bin, y_bin, test_size=0.3, random_state=42
)

scaler_bin = StandardScaler()
X_bin_train_scaled = scaler_bin.fit_transform(X_bin_train)
X_bin_test_scaled = scaler_bin.transform(X_bin_test)

# Treinar modelo de regressão logística binária
log_reg_bin = LogisticRegression(
    penalty='l2',           # Regularização L2
    C=1.0,                  # Inverso da força de regularização
    solver='lbfgs',         # Algoritmo de otimização
    max_iter=1000,
    random_state=42
)

log_reg_bin.fit(X_bin_train_scaled, y_bin_train)

# Previsões e métricas
y_bin_pred = log_reg_bin.predict(X_bin_test_scaled)
y_bin_prob = log_reg_bin.predict_proba(X_bin_test_scaled)

accuracy_bin = accuracy_score(y_bin_test, y_bin_pred)

print(f"\nAcurácia (binária): {accuracy_bin:.4f}")
print(f"Coeficientes: {log_reg_bin.coef_}")
print(f"Intercepto: {log_reg_bin.intercept_}")

# 2. CLASSIFICAÇÃO MULTICLASSE
print("\n" + "=" * 50)
print("2. CLASSIFICAÇÃO MULTICLASSE")
print("=" * 50)

# Gerar dados para classificação multiclasse
X_multi, y_multi = make_blobs(
    n_samples=1500,
    centers=3,
    n_features=2,
    cluster_std=1.5,
    random_state=42
)

print(f"Dados multiclasse: {X_multi.shape[0]} amostras, {X_multi.shape[1]} features")
print(f"Número de classes: {len(np.unique(y_multi))}")
print(f"Distribuição das classes: {np.unique(y_multi, return_counts=True)}")

# Dividir e normalizar dados
X_multi_train, X_multi_test, y_multi_train, y_multi_test = train_test_split(
    X_multi, y_multi, test_size=0.3, random_state=42
)

scaler_multi = StandardScaler()
X_multi_train_scaled = scaler_multi.fit_transform(X_multi_train)
X_multi_test_scaled = scaler_multi.transform(X_multi_test)

# Treinar modelo de regressão logística multiclasse
log_reg_multi = LogisticRegression(
    penalty='l2',
    C=1.0,
    solver='lbfgs',
    multi_class='multinomial',  # Classificação multinomial
    max_iter=1000,
    random_state=42
)

log_reg_multi.fit(X_multi_train_scaled, y_multi_train)

# Previsões e métricas
y_multi_pred = log_reg_multi.predict(X_multi_test_scaled)
y_multi_prob = log_reg_multi.predict_proba(X_multi_test_scaled)

accuracy_multi = accuracy_score(y_multi_test, y_multi_pred)

print(f"\nAcurácia (multiclasse): {accuracy_multi:.4f}")
print(f"Coeficientes shape: {log_reg_multi.coef_.shape}")
print(f"Intercepto shape: {log_reg_multi.intercept_.shape}")

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

# Gráfico 1: Classificação Binária - Dados e Fronteira de Decisão
plt.subplot(2, 3, 1)
plt.scatter(X_bin_train_scaled[:, 0], X_bin_train_scaled[:, 1], c=y_bin_train, 
            cmap='bwr', alpha=0.6, edgecolors='k')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Dados de Treino - Classificação Binária')
plt.colorbar()

# Gráfico 2: Classificação Binária - Fronteira de Decisão
plt.subplot(2, 3, 2)
xx, yy = np.meshgrid(
    np.linspace(X_bin_train_scaled[:, 0].min(), X_bin_train_scaled[:, 0].max(), 100),
    np.linspace(X_bin_train_scaled[:, 1].min(), X_bin_train_scaled[:, 1].max(), 100)
)
Z = log_reg_bin.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap='bwr')
plt.scatter(X_bin_test_scaled[:, 0], X_bin_test_scaled[:, 1], c=y_bin_test, 
            cmap='bwr', alpha=0.8, edgecolors='k')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Fronteira de Decisão - Classificação Binária')

# Gráfico 3: Probabilidades - Classificação Binária
plt.subplot(2, 3, 3)
plt.scatter(X_bin_test_scaled[:, 0], y_bin_prob[:, 1], c=y_bin_test, cmap='bwr')
plt.xlabel('Feature 1')
plt.ylabel('Probabilidade Classe 1')
plt.title('Probabilidades Previstas - Binária')
plt.colorbar()

# Gráfico 4: Classificação Multiclasse - Dados
plt.subplot(2, 3, 4)
plt.scatter(X_multi_train_scaled[:, 0], X_multi_train_scaled[:, 1], c=y_multi_train, 
            cmap='viridis', alpha=0.6, edgecolors='k')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Dados de Treino - Multiclasse')
plt.colorbar()

# Gráfico 5: Classificação Multiclasse - Fronteiras de Decisão
plt.subplot(2, 3, 5)
xx, yy = np.meshgrid(
    np.linspace(X_multi_train_scaled[:, 0].min(), X_multi_train_scaled[:, 0].max(), 100),
    np.linspace(X_multi_train_scaled[:, 1].min(), X_multi_train_scaled[:, 1].max(), 100)
)
Z = log_reg_multi.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')
plt.scatter(X_multi_test_scaled[:, 0], X_multi_test_scaled[:, 1], c=y_multi_test, 
            cmap='viridis', alpha=0.8, edgecolors='k')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Fronteiras de Decisão - Multiclasse')

# Gráfico 6: Probabilidades - Classificação Multiclasse
plt.subplot(2, 3, 6)
prob_max = np.max(y_multi_prob, axis=1)
plt.scatter(X_multi_test_scaled[:, 0], prob_max, c=y_multi_test, cmap='viridis')
plt.xlabel('Feature 1')
plt.ylabel('Probabilidade Máxima')
plt.title('Confiança das Previsões - Multiclasse')
plt.colorbar()

plt.tight_layout()
plt.show()

# 💡 ANÁLISE DETALHADA DOS RESULTADOS
print("\n" + "=" * 50)
print("ANÁLISE DETALHADA DOS MODELOS")
print("=" * 50)

# Relatório de classificação para binária
print("\nRELATÓRIO DE CLASSIFICAÇÃO - BINÁRIA:")
print(classification_report(y_bin_test, y_bin_pred))

# Relatório de classificação para multiclasse
print("\nRELATÓRIO DE CLASSIFICAÇÃO - MULTICLASSE:")
print(classification_report(y_multi_test, y_multi_pred))

# Matriz de confusão para multiclasse
print("\nMATRIZ DE CONFUSÃO - MULTICLASSE:")
print(confusion_matrix(y_multi_test, y_multi_pred))

# Análise dos coeficientes
print(f"\nANÁLISE DOS COEFICIENTES - MULTICLASSE:")
for i, coef_class in enumerate(log_reg_multi.coef_):
    print(f"Classe {i}: coef = [{coef_class[0]:.3f}, {coef_class[1]:.3f}]")

# Comparação de estratégias multiclasse
print(f"\nCOMPARAÇÃO DE ESTRATÉGIAS MULTICLASSE:")
strategies = ['ovr', 'multinomial']
accuracies = []

for strategy in strategies:
    log_reg_strategy = LogisticRegression(
        penalty='l2',
        C=1.0,
        solver='lbfgs',
        multi_class=strategy,
        max_iter=1000,
        random_state=42
    )
    log_reg_strategy.fit(X_multi_train_scaled, y_multi_train)
    y_pred_strategy = log_reg_strategy.predict(X_multi_test_scaled)
    acc = accuracy_score(y_multi_test, y_pred_strategy)
    accuracies.append(acc)
    print(f"Estratégia {strategy}: Acurácia = {acc:.4f}")

print(f"\nRECOMENDAÇÕES PRÁTICAS:")
print("1. Para problemas binários: multi_class='ovr'")
print("2. Para problemas multiclasse: testar 'ovr' vs 'multinomial'")
print("3. Normalizar features para melhor performance")
print("4. Ajustar parâmetro C para controlar regularização")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LogisticRegression

from sklearn.datasets import make_classification, make_blobs

from sklearn.model_selection import train_test_split

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

from sklearn.preprocessing import StandardScaler

print("=" * 60)

print("REGRESSÃO LOGÍSTICA - CLASSIFICAÇÃO BINÁRIA E MULTICLASSE")

print("=" * 60)

# 1. CLASSIFICAÇÃO BINÁRIA

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

print("1. CLASSIFICAÇÃO BINÁRIA")

print("=" * 50)

# Gerar dados para classificação binária

X_bin, y_bin = make_classification(

n_samples=1000,

n_features=2,

n_redundant=0,

n_informative=2,

n_clusters_per_class=1,

random_state=42

)

print(f"Dados binários: {X_bin.shape[0]} amostras, {X_bin.shape[1]} features")

print(f"Distribuição das classes: {np.unique(y_bin, return_counts=True)}")

# Dividir e normalizar dados

X_bin_train, X_bin_test, y_bin_train, y_bin_test = train_test_split(

X_bin, y_bin, test_size=0.3, random_state=42

)

scaler_bin = StandardScaler()

X_bin_train_scaled = scaler_bin.fit_transform(X_bin_train)

X_bin_test_scaled = scaler_bin.transform(X_bin_test)

# Treinar modelo de regressão logística binária

log_reg_bin = LogisticRegression(

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

C=1.0, # Inverso da força de regularização

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

max_iter=1000,

random_state=42

)

log_reg_bin.fit(X_bin_train_scaled, y_bin_train)

# Previsões e métricas

y_bin_pred = log_reg_bin.predict(X_bin_test_scaled)

y_bin_prob = log_reg_bin.predict_proba(X_bin_test_scaled)

accuracy_bin = accuracy_score(y_bin_test, y_bin_pred)

print(f"\nAcurácia (binária): {accuracy_bin:.4f}")

print(f"Coeficientes: {log_reg_bin.coef_}")

print(f"Intercepto: {log_reg_bin.intercept_}")

# 2. CLASSIFICAÇÃO MULTICLASSE

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

print("2. CLASSIFICAÇÃO MULTICLASSE")

print("=" * 50)

# Gerar dados para classificação multiclasse

X_multi, y_multi = make_blobs(

n_samples=1500,

centers=3,

n_features=2,

cluster_std=1.5,

random_state=42

)

print(f"Dados multiclasse: {X_multi.shape[0]} amostras, {X_multi.shape[1]} features")

print(f"Número de classes: {len(np.unique(y_multi))}")

print(f"Distribuição das classes: {np.unique(y_multi, return_counts=True)}")

# Dividir e normalizar dados

X_multi_train, X_multi_test, y_multi_train, y_multi_test = train_test_split(

X_multi, y_multi, test_size=0.3, random_state=42

)

scaler_multi = StandardScaler()

X_multi_train_scaled = scaler_multi.fit_transform(X_multi_train)

X_multi_test_scaled = scaler_multi.transform(X_multi_test)

# Treinar modelo de regressão logística multiclasse

log_reg_multi = LogisticRegression(

penalty='l2',

C=1.0,

solver='lbfgs',

multi_class='multinomial', # Classificação multinomial

max_iter=1000,

random_state=42

)

log_reg_multi.fit(X_multi_train_scaled, y_multi_train)

# Previsões e métricas

y_multi_pred = log_reg_multi.predict(X_multi_test_scaled)

y_multi_prob = log_reg_multi.predict_proba(X_multi_test_scaled)

accuracy_multi = accuracy_score(y_multi_test, y_multi_pred)

print(f"\nAcurácia (multiclasse): {accuracy_multi:.4f}")

print(f"Coeficientes shape: {log_reg_multi.coef_.shape}")

print(f"Intercepto shape: {log_reg_multi.intercept_.shape}")

# Visualização dos resultados

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

# Gráfico 1: Classificação Binária - Dados e Fronteira de Decisão

plt.subplot(2, 3, 1)

plt.scatter(X_bin_train_scaled[:, 0], X_bin_train_scaled[:, 1], c=y_bin_train,

cmap='bwr', alpha=0.6, edgecolors='k')

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title('Dados de Treino - Classificação Binária')

plt.colorbar()

# Gráfico 2: Classificação Binária - Fronteira de Decisão

plt.subplot(2, 3, 2)

xx, yy = np.meshgrid(

np.linspace(X_bin_train_scaled[:, 0].min(), X_bin_train_scaled[:, 0].max(), 100),

np.linspace(X_bin_train_scaled[:, 1].min(), X_bin_train_scaled[:, 1].max(), 100)

)

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

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap='bwr')

plt.scatter(X_bin_test_scaled[:, 0], X_bin_test_scaled[:, 1], c=y_bin_test,

cmap='bwr', alpha=0.8, edgecolors='k')

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title('Fronteira de Decisão - Classificação Binária')

# Gráfico 3: Probabilidades - Classificação Binária

plt.subplot(2, 3, 3)

plt.scatter(X_bin_test_scaled[:, 0], y_bin_prob[:, 1], c=y_bin_test, cmap='bwr')

plt.xlabel('Feature 1')

plt.ylabel('Probabilidade Classe 1')

plt.title('Probabilidades Previstas - Binária')

plt.colorbar()

# Gráfico 4: Classificação Multiclasse - Dados

plt.subplot(2, 3, 4)

plt.scatter(X_multi_train_scaled[:, 0], X_multi_train_scaled[:, 1], c=y_multi_train,

cmap='viridis', alpha=0.6, edgecolors='k')

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title('Dados de Treino - Multiclasse')

plt.colorbar()

# Gráfico 5: Classificação Multiclasse - Fronteiras de Decisão

plt.subplot(2, 3, 5)

xx, yy = np.meshgrid(

np.linspace(X_multi_train_scaled[:, 0].min(), X_multi_train_scaled[:, 0].max(), 100),

np.linspace(X_multi_train_scaled[:, 1].min(), X_multi_train_scaled[:, 1].max(), 100)

)

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

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')

plt.scatter(X_multi_test_scaled[:, 0], X_multi_test_scaled[:, 1], c=y_multi_test,

cmap='viridis', alpha=0.8, edgecolors='k')

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title('Fronteiras de Decisão - Multiclasse')

# Gráfico 6: Probabilidades - Classificação Multiclasse

plt.subplot(2, 3, 6)

prob_max = np.max(y_multi_prob, axis=1)

plt.scatter(X_multi_test_scaled[:, 0], prob_max, c=y_multi_test, cmap='viridis')

plt.xlabel('Feature 1')

plt.ylabel('Probabilidade Máxima')

plt.title('Confiança das Previsões - Multiclasse')

plt.colorbar()

plt.tight_layout()

plt.show()

# 💡 ANÁLISE DETALHADA DOS RESULTADOS

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

print("ANÁLISE DETALHADA DOS MODELOS")

print("=" * 50)

# Relatório de classificação para binária

print("\nRELATÓRIO DE CLASSIFICAÇÃO - BINÁRIA:")

print(classification_report(y_bin_test, y_bin_pred))

# Relatório de classificação para multiclasse

print("\nRELATÓRIO DE CLASSIFICAÇÃO - MULTICLASSE:")

print(classification_report(y_multi_test, y_multi_pred))

# Matriz de confusão para multiclasse

print("\nMATRIZ DE CONFUSÃO - MULTICLASSE:")

print(confusion_matrix(y_multi_test, y_multi_pred))

# Análise dos coeficientes

print(f"\nANÁLISE DOS COEFICIENTES - MULTICLASSE:")

for i, coef_class in enumerate(log_reg_multi.coef_):

print(f"Classe {i}: coef = [{coef_class[0]:.3f}, {coef_class[1]:.3f}]")

# Comparação de estratégias multiclasse

print(f"\nCOMPARAÇÃO DE ESTRATÉGIAS MULTICLASSE:")

strategies = ['ovr', 'multinomial']

accuracies = []

for strategy in strategies:

log_reg_strategy = LogisticRegression(

penalty='l2',

C=1.0,

solver='lbfgs',

multi_class=strategy,

max_iter=1000,

random_state=42

)

log_reg_strategy.fit(X_multi_train_scaled, y_multi_train)

y_pred_strategy = log_reg_strategy.predict(X_multi_test_scaled)

acc = accuracy_score(y_multi_test, y_pred_strategy)

accuracies.append(acc)

print(f"Estratégia {strategy}: Acurácia = {acc:.4f}")

print(f"\nRECOMENDAÇÕES PRÁTICAS:")

print("1. Para problemas binários: multi_class='ovr'")

print("2. Para problemas multiclasse: testar 'ovr' vs 'multinomial'")

print("3. Normalizar features para melhor performance")

print("4. Ajustar parâmetro C para controlar regularização")

Interpretação dos Resultados

Inegavelmente, a Regressão Logística demonstra excelente performance tanto em problemas binários quanto multiclasse. Afinal, as fronteiras de decisão lineares são claramente visíveis nos gráficos, mostrando a capacidade do modelo em separar classes de forma eficaz.

Vantagens da Regressão Logística

Interpretabilidade: Coeficientes indicam a importância das features
Probabilidades: Fornece probabilidades de pertencimento às classes
Eficiência: Computacionalmente eficiente mesmo com muitas features
Versatilidade: Aplicável a problemas binários e multiclasse

Considerações Práticas

Embora seja um algoritmo robusto, a Regressão Logística assume linearidade entre features e o logito. Ocasionalmente, em problemas com relações não-lineares complexas, outros algoritmos como Random Forest ou SVM podem performar melhor.

Contudo, para a maioria dos problemas de classificação onde a interpretabilidade é importante, a Regressão Logística permanece como uma excelente escolha inicial.

Conclusão

Portanto, a Regressão Logística representa uma ferramenta fundamental no arsenal do cientista de dados. Analogamente a um diagnóstico médico baseado em probabilidades, este algoritmo combina poder preditivo com interpretabilidade.

Enfim, o domínio da Regressão Logística e suas variações permite abordar uma ampla gama de problemas de classificação, desde diagnósticos médicos até sistemas de recomendação, sempre com a capacidade de explicar as decisões do modelo.