#!/usr/bin/env python3
# Source: q4-ml-coding.html
import numpy as np


def sigmoid(z: np.ndarray) -> np.ndarray:
    """Stable sigmoid. Never calls exp on a large positive number."""
    out = np.empty_like(z, dtype=float)
    pos = z >= 0
    out[pos] = 1.0 / (1.0 + np.exp(-z[pos]))
    ez = np.exp(z[~pos])                     # z < 0, so ez is in (0, 1)
    out[~pos] = ez / (1.0 + ez)
    return out


class LogisticRegression:
    def __init__(self, lr: float = 0.1, epochs: int = 2000, l2: float = 0.0) -> None:
        self.lr, self.epochs, self.l2 = lr, epochs, l2
        self.w: np.ndarray | None = None
        self.b: float = 0.0

    def fit(self, X: np.ndarray, y: np.ndarray) -> "LogisticRegression":
        """X: (n, d). y: (n,) of 0/1 labels."""
        n, d = X.shape
        self.w = np.zeros(d)
        self.b = 0.0
        for _ in range(self.epochs):
            p = sigmoid(X @ self.w + self.b)     # (n,)
            err = p - y                          # dL/dz for log loss
            grad_w = X.T @ err / n + self.l2 * self.w
            grad_b = err.mean()                  # no penalty on the bias
            self.w -= self.lr * grad_w
            self.b -= self.lr * grad_b
        return self

    def loss(self, X: np.ndarray, y: np.ndarray) -> float:
        z = X @ self.w + self.b
        # log(1 + e^z) - y*z, computed with logaddexp so it never overflows
        nll = np.mean(np.logaddexp(0.0, z) - y * z)
        return float(nll + 0.5 * self.l2 * self.w @ self.w)

    def predict_proba(self, X: np.ndarray) -> np.ndarray:
        p1 = sigmoid(X @ self.w + self.b)
        return np.column_stack([1.0 - p1, p1])   # (n, 2), like sklearn

    def predict(self, X: np.ndarray, threshold: float = 0.5) -> np.ndarray:
        return (self.predict_proba(X)[:, 1] >= threshold).astype(int)


if __name__ == "__main__":
    rng = np.random.default_rng(1)
    X = rng.normal(size=(400, 2))
    y = (X @ np.array([3.0, -2.0]) + 0.5 + 0.3 * rng.normal(size=400) > 0).astype(int)
    m = LogisticRegression(lr=0.5, l2=1e-3).fit(X, y)
    acc = (m.predict(X) == y).mean()
    assert acc > 0.95, acc
    assert np.allclose(sigmoid(np.array([-1000.0, 0.0, 1000.0])), [0.0, 0.5, 1.0])
    assert np.allclose(m.predict_proba(X).sum(1), 1.0)
    print("ok acc", acc, "loss", round(m.loss(X, y), 4))
