Regressão Logística em Machine Learning: Guia Completo

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

class RegressaoLogistica:
  def __init__(self, lr=0.1, n_iters=1000, lambda_reg=0.01):
    self.lr = lr
    self.n_iters = n_iters
    self.lambda_reg = lambda_reg # Parâmetro de Regularização L2
    self.weights = None
    self.bias = None
    self.loss_history = []

  def _sigmoid(self, z):
    return 1 / (1 + np.exp(-z))

  def fit(self, X, y):
    n_samples, n_features = X.shape
    self.weights = np.zeros(n_features)
    self.bias = 0

    for _ in range(self.n_iters):
      # Modelo Linear + Sigmóide
      model = np.dot(X, self.weights) + self.bias
      y_pred = self._sigmoid(model)

      # Cálculo da Log Loss (com regularização L2)
      loss = -np.mean(y * np.log(y_pred + 1e-15) + (1 - y) * np.log(1 - y_pred + 1e-15))
      loss += (self.lambda_reg / (2 * n_samples)) * np.sum(self.weights**2)
      self.loss_history.append(loss)

      # Gradientes (Derivadas da Log Loss + L2)
      dw = (1 / n_samples) * np.dot(X.T, (y_pred - y)) + (self.lambda_reg / n_samples) * self.weights
      db = (1 / n_samples) * np.sum(y_pred - y)

      # Atualização dos parâmetros
      self.weights -= self.lr * dw
      self.bias -= self.lr * db

  def predict_proba(self, X):
    return self._sigmoid(np.dot(X, self.weights) + self.bias)

  def predict(self, X, threshold=0.5):
    return [1 if i > threshold else 0 for i in self.predict_proba(X)]

# Exemplo de uso
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [1, 1], [5, 5]])
y = np.array([0, 0, 1, 1, 0, 1])

modelo = RegressaoLogistica(lr=0.1, n_iters=1000)
modelo.fit(X, y)

print(f"Pesos Finais: {modelo.weights}")
print(f"Probabilidades: {modelo.predict_proba(X)}")

# Configuração estética
sns.set_theme(style="whitegrid")
plt.figure(figsize=(10, 5))

# Plotando a história da Loss
plt.plot(modelo.loss_history, color='#2c3e50', linewidth=2.5, label='Log Loss (Custo)')

# Estética do gráfico
plt.title("Curva de Aprendizado: Minimização da Log Loss", fontsize=14, pad=15)
plt.xlabel("Iterações (Épocas)", fontsize=12)
plt.ylabel("Custo (Erro)", fontsize=12)
plt.fill_between(range(len(modelo.loss_history)), modelo.loss_history, color='#34495e', alpha=0.1)
plt.legend()
plt.show()

def plot_decision_boundary(X, y, model):
  # Criando uma malha (grid) para pintar o fundo
  h = .02  # tamanho do passo no mesh
  x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
  y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
  xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

  # Prevendo probabilidades para cada ponto do grid
  Z = np.array(model.predict(np.c_[xx.ravel(), yy.ravel()]))
  Z = Z.reshape(xx.shape)

  plt.figure(figsize=(10, 6))
    
  # Pintando a região de decisão
  plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlGn, alpha=0.3)
    
  # Plotando os pontos reais
  scatter = plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', s=100, cmap=plt.cm.RdYlGn, label="Dados Reais")
    
  # Linha da fronteira (onde prob = 0.5)
  # Equação: w1*x1 + w2*x2 + b = 0  => x2 = -(w1*x1 + b) / w2
  x1_line = np.array([x_min, x_max])
  x2_line = -(model.weights[0] * x1_line + model.bias) / model.weights[1]
  plt.plot(x1_line, x2_line, ls="--", color="black", label="Fronteira de Decisão (P=0.5)")

  plt.title("Fronteira de Decisão Linear", fontsize=14)
  plt.xlabel("Atributo 1 (ex: Idade)", fontsize=12)
  plt.ylabel("Atributo 2 (ex: Colesterol)", fontsize=12)
  plt.legend()
  plt.grid(alpha=0.3)
  plt.show()

# Chamada da função
plot_decision_boundary(X, y, modelo)