linearrf 1.2.1__tar.gz → 1.2.3__tar.gz

{linearrf-1.2.1/src/linearrf.egg-info → linearrf-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linearrf
-Version: 1.2.1
+Version: 1.2.3
 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.1 → linearrf-1.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "linearrf"
-version = "1.2.1"
+version = "1.2.3"
 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.1 → linearrf-1.2.3/src/linearrf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linearrf
-Version: 1.2.1
+Version: 1.2.3
 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.1 → linearrf-1.2.3}/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.1 → linearrf-1.2.3}/src/lrf/_criterion.py

@@ -82,43 +82,61 @@ def neg_mcc(y_true: np.ndarray, y_pred: np.ndarray):
 
 
 def neg_roc_auc(y_true: np.ndarray, y_pred: np.ndarray):
-    # Rank-based ROC AUC in O(n log n). Sort by descending score and sweep:
-    # each step adds the next sample to "predicted positive", so cumulative
-    # positives / negatives give TPR / FPR at every distinct cutoff.
+    # Rank-based ROC AUC in O(n log n). Sort by descending score, then evaluate
+    # TPR/FPR only at distinct-score endpoints — collapsing each tied group
+    # into a single point. Without this, tied predictions produce results that
+    # depend on the (arbitrary) within-tie sort order.
     y_true = np.asarray(y_true)
     y_pred = np.asarray(y_pred)
 
     order = np.argsort(-y_pred, kind='stable')
     y_sorted = y_true[order].astype(np.float64)
+    pred_sorted = y_pred[order]
 
-    positives = y_sorted.sum()
-    negatives = y_sorted.size - positives
+    tps_full = np.cumsum(y_sorted)
+    fps_full = np.arange(1, y_sorted.size + 1, dtype=np.float64) - tps_full
+
+    # End of each tied group: positions where the next prediction differs,
+    # plus the very last position.
+    endpoints = np.concatenate((np.where(np.diff(pred_sorted))[0],
+                                [y_sorted.size - 1]))
+    tps = tps_full[endpoints]
+    fps = fps_full[endpoints]
+
+    positives, negatives = tps[-1], fps[-1]
     if positives == 0 or negatives == 0:
         return 0.0
 
-    tpr = np.concatenate(([0.0], np.cumsum(y_sorted) / positives))
-    fpr = np.concatenate(([0.0], np.cumsum(1.0 - y_sorted) / negatives))
+    tpr = np.concatenate(([0.0], tps / positives))
+    fpr = np.concatenate(([0.0], fps / negatives))
 
     # negated so the caller minimizes AUC (matches the previous convention)
     return -_trapz(tpr, fpr)
 
 
 def neg_pr_auc(y_true: np.ndarray, y_pred: np.ndarray):
-    # Rank-based PR AUC in O(n log n) — same idea as neg_roc_auc above.
+    # Rank-based PR AUC in O(n log n). Same tie-collapsing as neg_roc_auc.
     y_true = np.asarray(y_true)
     y_pred = np.asarray(y_pred)
 
     order = np.argsort(-y_pred, kind='stable')
     y_sorted = y_true[order].astype(np.float64)
+    pred_sorted = y_pred[order]
+
+    tps_full = np.cumsum(y_sorted)
+    fps_full = np.arange(1, y_sorted.size + 1, dtype=np.float64) - tps_full
+
+    endpoints = np.concatenate((np.where(np.diff(pred_sorted))[0],
+                                [y_sorted.size - 1]))
+    tps = tps_full[endpoints]
+    fps = fps_full[endpoints]
 
-    positives = y_sorted.sum()
+    positives = tps[-1]
     if positives == 0:
         return 0.0
 
-    pos_cum = np.cumsum(y_sorted)
-    ranks = np.arange(1, y_sorted.size + 1, dtype=np.float64)
-    precision = pos_cum / ranks
-    recall = pos_cum / positives
+    precision = tps / (tps + fps)
+    recall = tps / positives
 
     return -_trapz(precision, recall)
 

linearrf-1.2.3/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.1 → linearrf-1.2.3}/src/lrf/lrf.py

@@ -21,6 +21,9 @@ class LRFRegressor(_LinearRandomForest):
         self.preprocessing = preprocessing
         self._estimator_type = 'regressor'
 
+        if criterion not in ('mse', 'rmse', 'mae', 'mape', 'wape', 'neg_explained_variance', 'neg_r2'):
+            print(' Metric "{}" is not implemented, MSE is used instead.'.format(criterion))
+
         if linear_model is None:
             linear_model = Regressor(alpha=self.alpha, preprocessing=self.preprocessing, intercept_in_input=True)
         else:
@@ -83,7 +86,6 @@ class LRFRegressor(_LinearRandomForest):
         elif self.criterion == 'neg_r2':
             val = neg_r2(y_true=y_true, y_pred=y_pred)
         else:
-            print(' Metric "{}" is not implemented, MSE is used instead.'.format(self.criterion))
             val = mse(y_true=y_true, y_pred=y_pred)
 
         return val
@@ -114,6 +116,10 @@ class LRFClassifier(_LinearRandomForest):
         self.preprocessing = preprocessing
         self._estimator_type = 'classifier'
 
+        if criterion not in ('hamming', 'cross_entropy', 'neg_mcc', 'neg_roc_auc', 'neg_pr_auc'):
+            print(' Metric "{}" is not implemented, negative Matthews Correlation Coefficient is used instead.'
+                  .format(criterion))
+
         if linear_model is None:
             linear_model = Classifier(C=self.C, preprocessing=self.preprocessing, intercept_in_input=True)
         else:
@@ -213,8 +219,6 @@ class LRFClassifier(_LinearRandomForest):
         elif self.criterion == 'neg_roc_auc':
             val = neg_roc_auc(y_true=y_true, y_pred=y_pred)
         else:
-            print(' Metric "{}" is not implemented, the negative Matthews Correlation Coefficient is used '
-                  'instead.'.format(self.criterion))
             val = neg_mcc(y_true=y_true, y_pred=y_pred)
 
         return val

linearrf-1.2.1/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))