deskit 0.2.0__tar.gz → 0.4.0__tar.gz

{deskit-0.2.0/src/deskit.egg-info → deskit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deskit
-Version: 0.2.0
+Version: 0.4.0
 Summary: A Python library for Dynamic Ensemble Selection
 Author: Tikhon Vodyanov
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # deskit
 
-[deskit](https://TikaaVo.github.io/deskit/) is a flexible, lightweight, and easy-to-use ensembling library that implements
+deskit is a flexible, lightweight, and easy-to-use ensembling library that implements
 Dynamic Ensemble Selection (DES) algorithms for ensembling multiple ML models
 on a given dataset. 
 
@@ -43,6 +43,8 @@ requiring any wrappers, including custom models, popular ML libraries, and APIs.
 deskit includes several DES algorithms, and it works with both classification
 and regression.
 
+See the full documentation [here](https://TikaaVo.github.io/deskit/).
+
 # Dynamic Ensemble Selection
 
 Ensemble learning in machine learning refers to when multiple models trained on a 
@@ -148,14 +150,15 @@ weights = router.predict(X_test[i])
 
 ## Algorithms
 
-| Method    | Best for | Notes                                                                                                    |
-|-----------|---|----------------------------------------------------------------------------------------------------------|
-| `KNNDWS`  | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness.                              |
-| `KNNDWSI` | Regression | Like KNN-DWS but scores are inverse-distance weighted.                                                   |
-| `KNORAU`  | Classification | Vote-count weighting. Each model earns one vote per neighbour it correctly classifies.                   |
-| `KNORAE`  | Classification | Intersection-based. Only models correct on all neighbours survive; falls back to smaller neighbourhoods. |
-| `KNORAIU` | Classification | Like KNORA-U but votes are inverse-distance weighted.                                                    |
-| `OLA`     | Both | Hard selection: only the single best model in the neighbourhood contributes.                             |
+| Method     | Best for       | Notes                                                                                                |
+|------------|----------------|------------------------------------------------------------------------------------------------------|
+| `DEWS-U`   | Regression     | Softmax over neighborhood-averaged scores. Temperature controls sharpness.                           |
+| `DEWS-I`   | Regression     | Like DEWS-U but scores are inverse-distance weighted.                                                |
+| `DEWS-T`   | Both           | Like DEWS-U but fits a weighted trend line over neighbor scores and extrapolates to the test point.  |
+| `KNORA-U`  | Classification | Vote-count weighting. Each model earns one vote per neighbor it correctly classifies.                |
+| `KNORA-E`  | Classification | Intersection-based. Only models correct on all neighbors survive; falls back to smaller neighborhoods. |
+| `KNORA-IU` | Classification | Like KNORA-U but votes are inverse-distance weighted.                                                |
+| `OLA`      | Both           | Hard selection: only the single best model in the neighborhood contributes.                          |
 
 ---
 
@@ -202,13 +205,18 @@ def pinball(y_true, y_pred, alpha=0.9):
     e = y_true - y_pred
     return alpha * e if e >= 0 else (alpha - 1) * e
 
-router = KNNDWS(task="regression", metric=pinball, mode="min", k=20)
+router = DEWSU(task="regression", metric=pinball, mode="min", k=20)
 ```
 
 Built-in metric strings: `accuracy`, `mae`, `mse`, `rmse`, `log_loss`, `prob_correct`.
 
 ---
 
+## Data types
+
+deskit can be used with non-tabular data types like images, time series, and more. However, when used, the
+passed features either need to be run through a feature extractor beforehand, such as a CNN backbone for images.
+
 ## Benchmark results
 
 100-seed benchmark (seeds 0–99) on standard sklearn and OpenML datasets. "Best Single" is the best
@@ -224,39 +232,39 @@ Pool: KNN, Decision Tree, SVR, Ridge, Bayesian Ridge.
 
 This pool was selected for having variability in architectures while avoiding a single dominant model.
 
-deskit algorithms tested: OLA, KNN-DWS, KNN-DWS-I, KNORA-U, KNORA-E, KNORA-IU.
+deskit algorithms tested: OLA, DEWS-U, DEWS-I, DEWS-T, KNORA-U, KNORA-E, KNORA-IU.
 
 ### Regression (MAE, lower is better)
 
-% shown as delta vs Best Single. 100-seed mean.
+% shown as delta vs Best Single. 20-seed mean.
 
-| Dataset                      | Best Single | Simple Avg | deskit best             |
-|------------------------------|-------------|------------|-------------------------|
-| California Housing (sklearn) | 0.3955      | +7.93%     | **−2.68%** (KNN-DWS-I)  |
-| Bike Sharing (OpenML)        | 51.604      | +48.39%    | **−6.25%** (KNN-DWS-I)  |
-| Abalone (OpenML)             | **1.4923**  | +1.29%     | +1.61% (KNORA-IU)       |
-| Diabetes (sklearn)           | **44.986**  | +2.98%     | +0.88% (KNN-DWS-I)      |
-| Concrete Strength (OpenML)   | 5.3934      | +21.30%    | **−2.85%** (KNORA-IU)   |
+| Dataset                      | Best Single | Simple Avg | deskit best               |
+|------------------------------|-------------|------------|---------------------------|
+| California Housing (sklearn) | 0.3956      | +7.99%     | **−2.54%** (DEWS-I)       |
+| Bike Sharing (OpenML)        | 51.678      | +47.77%    | **−6.86%** (DEWS-I)       |
+| Abalone (OpenML)             | **1.4981**  | +1.14%     | +1.47% (KNORA-U/KNORA-IU) |
+| Diabetes (sklearn)           | **44.504**  | +3.18%     | +1.09% (DEWS-I/DEWS-T)    |
+| Concrete Strength (OpenML)   | 5.2686      | +23.66%    | **−1.20%** (DEWS-I)       |
 
 deskit beats best single and simple averaging on 3/5 regression datasets. This shows how DES can provide a
 strong boost if used on the right dataset, but it might be counterproductive if used blindly.
 
 KNORA variants are designed for classification, which explains the poor performance
 on regression datasets; However, some exception can occur in certain datasets, either where
-feature space is has hard clusters (like in Concrete Strength) or when the target is discrete
+feature space has hard clusters (like in Concrete Strength) or when the target is discrete
 and classification-like (like in Abalone).
 
 ### Classification (Accuracy, higher is better)
 
-% shown as delta vs Best Single. 100-seed mean.
+% shown as delta vs Best Single. 20-seed mean.
 
-| Dataset                | Best Single | Simple Avg | deskit best             |
-|------------------------|-------------|------------|-------------------------|
-| HAR (OpenML)           | 98.24%      | −0.32%     | **+0.14%** (KNN-DWS-I)  |
-| Yeast (OpenML)         | 59.19%      | +0.46%     | **+1.48%** (KNORA-IU)   |
-| Image Segment (OpenML) | 93.65%      | +1.70%     | **+2.33%** (KNORA-IU)   |
-| Waveform (OpenML)      | **86.28%**  | −1.04%     | −0.55% (KNN-DWS-I)      |
-| Vowel (OpenML)         | 90.54%      | −1.81%     | **+0.93%** (KNORA-IU)   |
+| Dataset                | Best Single | Simple Avg | deskit best              |
+|------------------------|-------------|------------|--------------------------|
+| HAR (OpenML)           | 98.24%      | −0.33%     | **+0.16%** (DEWS-T)      |
+| Yeast (OpenML)         | 58.87%      | +0.77%     | **+1.66%** (KNORA-IU)    |
+| Image Segment (OpenML) | 93.70%      | +1.40%     | **+2.25%** (DEWS-T)      |
+| Waveform (OpenML)      | **85.91%**  | −0.98%     | −0.39% (DEWS-T)          |
+| Vowel (OpenML)         | 89.95%      | −2.05%     | **+0.93%** (KNORA-IU)    |
 
 deskit beats or matches best single and simple averaging on 4/5 classification datasets. As seen on regression, DES
 can improve or hurt performance, so it must be used wisely, but if used correctly it can show promising results.

{deskit-0.2.0 → deskit-0.4.0}/README.md

@@ -1,6 +1,6 @@
 # deskit
 
-[deskit](https://TikaaVo.github.io/deskit/) is a flexible, lightweight, and easy-to-use ensembling library that implements
+deskit is a flexible, lightweight, and easy-to-use ensembling library that implements
 Dynamic Ensemble Selection (DES) algorithms for ensembling multiple ML models
 on a given dataset. 
 
@@ -12,6 +12,8 @@ requiring any wrappers, including custom models, popular ML libraries, and APIs.
 deskit includes several DES algorithms, and it works with both classification
 and regression.
 
+See the full documentation [here](https://TikaaVo.github.io/deskit/).
+
 # Dynamic Ensemble Selection
 
 Ensemble learning in machine learning refers to when multiple models trained on a 
@@ -117,14 +119,15 @@ weights = router.predict(X_test[i])
 
 ## Algorithms
 
-| Method    | Best for | Notes                                                                                                    |
-|-----------|---|----------------------------------------------------------------------------------------------------------|
-| `KNNDWS`  | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness.                              |
-| `KNNDWSI` | Regression | Like KNN-DWS but scores are inverse-distance weighted.                                                   |
-| `KNORAU`  | Classification | Vote-count weighting. Each model earns one vote per neighbour it correctly classifies.                   |
-| `KNORAE`  | Classification | Intersection-based. Only models correct on all neighbours survive; falls back to smaller neighbourhoods. |
-| `KNORAIU` | Classification | Like KNORA-U but votes are inverse-distance weighted.                                                    |
-| `OLA`     | Both | Hard selection: only the single best model in the neighbourhood contributes.                             |
+| Method     | Best for       | Notes                                                                                                |
+|------------|----------------|------------------------------------------------------------------------------------------------------|
+| `DEWS-U`   | Regression     | Softmax over neighborhood-averaged scores. Temperature controls sharpness.                           |
+| `DEWS-I`   | Regression     | Like DEWS-U but scores are inverse-distance weighted.                                                |
+| `DEWS-T`   | Both           | Like DEWS-U but fits a weighted trend line over neighbor scores and extrapolates to the test point.  |
+| `KNORA-U`  | Classification | Vote-count weighting. Each model earns one vote per neighbor it correctly classifies.                |
+| `KNORA-E`  | Classification | Intersection-based. Only models correct on all neighbors survive; falls back to smaller neighborhoods. |
+| `KNORA-IU` | Classification | Like KNORA-U but votes are inverse-distance weighted.                                                |
+| `OLA`      | Both           | Hard selection: only the single best model in the neighborhood contributes.                          |
 
 ---
 
@@ -171,13 +174,18 @@ def pinball(y_true, y_pred, alpha=0.9):
     e = y_true - y_pred
     return alpha * e if e >= 0 else (alpha - 1) * e
 
-router = KNNDWS(task="regression", metric=pinball, mode="min", k=20)
+router = DEWSU(task="regression", metric=pinball, mode="min", k=20)
 ```
 
 Built-in metric strings: `accuracy`, `mae`, `mse`, `rmse`, `log_loss`, `prob_correct`.
 
 ---
 
+## Data types
+
+deskit can be used with non-tabular data types like images, time series, and more. However, when used, the
+passed features either need to be run through a feature extractor beforehand, such as a CNN backbone for images.
+
 ## Benchmark results
 
 100-seed benchmark (seeds 0–99) on standard sklearn and OpenML datasets. "Best Single" is the best
@@ -193,39 +201,39 @@ Pool: KNN, Decision Tree, SVR, Ridge, Bayesian Ridge.
 
 This pool was selected for having variability in architectures while avoiding a single dominant model.
 
-deskit algorithms tested: OLA, KNN-DWS, KNN-DWS-I, KNORA-U, KNORA-E, KNORA-IU.
+deskit algorithms tested: OLA, DEWS-U, DEWS-I, DEWS-T, KNORA-U, KNORA-E, KNORA-IU.
 
 ### Regression (MAE, lower is better)
 
-% shown as delta vs Best Single. 100-seed mean.
+% shown as delta vs Best Single. 20-seed mean.
 
-| Dataset                      | Best Single | Simple Avg | deskit best             |
-|------------------------------|-------------|------------|-------------------------|
-| California Housing (sklearn) | 0.3955      | +7.93%     | **−2.68%** (KNN-DWS-I)  |
-| Bike Sharing (OpenML)        | 51.604      | +48.39%    | **−6.25%** (KNN-DWS-I)  |
-| Abalone (OpenML)             | **1.4923**  | +1.29%     | +1.61% (KNORA-IU)       |
-| Diabetes (sklearn)           | **44.986**  | +2.98%     | +0.88% (KNN-DWS-I)      |
-| Concrete Strength (OpenML)   | 5.3934      | +21.30%    | **−2.85%** (KNORA-IU)   |
+| Dataset                      | Best Single | Simple Avg | deskit best               |
+|------------------------------|-------------|------------|---------------------------|
+| California Housing (sklearn) | 0.3956      | +7.99%     | **−2.54%** (DEWS-I)       |
+| Bike Sharing (OpenML)        | 51.678      | +47.77%    | **−6.86%** (DEWS-I)       |
+| Abalone (OpenML)             | **1.4981**  | +1.14%     | +1.47% (KNORA-U/KNORA-IU) |
+| Diabetes (sklearn)           | **44.504**  | +3.18%     | +1.09% (DEWS-I/DEWS-T)    |
+| Concrete Strength (OpenML)   | 5.2686      | +23.66%    | **−1.20%** (DEWS-I)       |
 
 deskit beats best single and simple averaging on 3/5 regression datasets. This shows how DES can provide a
 strong boost if used on the right dataset, but it might be counterproductive if used blindly.
 
 KNORA variants are designed for classification, which explains the poor performance
 on regression datasets; However, some exception can occur in certain datasets, either where
-feature space is has hard clusters (like in Concrete Strength) or when the target is discrete
+feature space has hard clusters (like in Concrete Strength) or when the target is discrete
 and classification-like (like in Abalone).
 
 ### Classification (Accuracy, higher is better)
 
-% shown as delta vs Best Single. 100-seed mean.
+% shown as delta vs Best Single. 20-seed mean.
 
-| Dataset                | Best Single | Simple Avg | deskit best             |
-|------------------------|-------------|------------|-------------------------|
-| HAR (OpenML)           | 98.24%      | −0.32%     | **+0.14%** (KNN-DWS-I)  |
-| Yeast (OpenML)         | 59.19%      | +0.46%     | **+1.48%** (KNORA-IU)   |
-| Image Segment (OpenML) | 93.65%      | +1.70%     | **+2.33%** (KNORA-IU)   |
-| Waveform (OpenML)      | **86.28%**  | −1.04%     | −0.55% (KNN-DWS-I)      |
-| Vowel (OpenML)         | 90.54%      | −1.81%     | **+0.93%** (KNORA-IU)   |
+| Dataset                | Best Single | Simple Avg | deskit best              |
+|------------------------|-------------|------------|--------------------------|
+| HAR (OpenML)           | 98.24%      | −0.33%     | **+0.16%** (DEWS-T)      |
+| Yeast (OpenML)         | 58.87%      | +0.77%     | **+1.66%** (KNORA-IU)    |
+| Image Segment (OpenML) | 93.70%      | +1.40%     | **+2.25%** (DEWS-T)      |
+| Waveform (OpenML)      | **85.91%**  | −0.98%     | −0.39% (DEWS-T)          |
+| Vowel (OpenML)         | 89.95%      | −2.05%     | **+0.93%** (KNORA-IU)    |
 
 deskit beats or matches best single and simple averaging on 4/5 classification datasets. As seen on regression, DES
 can improve or hurt performance, so it must be used wisely, but if used correctly it can show promising results.

{deskit-0.2.0 → deskit-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deskit"
-version = "0.2.0"
+version = "0.4.0"
 description = "A Python library for Dynamic Ensemble Selection"
 readme = "README.md"
 license = "MIT"

{deskit-0.2.0 → deskit-0.4.0}/src/deskit/__init__.py

@@ -5,13 +5,13 @@ Metrics
 -------
 Pass a metric name string:
 
-    KNNDWS(task='classification', metric='log_loss', mode='min')
+    DEWSU(task='classification', metric='log_loss', mode='min')
 
 Or import a metric function directly:
 
     from deskit.metrics import log_loss, mae
 
-    KNNDWS(task='classification', metric=log_loss, mode='min')
+    DEWSU(task='classification', metric=log_loss, mode='min')
 
 Available built-in metrics:
     Scalar predictions (pass predict() output):
@@ -21,7 +21,7 @@ Available built-in metrics:
         'log_loss', 'prob_correct'
 """
 
-from deskit.des.knndws   import KNNDWS
+from deskit.des.dewsu   import DEWSU
 from deskit.des.ola      import OLA
 from deskit.des.knorau   import KNORAU
 from deskit.des.knorae   import KNORAE
@@ -31,7 +31,7 @@ from deskit._config      import SPEED_PRESETS, list_presets
 from deskit.analysis     import analyze
 
 __all__ = [
-    'KNNDWS',
+    'DEWSU',
     'OLA',
     'KNORAU',
     'KNORAE',

{deskit-0.2.0 → deskit-0.4.0}/src/deskit/des/__init__.py

@@ -1,7 +1,7 @@
-from deskit.des.knndws import KNNDWS
+from deskit.des.dewsu import DEWSU
 from deskit.des.ola    import OLA
 from deskit.des.knorau import KNORAU
 from deskit.des.knorae import KNORAE
 from deskit.des.knoraiu import KNORAIU
 
-__all__ = ['KNNDWS', 'OLA', 'KNORAU', 'KNORAE', 'KNORAIU']
+__all__ = ['DEWSU', 'OLA', 'KNORAU', 'KNORAE', 'KNORAIU']

deskit-0.2.0/src/deskit/des/knndwsi.py → deskit-0.4.0/src/deskit/des/dewsi.py

@@ -1,5 +1,5 @@
 """
-KNN-DWS-IU: K-Nearest Neighbors with Distance-Weighted Softmax — Inverse-weighted Union.
+DEWS-IU: K-Nearest Neighbors with Distance-Weighted Softmax — Inverse-weighted Union.
 """
 from deskit.base.knnbase import KNNBase
 from deskit._config import make_finder, resolve_metric, prep_fit_inputs
@@ -7,11 +7,11 @@ from deskit.utils import to_numpy
 import numpy as np
 
 
-class KNNDWSI(KNNBase):
+class DEWSI(KNNBase):
     """
-    KNN-DWS-IU: K-Nearest Neighbors with Distance-Weighted Softmax — Inverse-weighted Union.
+    DEWS-IU: K-Nearest Neighbors with Distance-Weighted Softmax — Inverse-weighted Union.
 
-    Extends KNN-DWS by replacing the simple average of neighbor scores with an
+    Extends DEWS-U by replacing the simple average of neighbor scores with an
     inverse-distance-weighted average, so closer neighbors have a stronger
     influence on the softmax routing — analogous to how KNORA-IU extends KNORA-U.
 

deskit-0.4.0/src/deskit/des/dewst.py

@@ -0,0 +1,200 @@
+"""
+DEWS-T: Distance-weighted Ensemble with Softmax — Trend.
+"""
+from deskit.base.knnbase import KNNBase
+from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit.utils import to_numpy
+import numpy as np
+
+
+_SIGNED_METRICS = {'mae', 'mse'}
+
+
+def _signed_residual(y_true, y_pred):
+    return float(y_true) - float(y_pred)
+
+
+class DEWST(KNNBase):
+    """
+    DEWS-T: Distance-weighted Ensemble with Softmax — Trend.
+    Parameters
+    ----------
+    task : str
+        'classification' or 'regression'.
+    metric : str or callable
+        Scoring function. 'mae' or 'mse' activate signed-residual mode;
+        all other metrics are trended directly.
+    mode : str
+        'max' if higher scores are better, 'min' if lower.
+    k : int
+        Neighbourhood size. Default: 10.
+    threshold : float
+        Competence gate. After per-neighbourhood normalisation (best=1.0,
+        worst=0.0), models below this fraction are excluded from softmax.
+        0.0 disables the gate; 1.0 reduces to OLA behaviour. Default: 0.5.
+    temperature : float, optional
+        Softmax sharpness. Lower = sharper routing toward the local best model.
+        Defaults to 0.1 for min-metrics, 1.0 otherwise.
+    r2_threshold : float
+        Minimum weighted R² for the trend line to be trusted. Below this value
+        the sample falls back to DEWS-I scoring for that model. Default: 0.2.
+    preset : str
+        Neighbour search preset. Default: 'balanced'. See list_presets().
+    """
+
+    def __init__(self, task, metric='mae', mode='min', k=10,
+                 threshold=0.5, temperature=None, r2_threshold=0.2,
+                 preset='balanced', **kwargs):
+        metric_name, metric_fn = resolve_metric(metric)
+        finder = make_finder(preset, k, **kwargs)
+
+        self._use_signed  = metric_name in _SIGNED_METRICS
+        self._metric_name = metric_name
+        self._convert     = {'mae': np.abs, 'mse': np.square}.get(metric_name)
+
+        # For signed metrics, use signed residuals
+        super().__init__(
+            metric=_signed_residual if self._use_signed else metric_fn,
+            mode='max' if self._use_signed else mode,
+            neighbor_finder=finder
+        )
+
+        self._real_mode   = mode
+        self.task         = task
+        self.threshold    = threshold
+        self._temperature = temperature
+        self.r2_threshold = r2_threshold
+
+    def fit(self, features, y, preds_dict):
+        """
+
+        Parameters
+        ----------
+        features : array-like, shape (n_val, n_features)
+            Validation features. Must not overlap with train or test data.
+        y : array-like, shape (n_val,)
+            Validation ground-truth labels or values.
+        preds_dict : dict[str, array-like]
+            Validation predictions keyed by model name.
+        """
+        features, y, preds_dict = prep_fit_inputs(
+            features, y, preds_dict, self._metric_name
+        )
+        super().fit(features, y, preds_dict)
+
+    def predict(self, x, temperature=None, threshold=None):
+        """
+
+        Parameters
+        ----------
+        x : array-like, shape (n_features,) or (n_samples, n_features)
+        temperature : float, optional
+            Overrides the instance temperature for this call.
+        threshold : float, optional
+            Overrides the instance threshold for this call.
+
+        Returns
+        -------
+        dict or list of dict
+            Single sample: {model_name: weight}. Batch: list of such dicts.
+        """
+        t  = temperature if temperature is not None else (
+             self._temperature if self._temperature is not None else
+             (0.1 if self._real_mode == 'min' else 1.0))
+        th = threshold if threshold is not None else self.threshold
+
+        x          = np.atleast_2d(to_numpy(x))
+        batch_size = x.shape[0]
+
+        distances, indices = self.model.kneighbors(x)          # (batch, k)
+        k = distances.shape[1]
+
+        # Inverse-distance weights
+        inv_dist   = 1.0 / np.maximum(distances, 1e-8)         # (batch, k)
+        inv_dist_w = inv_dist / inv_dist.sum(axis=1, keepdims=True)
+
+        # Scores at each neighbour: (batch, k, n_models).
+        neighbor_scores = self.matrix[indices]
+
+        # Weighted least squares trend
+        d_max  = distances.max(axis=1, keepdims=True)
+        d_norm = distances / np.where(d_max > 0, d_max, 1.0)   # (batch, k)
+
+        # X^{T}WX: shape (batch, 2, 2)
+        W   = inv_dist_w                                        # (batch, k)
+        a   =  W.sum(axis=1)                                    # (batch,)
+        b   = (W * d_norm).sum(axis=1)
+        d_v = (W * d_norm ** 2).sum(axis=1)
+        det = a * d_v - b ** 2                                  # (batch,)
+        bad_det  = np.abs(det) <= 1e-12
+        det_safe = np.where(bad_det, 1.0, det)
+
+        # XᵀWy for all models: shape (batch, 2, n_models).
+        Wy  = neighbor_scores * inv_dist_w[:, :, np.newaxis]    # (batch, k, n_models)
+        Wdy = Wy * d_norm[:, :, np.newaxis]
+        XtWy_0 = Wy.sum(axis=1)                                 # (batch, n_models)
+        XtWy_1 = Wdy.sum(axis=1)                                # (batch, n_models)
+
+        # Closed-form 2×2 inverse applied.
+        # intercept B0
+        # slope     B1
+        intercept = (d_v[:, np.newaxis] * XtWy_0 -
+                     b[:, np.newaxis]   * XtWy_1) / det_safe[:, np.newaxis]
+        slope     = (a[:, np.newaxis]   * XtWy_1 -
+                     b[:, np.newaxis]   * XtWy_0) / det_safe[:, np.newaxis]
+
+        # Weighted R^2
+        y_hat   = (intercept[:, np.newaxis, :] +
+                   slope[:, np.newaxis, :]     *
+                   d_norm[:, :, np.newaxis])                    # (batch, k, n_models)
+        y_wmean = XtWy_0                                        # weighted mean
+        ss_res  = (inv_dist_w[:, :, np.newaxis] *
+                   (neighbor_scores - y_hat) ** 2).sum(axis=1)
+        ss_tot  = (inv_dist_w[:, :, np.newaxis] *
+                   (neighbor_scores - y_wmean[:, np.newaxis, :]) ** 2).sum(axis=1)
+        r2      = np.where(ss_tot > 1e-12, 1.0 - ss_res / ss_tot, 0.0)
+        # Bad determinant = fallback.
+        r2      = np.where(bad_det[:, np.newaxis], 0.0, r2)    # (batch, n_models)
+
+        # DEWS-I fallback
+        if self._use_signed:
+            # Convert signed residuals back to metric
+            fallback_raw   = self._convert(neighbor_scores)
+            dewsi_scores   = -(fallback_raw * inv_dist_w[:, :, np.newaxis]).sum(axis=1)
+        else:
+            dewsi_scores   = XtWy_0
+
+        # Convert trend intercept to routing scord
+        if self._use_signed:
+            trend_scores = -self._convert(intercept)            # negate for min-routing
+        else:
+            trend_scores = intercept
+
+        # Blend: trust trend where R² ≥ threshold, fall back otherwise.
+        use_trend  = r2 >= self.r2_threshold
+        avg_scores = np.where(use_trend, trend_scores, dewsi_scores)
+
+        # Standard DEWS softmax
+        local_min   = avg_scores.min(axis=1, keepdims=True)
+        local_max   = avg_scores.max(axis=1, keepdims=True)
+        local_range = local_max - local_min
+        norm_scores = (avg_scores - local_min) / np.where(local_range > 0, local_range, 1.0)
+
+        if th > 0:
+            gate        = norm_scores >= th
+            any_pass    = gate.any(axis=1, keepdims=True)
+            gate        = np.where(any_pass, gate, norm_scores == 1.0)
+            norm_scores = norm_scores * gate
+
+        max_scores = norm_scores.max(axis=1, keepdims=True)
+        exp_scores = np.exp((norm_scores - max_scores) / t)
+        if th > 0:
+            exp_scores = exp_scores * gate
+        total   = exp_scores.sum(axis=1, keepdims=True)
+        weights = np.where(total > 0,
+                           exp_scores / np.where(total > 0, total, 1.0),
+                           np.full_like(exp_scores, 1.0 / len(self.models)))
+
+        if batch_size == 1:
+            return dict(zip(self.models, weights[0]))
+        return [dict(zip(self.models, w)) for w in weights]

deskit-0.2.0/src/deskit/des/knndws.py → deskit-0.4.0/src/deskit/des/dewsu.py

@@ -1,5 +1,5 @@
 """
-KNN-DWS: K-Nearest Neighbors with Distance-Weighted Softmax.
+DEWS-U: K-Nearest Neighbors with Distance-Weighted Softmax.
 """
 from deskit.base.knnbase import KNNBase
 from deskit._config import make_finder, resolve_metric, prep_fit_inputs
@@ -7,9 +7,9 @@ from deskit.utils import to_numpy
 import numpy as np
 
 
-class KNNDWS(KNNBase):
+class DEWSU(KNNBase):
     """
-    KNN-DWS: K-Nearest Neighbors with Distance-Weighted Softmax.
+    DEWS-U: K-Nearest Neighbors with Distance-Weighted Softmax.
 
     Parameters
     ----------

{deskit-0.2.0 → deskit-0.4.0}/src/deskit/router.py

@@ -3,7 +3,7 @@ DynamicRouter — string-based factory for programmatic algorithm selection.
 
 Use DynamicRouter when you need to choose an algorithm via a string at runtime.
 """
-from deskit.des.knndws   import KNNDWS
+from deskit.des.dewsu   import DEWSU
 from deskit.des.ola      import OLA
 from deskit.des.knorau   import KNORAU
 from deskit.des.knorae   import KNORAE
@@ -12,7 +12,7 @@ from deskit._config      import SPEED_PRESETS, list_presets
 from deskit.utils        import to_numpy, add_batch_dim
 
 _METHOD_CLASSES = {
-    'knn-dws':  KNNDWS,
+    'DEWS-U':  DEWSU,
     'ola':      OLA,
     'knora-u':  KNORAU,
     'knora-e':  KNORAE,
@@ -29,7 +29,7 @@ class DynamicRouter:
     task : str
         'classification' or 'regression'.
     method : str
-        'knn-dws', 'ola', 'knora-u', or 'knora-e'.
+        'DEWS-U', 'ola', 'knora-u', or 'knora-e'.
     metric : str or callable
         Per-sample scoring function. Built-in names: 'accuracy', 'mae', 'mse',
         'rmse', 'log_loss', 'prob_correct'. Or any callable (y_true, y_pred) -> float.
@@ -40,7 +40,7 @@ class DynamicRouter:
     threshold : float
         Competence gate applied after per-neighborhood normalization.
     temperature : float, optional
-        Softmax sharpness for knn-dws. Ignored by other algorithms.
+        Softmax sharpness for DEWS-U. Ignored by other algorithms.
     preset : str
         Speed/accuracy preset. Call list_presets() for options.
     feature_extractor : callable, optional
@@ -51,7 +51,7 @@ class DynamicRouter:
         Forwarded to the neighbor finder constructor.
     """
 
-    def __init__(self, task, method='knn-dws', metric='accuracy', mode='max',
+    def __init__(self, task, method='DEWS-U', metric='accuracy', mode='max',
                  k=10, threshold=0.5, temperature=None, preset='balanced',
                  feature_extractor=None, finder=None, **kwargs):
 
@@ -71,8 +71,8 @@ class DynamicRouter:
         # Pass finder through as a kwarg when using preset='custom'.
         extra = {'finder': finder} if finder is not None else {}
 
-        # KNNDWS accepts temperature; the others don't.
-        if method == 'knn-dws':
+        # DEWSU accepts temperature; the others don't.
+        if method == 'DEWS-U':
             self._des = cls(
                 task=task, metric=metric, mode=mode, k=k,
                 threshold=threshold, temperature=temperature,
@@ -108,7 +108,7 @@ class DynamicRouter:
         ----------
         x : array-like, shape (n_features,) or (n_samples, n_features)
         temperature : float, optional
-            knn-dws only. Overrides the instance temperature for this call.
+            DEWS-U only. Overrides the instance temperature for this call.
         threshold : float, optional
             Overrides the instance threshold for this call.
 
@@ -125,7 +125,7 @@ class DynamicRouter:
     # Class methods
 
     @classmethod
-    def from_data_size(cls, n_samples, n_features, task, method='knn-dws',
+    def from_data_size(cls, n_samples, n_features, task, method='DEWS-U',
                        metric='accuracy', mode='max', k=10, threshold=0.5,
                        n_queries=None, **extra_kwargs):
         """

{deskit-0.2.0 → deskit-0.4.0/src/deskit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deskit
-Version: 0.2.0
+Version: 0.4.0
 Summary: A Python library for Dynamic Ensemble Selection
 Author: Tikhon Vodyanov
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # deskit
 
-[deskit](https://TikaaVo.github.io/deskit/) is a flexible, lightweight, and easy-to-use ensembling library that implements
+deskit is a flexible, lightweight, and easy-to-use ensembling library that implements
 Dynamic Ensemble Selection (DES) algorithms for ensembling multiple ML models
 on a given dataset. 
 
@@ -43,6 +43,8 @@ requiring any wrappers, including custom models, popular ML libraries, and APIs.
 deskit includes several DES algorithms, and it works with both classification
 and regression.
 
+See the full documentation [here](https://TikaaVo.github.io/deskit/).
+
 # Dynamic Ensemble Selection
 
 Ensemble learning in machine learning refers to when multiple models trained on a 
@@ -148,14 +150,15 @@ weights = router.predict(X_test[i])
 
 ## Algorithms
 
-| Method    | Best for | Notes                                                                                                    |
-|-----------|---|----------------------------------------------------------------------------------------------------------|
-| `KNNDWS`  | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness.                              |
-| `KNNDWSI` | Regression | Like KNN-DWS but scores are inverse-distance weighted.                                                   |
-| `KNORAU`  | Classification | Vote-count weighting. Each model earns one vote per neighbour it correctly classifies.                   |
-| `KNORAE`  | Classification | Intersection-based. Only models correct on all neighbours survive; falls back to smaller neighbourhoods. |
-| `KNORAIU` | Classification | Like KNORA-U but votes are inverse-distance weighted.                                                    |
-| `OLA`     | Both | Hard selection: only the single best model in the neighbourhood contributes.                             |
+| Method     | Best for       | Notes                                                                                                |
+|------------|----------------|------------------------------------------------------------------------------------------------------|
+| `DEWS-U`   | Regression     | Softmax over neighborhood-averaged scores. Temperature controls sharpness.                           |
+| `DEWS-I`   | Regression     | Like DEWS-U but scores are inverse-distance weighted.                                                |
+| `DEWS-T`   | Both           | Like DEWS-U but fits a weighted trend line over neighbor scores and extrapolates to the test point.  |
+| `KNORA-U`  | Classification | Vote-count weighting. Each model earns one vote per neighbor it correctly classifies.                |
+| `KNORA-E`  | Classification | Intersection-based. Only models correct on all neighbors survive; falls back to smaller neighborhoods. |
+| `KNORA-IU` | Classification | Like KNORA-U but votes are inverse-distance weighted.                                                |
+| `OLA`      | Both           | Hard selection: only the single best model in the neighborhood contributes.                          |
 
 ---
 
@@ -202,13 +205,18 @@ def pinball(y_true, y_pred, alpha=0.9):
     e = y_true - y_pred
     return alpha * e if e >= 0 else (alpha - 1) * e
 
-router = KNNDWS(task="regression", metric=pinball, mode="min", k=20)
+router = DEWSU(task="regression", metric=pinball, mode="min", k=20)
 ```
 
 Built-in metric strings: `accuracy`, `mae`, `mse`, `rmse`, `log_loss`, `prob_correct`.
 
 ---
 
+## Data types
+
+deskit can be used with non-tabular data types like images, time series, and more. However, when used, the
+passed features either need to be run through a feature extractor beforehand, such as a CNN backbone for images.
+
 ## Benchmark results
 
 100-seed benchmark (seeds 0–99) on standard sklearn and OpenML datasets. "Best Single" is the best
@@ -224,39 +232,39 @@ Pool: KNN, Decision Tree, SVR, Ridge, Bayesian Ridge.
 
 This pool was selected for having variability in architectures while avoiding a single dominant model.
 
-deskit algorithms tested: OLA, KNN-DWS, KNN-DWS-I, KNORA-U, KNORA-E, KNORA-IU.
+deskit algorithms tested: OLA, DEWS-U, DEWS-I, DEWS-T, KNORA-U, KNORA-E, KNORA-IU.
 
 ### Regression (MAE, lower is better)
 
-% shown as delta vs Best Single. 100-seed mean.
+% shown as delta vs Best Single. 20-seed mean.
 
-| Dataset                      | Best Single | Simple Avg | deskit best             |
-|------------------------------|-------------|------------|-------------------------|
-| California Housing (sklearn) | 0.3955      | +7.93%     | **−2.68%** (KNN-DWS-I)  |
-| Bike Sharing (OpenML)        | 51.604      | +48.39%    | **−6.25%** (KNN-DWS-I)  |
-| Abalone (OpenML)             | **1.4923**  | +1.29%     | +1.61% (KNORA-IU)       |
-| Diabetes (sklearn)           | **44.986**  | +2.98%     | +0.88% (KNN-DWS-I)      |
-| Concrete Strength (OpenML)   | 5.3934      | +21.30%    | **−2.85%** (KNORA-IU)   |
+| Dataset                      | Best Single | Simple Avg | deskit best               |
+|------------------------------|-------------|------------|---------------------------|
+| California Housing (sklearn) | 0.3956      | +7.99%     | **−2.54%** (DEWS-I)       |
+| Bike Sharing (OpenML)        | 51.678      | +47.77%    | **−6.86%** (DEWS-I)       |
+| Abalone (OpenML)             | **1.4981**  | +1.14%     | +1.47% (KNORA-U/KNORA-IU) |
+| Diabetes (sklearn)           | **44.504**  | +3.18%     | +1.09% (DEWS-I/DEWS-T)    |
+| Concrete Strength (OpenML)   | 5.2686      | +23.66%    | **−1.20%** (DEWS-I)       |
 
 deskit beats best single and simple averaging on 3/5 regression datasets. This shows how DES can provide a
 strong boost if used on the right dataset, but it might be counterproductive if used blindly.
 
 KNORA variants are designed for classification, which explains the poor performance
 on regression datasets; However, some exception can occur in certain datasets, either where
-feature space is has hard clusters (like in Concrete Strength) or when the target is discrete
+feature space has hard clusters (like in Concrete Strength) or when the target is discrete
 and classification-like (like in Abalone).
 
 ### Classification (Accuracy, higher is better)
 
-% shown as delta vs Best Single. 100-seed mean.
+% shown as delta vs Best Single. 20-seed mean.
 
-| Dataset                | Best Single | Simple Avg | deskit best             |
-|------------------------|-------------|------------|-------------------------|
-| HAR (OpenML)           | 98.24%      | −0.32%     | **+0.14%** (KNN-DWS-I)  |
-| Yeast (OpenML)         | 59.19%      | +0.46%     | **+1.48%** (KNORA-IU)   |
-| Image Segment (OpenML) | 93.65%      | +1.70%     | **+2.33%** (KNORA-IU)   |
-| Waveform (OpenML)      | **86.28%**  | −1.04%     | −0.55% (KNN-DWS-I)      |
-| Vowel (OpenML)         | 90.54%      | −1.81%     | **+0.93%** (KNORA-IU)   |
+| Dataset                | Best Single | Simple Avg | deskit best              |
+|------------------------|-------------|------------|--------------------------|
+| HAR (OpenML)           | 98.24%      | −0.33%     | **+0.16%** (DEWS-T)      |
+| Yeast (OpenML)         | 58.87%      | +0.77%     | **+1.66%** (KNORA-IU)    |
+| Image Segment (OpenML) | 93.70%      | +1.40%     | **+2.25%** (DEWS-T)      |
+| Waveform (OpenML)      | **85.91%**  | −0.98%     | −0.39% (DEWS-T)          |
+| Vowel (OpenML)         | 89.95%      | −2.05%     | **+0.93%** (KNORA-IU)    |
 
 deskit beats or matches best single and simple averaging on 4/5 classification datasets. As seen on regression, DES
 can improve or hurt performance, so it must be used wisely, but if used correctly it can show promising results.

{deskit-0.2.0 → deskit-0.4.0}/src/deskit.egg-info/SOURCES.txt

@@ -17,8 +17,9 @@ src/deskit/base/__init__.py
 src/deskit/base/base.py
 src/deskit/base/knnbase.py
 src/deskit/des/__init__.py
-src/deskit/des/knndws.py
-src/deskit/des/knndwsi.py
+src/deskit/des/dewsi.py
+src/deskit/des/dewst.py
+src/deskit/des/dewsu.py
 src/deskit/des/knorae.py
 src/deskit/des/knoraiu.py
 src/deskit/des/knorau.py