linearrf 1.2.0__tar.gz → 1.2.2__tar.gz

{linearrf-1.2.0/src/linearrf.egg-info → linearrf-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linearrf
-Version: 1.2.0
+Version: 1.2.2
 Summary: A python libary to build Random Forests with Linear Models at the leaves.
 Author-email: Marian Biermann <marianbiermann@gmx.de>
 Project-URL: homepage, https://github.com/marianbiermann/lrf

{linearrf-1.2.0 → linearrf-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "linearrf"
-version = "1.2.0"
+version = "1.2.2"
 description = "A python libary to build Random Forests with Linear Models at the leaves."
 readme = "README.md"
 authors = [{ name = "Marian Biermann", email = "marianbiermann@gmx.de" }]

{linearrf-1.2.0 → linearrf-1.2.2/src/linearrf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linearrf
-Version: 1.2.0
+Version: 1.2.2
 Summary: A python libary to build Random Forests with Linear Models at the leaves.
 Author-email: Marian Biermann <marianbiermann@gmx.de>
 Project-URL: homepage, https://github.com/marianbiermann/lrf

{linearrf-1.2.0 → linearrf-1.2.2}/src/lrf/_base_lrf.py

@@ -184,7 +184,7 @@ class _LinearRandomForest:
 
         rng = np.random.default_rng(random_state)
 
-        idx = rng.choice(np.arange(x.shape[0]), x.shape[0])
+        idx = rng.integers(0, x.shape[0], x.shape[0])
         x = x[idx]
         y = y[idx]
 

linearrf-1.2.2/src/lrf/_irls.py

@@ -0,0 +1,112 @@
+import numpy as np
+
+
+class IRLS:
+    """Iteratively Reweighted Least Squares for L2-regularized logistic regression.
+
+    Each iteration is a single Newton step using the closed-form Hessian for
+    the binary log-loss: H = XᵀWX + λR, with W = diag(p(1-p)). Typically
+    converges in 5-15 iterations from a zero start and 2-5 iterations from a
+    warm start, versus the previous BFGS implementation which could take
+    hundreds of function evaluations per fit.
+
+    Each Newton step is guarded by Armijo backtracking so the loss is
+    monotonically non-increasing — protects against overshoot when the warm
+    start lands in an ill-conditioned region (saturated probabilities make
+    XᵀWX nearly singular on the data side and Newton's quadratic model
+    misleads).
+
+    Args:
+        n_iter: maximum Newton iterations.
+        tol: stop when ||t·step|| / max(||β||, 1) < tol.
+        intercept: whether x[:, 0] is the intercept column. The intercept is
+                   excluded from L2 regularization.
+    """
+
+    # Textbook Armijo constant. _backtrack_max = 20 → smallest accepted step
+    # is 2**-20 of full Newton; below that we treat the iter as a failure.
+    _armijo_c1 = 1e-4
+    _backtrack_max = 20
+
+    def __init__(self, n_iter: int = 25, tol: float = 1e-6, intercept: bool = True):
+        self.n_iter = n_iter
+        self.tol = tol
+        self.intercept = intercept
+
+    def classification(self, x: np.ndarray, y_true: np.ndarray, coef_: np.ndarray, C: float = 1.0):
+        # λ = 1/C, matching the sklearn convention. The intercept term sits at
+        # position 0 and stays unregularized.
+        lam = 1.0 / C
+        m = x.shape[1]
+
+        reg_diag = np.full(m, lam)
+        if self.intercept:
+            reg_diag[0] = 0.0
+
+        beta = coef_.astype(np.float64, copy=True)
+        y = y_true.astype(np.float64, copy=False)
+
+        loss = self._loss(x, y, beta, reg_diag)
+
+        for _ in range(self.n_iter):
+            p = self._sigmoid(x @ beta)
+
+            # Hessian weight; clipped so saturated probabilities don't collapse
+            # XᵀWX to singular.
+            w = np.clip(p * (1.0 - p), 1e-12, None)
+
+            grad = x.T @ (p - y) + reg_diag * beta
+
+            xtwx = (x * w[:, np.newaxis]).T @ x
+            # add λR on the diagonal in-place
+            xtwx.flat[::m + 1] += reg_diag
+
+            try:
+                step = np.linalg.solve(xtwx, grad)
+            except np.linalg.LinAlgError:
+                break
+
+            # Search direction d = -step; ∇fᵀd = -gᵀstep. Should be negative
+            # whenever the Hessian is SPD and grad ≠ 0. A non-negative value
+            # means the solve produced garbage — bail rather than ascend.
+            directional = -(grad @ step)
+            if directional >= 0:
+                break
+
+            # Armijo backtracking: shrink t until f(β + t·d) ≤ f(β) + c1·t·∇fᵀd.
+            t = 1.0
+            new_beta = beta
+            new_loss = loss
+            for _ in range(self._backtrack_max):
+                new_beta = beta - t * step
+                new_loss = self._loss(x, y, new_beta, reg_diag)
+                if new_loss <= loss + self._armijo_c1 * t * directional:
+                    break
+                t *= 0.5
+            else:
+                # Could not find a step satisfying sufficient decrease; stop.
+                break
+
+            beta = new_beta
+            loss = new_loss
+
+            # use t·step (the step actually taken) so a heavily-backtracked iter
+            # is correctly recognized as small progress
+            if np.linalg.norm(t * step) / max(np.linalg.norm(beta), 1.0) < self.tol:
+                break
+
+        return beta
+
+    @staticmethod
+    def _loss(x: np.ndarray, y: np.ndarray, beta: np.ndarray, reg_diag: np.ndarray):
+        # L(β) = Σ logaddexp(0, z) - y·z + ½ Σ λ_j β_j²,  z = Xβ
+        # logaddexp form avoids log(p) blowups when p is near 0 or 1.
+        z = x @ beta
+        nll = np.logaddexp(0.0, z).sum() - y @ z
+        reg = 0.5 * (reg_diag * beta).dot(beta)
+        return nll + reg
+
+    @staticmethod
+    def _sigmoid(z: np.ndarray):
+        # σ(z) = exp(-logaddexp(0, -z)) — overflow-safe in both tails.
+        return np.exp(-np.logaddexp(0, -z))

{linearrf-1.2.0 → linearrf-1.2.2}/src/lrf/_node.py

@@ -13,6 +13,6 @@ class Node:
     split_col_idx: int = None
     threshold: float = None
     metric: float = None
-    left_node = None
-    right_node = None
+    left_node: 'Node' = None
+    right_node: 'Node' = None
     model: Union[Regressor, Classifier] = None

{linearrf-1.2.0 → linearrf-1.2.2}/src/lrf/lrf.py

@@ -53,7 +53,7 @@ class LRFRegressor(_LinearRandomForest):
     def _predict_tree(self, node: Node, x: np.ndarray, results: List):
         if node.model is None:
             if x.shape[0] > 0:
-                left_indices = x[:, node.split_col_idx + 1] < node.threshold
+                left_indices = x[:, node.split_col_idx + 1] <= node.threshold
                 right_indices = ~left_indices
 
                 results = self._predict_tree(node.left_node, x[left_indices], results)
@@ -184,7 +184,7 @@ class LRFClassifier(_LinearRandomForest):
 
         if node.model is None:
             if x.shape[0] > 0:
-                left_indices = x[:, node.split_col_idx + 1] < node.threshold
+                left_indices = x[:, node.split_col_idx + 1] <= node.threshold
                 right_indices = ~left_indices
 
                 results = self._predict_proba_tree(node.left_node, x[left_indices], results)

linearrf-1.2.0/src/lrf/_irls.py

@@ -1,66 +0,0 @@
-import numpy as np
-
-
-class IRLS:
-    """Iteratively Reweighted Least Squares for L2-regularized logistic regression.
-
-    Each iteration is a single Newton step using the closed-form Hessian for
-    the binary log-loss: H = XᵀWX + λR, with W = diag(p(1-p)). Typically
-    converges in 5-15 iterations from a zero start and 2-5 iterations from a
-    warm start, versus the previous BFGS implementation which could take
-    hundreds of function evaluations per fit.
-
-    Args:
-        n_iter: maximum Newton iterations.
-        tol: stop when ||step|| / max(||β||, 1) < tol.
-        intercept: whether x[:, 0] is the intercept column. The intercept is
-                   excluded from L2 regularization.
-    """
-
-    def __init__(self, n_iter: int = 25, tol: float = 1e-6, intercept: bool = True):
-        self.n_iter = n_iter
-        self.tol = tol
-        self.intercept = intercept
-
-    def classification(self, x: np.ndarray, y_true: np.ndarray, coef_: np.ndarray, C: float = 1.0):
-        # λ = 1/C, matching the sklearn convention. The intercept term sits at
-        # position 0 and stays unregularized.
-        lam = 1.0 / C
-        m = x.shape[1]
-
-        reg_diag = np.full(m, lam)
-        if self.intercept:
-            reg_diag[0] = 0.0
-
-        beta = coef_.astype(np.float64, copy=True)
-        y = y_true.astype(np.float64, copy=False)
-
-        for _ in range(self.n_iter):
-            p = self._sigmoid(x @ beta)
-
-            # Hessian weight; clipped so saturated probabilities don't collapse
-            # XᵀWX to singular.
-            w = np.clip(p * (1.0 - p), 1e-12, None)
-
-            grad = x.T @ (p - y) + reg_diag * beta
-
-            xtwx = (x * w[:, np.newaxis]).T @ x
-            # add λR on the diagonal in-place
-            xtwx.flat[::m + 1] += reg_diag
-
-            try:
-                step = np.linalg.solve(xtwx, grad)
-            except np.linalg.LinAlgError:
-                break
-
-            beta -= step
-
-            if np.linalg.norm(step) / max(np.linalg.norm(beta), 1.0) < self.tol:
-                break
-
-        return beta
-
-    @staticmethod
-    def _sigmoid(z: np.ndarray):
-        # σ(z) = exp(-logaddexp(0, -z)) — overflow-safe in both tails.
-        return np.exp(-np.logaddexp(0, -z))