PyPI - deskit - Versions diffs - 0.1.0__tar.gz → 0.3.0__tar.gz - Mend

deskit 0.1.0tar.gz → 0.3.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

{deskit-0.1.0/src/deskit.egg-info → deskit-0.3.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deskit
-Version: 0.1.0
+Version: 0.3.0
 Summary: A Python library for Dynamic Ensemble Selection
 Author: Tikhon Vodyanov
 License-Expression: MIT
@@ -31,18 +31,20 @@ Dynamic: license-file
 # deskit
-[deskit](https://TikaaVo.github.io/deskit/) is a flexible, light, 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 singular dataset.
+on a given dataset.
 The library works entirely with data, taking as input a validation dataset
-along with pre-computed predictions and outputting a dictionary of weights
+along with precomputed predictions and outputting a dictionary of weights
 per model. This means that it can be used with any library or model without
 requiring any wrappers, including custom models, popular ML libraries, and APIs.
-deskit contains multiple different DES algorithms, and it works with both classification
+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
@@ -55,7 +57,7 @@ concept that there are regions of feature space where certain models perform par
 so every base model can be an expert in a different region.
 Only the most competent, or an ensemble of the most competent models is selected for the prediction.
-Through empirical studies, DES has been shown to perform best with small-sized, imbalanced, or
+Through empirical studies, DES has been shown to perform best on small-sized, imbalanced, or
 heterogeneous datasets, as well as non-stationary data (concept drift), models that haven't perfected a dataset,
 and when used on an ensemble of models with differing architectures and perspectives.
@@ -148,13 +150,14 @@ weights = router.predict(X_test[i])
 ## Algorithms
-| Method | Best for | Notes |
-|---|---|---|
-| `KNNDWS` | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness. |
-| `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                                                                                                    |
+|-----------|---|----------------------------------------------------------------------------------------------------------|
+| `DEWSU`  | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness.                              |
+| `DEWSI` | Regression | Like DEWS-U 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.                             |
 ---
@@ -201,16 +204,21 @@ 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
-20-seed benchmark (seeds 0–19) on standard sklearn and OpenML datasets. "Best Single" is the best
+100-seed benchmark (seeds 0–99) on standard sklearn and OpenML datasets. "Best Single" is the best
 individual model selected on the validation set. "Simple Average" is uniform
 equal-weight blending, included as a baseline.
@@ -223,19 +231,19 @@ 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, KNORA-U, KNORA-E, KNORA-IU.
+deskit algorithms tested: OLA, DEWS-U, DEWS-I, KNORA-U, KNORA-E, KNORA-IU.
 ### Regression (MAE, lower is better)
-% shown as delta vs Best Single. 10-seed mean.
+% shown as delta vs Best Single. 100-seed mean.
-| Dataset                      | Best Single | Simple Avg | deskit best            |
-|------------------------------|-----------|---|-----------------------|
-| California Housing (sklearn) | 0.3956    | +7.99% | **-2.24%** (KNN-DWS)  |
-| Bike Sharing (OpenML)        | 51.6779   | +47.77% | **-5.34%** (KNN-DWS)  |
-| Abalone (OpenML)             | **1.4981** | +1.14% | +1.47% (KNORA-U)      |
-| Diabetes (sklearn)           | **44.5042** | +3.18% | +1.17% (KNN-DWS)      |
-| Conrete Strength (OpenML)    | 5.2686 | +23.66% | **-1.05%** (KNORA-IU) |
+| Dataset                      | Best Single | Simple Avg | deskit best             |
+|------------------------------|-------------|------------|-------------------------|
+| California Housing (sklearn) | 0.3955      | +7.93%     | **−2.68%** (DEWS-I)  |
+| Bike Sharing (OpenML)        | 51.604      | +48.39%    | **−6.25%** (DEWS-I)  |
+| Abalone (OpenML)             | **1.4923**  | +1.29%     | +1.61% (KNORA-IU)       |
+| Diabetes (sklearn)           | **44.986**  | +2.98%     | +0.88% (DEWS-I)      |
+| Concrete Strength (OpenML)   | 5.3934      | +21.30%    | **−2.85%** (KNORA-IU)   |
 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.
@@ -247,37 +255,37 @@ and classification-like (like in Abalone).
 ### Classification (Accuracy, higher is better)
-% shown as delta vs Best Single. 10-seed mean.
+% shown as delta vs Best Single. 100-seed mean.
-| Dataset                | Best Single | Simple Avg | deskit best            |
-|------------------------|-------------|--------|-----------------------|
-| HAR (OpenML)           | 98.24%      | -0.33% | **+0.14%** (KNN-DWS)  |
-| Yeast (OpenML)         | 58.87%      | +0.77% | **+1.66%** (KNORA-IU) |
-| Image Segment (OpenML) | 93.70%      | +1.40% | **+2.09%** (KNORA-IU) |
-| Waveform (OpenML)      | 89.95%      | -2.05% | **+0.93%** (KNORA-E)  |
-| Vowel (OpenML)         | **85.91%**  | -0.98% | -0.40% (KNN-DWS)      |
+| Dataset                | Best Single | Simple Avg | deskit best             |
+|------------------------|-------------|------------|-------------------------|
+| HAR (OpenML)           | 98.24%      | −0.32%     | **+0.14%** (DEWS-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% (DEWS-I)      |
+| Vowel (OpenML)         | 90.54%      | −1.81%     | **+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.
 ### Speed (mean ms fit + predict, 20 seeds, all tested algorithms combined)
-Consider that usually it is recommended to only use one algorithm at a time, this benchmark ran five of them at the
-same time, so with a single one runtime is expected to be about 5x faster. For this benchmark, `preset='balanced'` was used,
+Consider that usually it is recommended to only use one algorithm at a time, this benchmark ran six of them at the
+same time, so with a single one runtime is expected to be about 6x faster. For this benchmark, `preset='balanced'` was used,
 so the backend was an ANN algorithm with FAISS IVF.
 | Dataset            | deskit    |
-|--------------------|----------|
-| California Housing | 136.6 ms |
-| Bike Sharing       | 115.5 ms |
-| Abalone            | 28.5 ms  |
-| Diabetes           | 8.1 ms   |
-| Conrete Strength   | 9.4 ms   |
-| HAR                | 297.5 ms |
-| Yeast              | 16.3 ms  |
-| Image Segment      | 27.2 ms  |
-| Waveform           | 48.9 ms  |
-| Vowel              | 16.5 ms  |
+|--------------------|-----------|
+| California Housing | 159.8 ms  |
+| Bike Sharing       | 130.3 ms  |
+| Abalone            | 32.9 ms   |
+| Diabetes           | 8.2 ms    |
+| Conrete Strength   | 10.8 ms   |
+| HAR                | 352.0 ms  |
+| Yeast              | 18.6 ms   |
+| Image Segment      | 32.4 ms   |
+| Waveform           | 58.7 ms   |
+| Vowel              | 19.6 ms   |
 deskit caches all model predictions on the validation set at fit time and reads
 from that matrix at inference.

{deskit-0.1.0 → deskit-0.3.0}/README.md RENAMED Viewed

@@ -1,17 +1,19 @@
 # deskit
-[deskit](https://TikaaVo.github.io/deskit/) is a flexible, light, 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 singular dataset.
+on a given dataset.
 The library works entirely with data, taking as input a validation dataset
-along with pre-computed predictions and outputting a dictionary of weights
+along with precomputed predictions and outputting a dictionary of weights
 per model. This means that it can be used with any library or model without
 requiring any wrappers, including custom models, popular ML libraries, and APIs.
-deskit contains multiple different DES algorithms, and it works with both classification
+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
@@ -24,7 +26,7 @@ concept that there are regions of feature space where certain models perform par
 so every base model can be an expert in a different region.
 Only the most competent, or an ensemble of the most competent models is selected for the prediction.
-Through empirical studies, DES has been shown to perform best with small-sized, imbalanced, or
+Through empirical studies, DES has been shown to perform best on small-sized, imbalanced, or
 heterogeneous datasets, as well as non-stationary data (concept drift), models that haven't perfected a dataset,
 and when used on an ensemble of models with differing architectures and perspectives.
@@ -117,13 +119,14 @@ weights = router.predict(X_test[i])
 ## Algorithms
-| Method | Best for | Notes |
-|---|---|---|
-| `KNNDWS` | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness. |
-| `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                                                                                                    |
+|-----------|---|----------------------------------------------------------------------------------------------------------|
+| `DEWSU`  | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness.                              |
+| `DEWSI` | Regression | Like DEWS-U 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.                             |
 ---
@@ -170,16 +173,21 @@ 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
-20-seed benchmark (seeds 0–19) on standard sklearn and OpenML datasets. "Best Single" is the best
+100-seed benchmark (seeds 0–99) on standard sklearn and OpenML datasets. "Best Single" is the best
 individual model selected on the validation set. "Simple Average" is uniform
 equal-weight blending, included as a baseline.
@@ -192,19 +200,19 @@ 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, KNORA-U, KNORA-E, KNORA-IU.
+deskit algorithms tested: OLA, DEWS-U, DEWS-I, KNORA-U, KNORA-E, KNORA-IU.
 ### Regression (MAE, lower is better)
-% shown as delta vs Best Single. 10-seed mean.
+% shown as delta vs Best Single. 100-seed mean.
-| Dataset                      | Best Single | Simple Avg | deskit best            |
-|------------------------------|-----------|---|-----------------------|
-| California Housing (sklearn) | 0.3956    | +7.99% | **-2.24%** (KNN-DWS)  |
-| Bike Sharing (OpenML)        | 51.6779   | +47.77% | **-5.34%** (KNN-DWS)  |
-| Abalone (OpenML)             | **1.4981** | +1.14% | +1.47% (KNORA-U)      |
-| Diabetes (sklearn)           | **44.5042** | +3.18% | +1.17% (KNN-DWS)      |
-| Conrete Strength (OpenML)    | 5.2686 | +23.66% | **-1.05%** (KNORA-IU) |
+| Dataset                      | Best Single | Simple Avg | deskit best             |
+|------------------------------|-------------|------------|-------------------------|
+| California Housing (sklearn) | 0.3955      | +7.93%     | **−2.68%** (DEWS-I)  |
+| Bike Sharing (OpenML)        | 51.604      | +48.39%    | **−6.25%** (DEWS-I)  |
+| Abalone (OpenML)             | **1.4923**  | +1.29%     | +1.61% (KNORA-IU)       |
+| Diabetes (sklearn)           | **44.986**  | +2.98%     | +0.88% (DEWS-I)      |
+| Concrete Strength (OpenML)   | 5.3934      | +21.30%    | **−2.85%** (KNORA-IU)   |
 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.
@@ -216,37 +224,37 @@ and classification-like (like in Abalone).
 ### Classification (Accuracy, higher is better)
-% shown as delta vs Best Single. 10-seed mean.
+% shown as delta vs Best Single. 100-seed mean.
-| Dataset                | Best Single | Simple Avg | deskit best            |
-|------------------------|-------------|--------|-----------------------|
-| HAR (OpenML)           | 98.24%      | -0.33% | **+0.14%** (KNN-DWS)  |
-| Yeast (OpenML)         | 58.87%      | +0.77% | **+1.66%** (KNORA-IU) |
-| Image Segment (OpenML) | 93.70%      | +1.40% | **+2.09%** (KNORA-IU) |
-| Waveform (OpenML)      | 89.95%      | -2.05% | **+0.93%** (KNORA-E)  |
-| Vowel (OpenML)         | **85.91%**  | -0.98% | -0.40% (KNN-DWS)      |
+| Dataset                | Best Single | Simple Avg | deskit best             |
+|------------------------|-------------|------------|-------------------------|
+| HAR (OpenML)           | 98.24%      | −0.32%     | **+0.14%** (DEWS-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% (DEWS-I)      |
+| Vowel (OpenML)         | 90.54%      | −1.81%     | **+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.
 ### Speed (mean ms fit + predict, 20 seeds, all tested algorithms combined)
-Consider that usually it is recommended to only use one algorithm at a time, this benchmark ran five of them at the
-same time, so with a single one runtime is expected to be about 5x faster. For this benchmark, `preset='balanced'` was used,
+Consider that usually it is recommended to only use one algorithm at a time, this benchmark ran six of them at the
+same time, so with a single one runtime is expected to be about 6x faster. For this benchmark, `preset='balanced'` was used,
 so the backend was an ANN algorithm with FAISS IVF.
 | Dataset            | deskit    |
-|--------------------|----------|
-| California Housing | 136.6 ms |
-| Bike Sharing       | 115.5 ms |
-| Abalone            | 28.5 ms  |
-| Diabetes           | 8.1 ms   |
-| Conrete Strength   | 9.4 ms   |
-| HAR                | 297.5 ms |
-| Yeast              | 16.3 ms  |
-| Image Segment      | 27.2 ms  |
-| Waveform           | 48.9 ms  |
-| Vowel              | 16.5 ms  |
+|--------------------|-----------|
+| California Housing | 159.8 ms  |
+| Bike Sharing       | 130.3 ms  |
+| Abalone            | 32.9 ms   |
+| Diabetes           | 8.2 ms    |
+| Conrete Strength   | 10.8 ms   |
+| HAR                | 352.0 ms  |
+| Yeast              | 18.6 ms   |
+| Image Segment      | 32.4 ms   |
+| Waveform           | 58.7 ms   |
+| Vowel              | 19.6 ms   |
 deskit caches all model predictions on the validation set at fit time and reads
 from that matrix at inference.
@@ -255,4 +263,4 @@ from that matrix at inference.
 ## Contributing
-Issues and PRs welcome.
+Issues and PRs welcome.

{deskit-0.1.0 → deskit-0.3.0}/pyproject.toml RENAMED Viewed

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

{deskit-0.1.0 → deskit-0.3.0}/src/deskit/__init__.py RENAMED Viewed

@@ -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.1.0 → deskit-0.3.0}/src/deskit/des/__init__.py RENAMED Viewed

@@ -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.3.0/src/deskit/des/dewsi.py ADDED Viewed

@@ -0,0 +1,130 @@
+"""
+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
+from deskit.utils import to_numpy
+import numpy as np
+class DEWSI(KNNBase):
+    """
+    DEWS-IU: K-Nearest Neighbors with Distance-Weighted Softmax — Inverse-weighted Union.
+    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.
+    Parameters
+    ----------
+    task : str
+        'classification' or 'regression'.
+    metric : str or callable
+        Scoring function. Use 'log_loss' or 'prob_correct' with predict_proba()
+        output for classification; 'mae', 'mse', or 'rmse' for regression.
+    mode : str
+        'max' if higher scores are better, 'min' if lower.
+    k : int
+        Neighborhood size. Default: 10.
+    threshold : float
+        After per-neighborhood normalization (best=1.0, worst=0.0), models
+        below this fraction are excluded from softmax. 0.0 disables the gate;
+        1.0 reduces to OLA behavior. Default: 0.5.
+    temperature : float, optional
+        Softmax sharpness. Lower = sharper routing toward the local best model;
+        higher = softer blending. If not set, defaults to 0.1 for regression
+        (min-metrics) and 1.0 for classification (max-metrics) at predict time.
+    preset : str
+        Neighbor search preset. Default: 'balanced'. See list_presets().
+    """
+    def __init__(self, task, metric='mae', mode='min', k=10,
+                 threshold=0.5, temperature=None, preset='balanced', **kwargs):
+        metric_name, metric_fn = resolve_metric(metric)
+        finder = make_finder(preset, k, **kwargs)
+        super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder)
+        self.task         = task
+        self.threshold    = threshold
+        self._temperature = temperature
+        self._metric_name = metric_name
+    def fit(self, features, y, preds_dict):
+        """
+        Fit the routing model on validation data.
+        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.
+            Shape (n_val,) for scalar metrics; (n_val, n_classes) for probability metrics.
+        """
+        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):
+        """
+        Return per-sample model weights.
+        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.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)   # both (batch, k)
+        # Inverse-distance-weighted average of each model's scores over the K neighbors.
+        # Closer neighbors exert stronger influence on routing.
+        inv_dist    = 1.0 / np.maximum(distances, 1e-8)          # (batch, k)
+        inv_dist_w  = inv_dist / inv_dist.sum(axis=1, keepdims=True)  # normalised weights
+        neighbor_scores = self.matrix[indices]                    # (batch, k, n_models)
+        avg_scores  = (neighbor_scores * inv_dist_w[:, :, np.newaxis]).sum(axis=1)  # (batch, n_models)
+        # Normalize per neighborhood: best model = 1.0, worst = 0.0
+        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)
+        # Zero out models below threshold.
+        # If nothing passes: fall back to single best.
+        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
+        # Softmax
+        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.1.0/src/deskit/des/knndws.py → deskit-0.3.0/src/deskit/des/dewsu.py RENAMED Viewed

@@ -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.1.0 → deskit-0.3.0}/src/deskit/router.py RENAMED Viewed

@@ -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.1.0 → deskit-0.3.0/src/deskit.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deskit
-Version: 0.1.0
+Version: 0.3.0
 Summary: A Python library for Dynamic Ensemble Selection
 Author: Tikhon Vodyanov
 License-Expression: MIT
@@ -31,18 +31,20 @@ Dynamic: license-file
 # deskit
-[deskit](https://TikaaVo.github.io/deskit/) is a flexible, light, 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 singular dataset.
+on a given dataset.
 The library works entirely with data, taking as input a validation dataset
-along with pre-computed predictions and outputting a dictionary of weights
+along with precomputed predictions and outputting a dictionary of weights
 per model. This means that it can be used with any library or model without
 requiring any wrappers, including custom models, popular ML libraries, and APIs.
-deskit contains multiple different DES algorithms, and it works with both classification
+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
@@ -55,7 +57,7 @@ concept that there are regions of feature space where certain models perform par
 so every base model can be an expert in a different region.
 Only the most competent, or an ensemble of the most competent models is selected for the prediction.
-Through empirical studies, DES has been shown to perform best with small-sized, imbalanced, or
+Through empirical studies, DES has been shown to perform best on small-sized, imbalanced, or
 heterogeneous datasets, as well as non-stationary data (concept drift), models that haven't perfected a dataset,
 and when used on an ensemble of models with differing architectures and perspectives.
@@ -148,13 +150,14 @@ weights = router.predict(X_test[i])
 ## Algorithms
-| Method | Best for | Notes |
-|---|---|---|
-| `KNNDWS` | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness. |
-| `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                                                                                                    |
+|-----------|---|----------------------------------------------------------------------------------------------------------|
+| `DEWSU`  | Regression | Softmax over neighbourhood-averaged scores. Temperature controls sharpness.                              |
+| `DEWSI` | Regression | Like DEWS-U 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.                             |
 ---
@@ -201,16 +204,21 @@ 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
-20-seed benchmark (seeds 0–19) on standard sklearn and OpenML datasets. "Best Single" is the best
+100-seed benchmark (seeds 0–99) on standard sklearn and OpenML datasets. "Best Single" is the best
 individual model selected on the validation set. "Simple Average" is uniform
 equal-weight blending, included as a baseline.
@@ -223,19 +231,19 @@ 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, KNORA-U, KNORA-E, KNORA-IU.
+deskit algorithms tested: OLA, DEWS-U, DEWS-I, KNORA-U, KNORA-E, KNORA-IU.
 ### Regression (MAE, lower is better)
-% shown as delta vs Best Single. 10-seed mean.
+% shown as delta vs Best Single. 100-seed mean.
-| Dataset                      | Best Single | Simple Avg | deskit best            |
-|------------------------------|-----------|---|-----------------------|
-| California Housing (sklearn) | 0.3956    | +7.99% | **-2.24%** (KNN-DWS)  |
-| Bike Sharing (OpenML)        | 51.6779   | +47.77% | **-5.34%** (KNN-DWS)  |
-| Abalone (OpenML)             | **1.4981** | +1.14% | +1.47% (KNORA-U)      |
-| Diabetes (sklearn)           | **44.5042** | +3.18% | +1.17% (KNN-DWS)      |
-| Conrete Strength (OpenML)    | 5.2686 | +23.66% | **-1.05%** (KNORA-IU) |
+| Dataset                      | Best Single | Simple Avg | deskit best             |
+|------------------------------|-------------|------------|-------------------------|
+| California Housing (sklearn) | 0.3955      | +7.93%     | **−2.68%** (DEWS-I)  |
+| Bike Sharing (OpenML)        | 51.604      | +48.39%    | **−6.25%** (DEWS-I)  |
+| Abalone (OpenML)             | **1.4923**  | +1.29%     | +1.61% (KNORA-IU)       |
+| Diabetes (sklearn)           | **44.986**  | +2.98%     | +0.88% (DEWS-I)      |
+| Concrete Strength (OpenML)   | 5.3934      | +21.30%    | **−2.85%** (KNORA-IU)   |
 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.
@@ -247,37 +255,37 @@ and classification-like (like in Abalone).
 ### Classification (Accuracy, higher is better)
-% shown as delta vs Best Single. 10-seed mean.
+% shown as delta vs Best Single. 100-seed mean.
-| Dataset                | Best Single | Simple Avg | deskit best            |
-|------------------------|-------------|--------|-----------------------|
-| HAR (OpenML)           | 98.24%      | -0.33% | **+0.14%** (KNN-DWS)  |
-| Yeast (OpenML)         | 58.87%      | +0.77% | **+1.66%** (KNORA-IU) |
-| Image Segment (OpenML) | 93.70%      | +1.40% | **+2.09%** (KNORA-IU) |
-| Waveform (OpenML)      | 89.95%      | -2.05% | **+0.93%** (KNORA-E)  |
-| Vowel (OpenML)         | **85.91%**  | -0.98% | -0.40% (KNN-DWS)      |
+| Dataset                | Best Single | Simple Avg | deskit best             |
+|------------------------|-------------|------------|-------------------------|
+| HAR (OpenML)           | 98.24%      | −0.32%     | **+0.14%** (DEWS-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% (DEWS-I)      |
+| Vowel (OpenML)         | 90.54%      | −1.81%     | **+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.
 ### Speed (mean ms fit + predict, 20 seeds, all tested algorithms combined)
-Consider that usually it is recommended to only use one algorithm at a time, this benchmark ran five of them at the
-same time, so with a single one runtime is expected to be about 5x faster. For this benchmark, `preset='balanced'` was used,
+Consider that usually it is recommended to only use one algorithm at a time, this benchmark ran six of them at the
+same time, so with a single one runtime is expected to be about 6x faster. For this benchmark, `preset='balanced'` was used,
 so the backend was an ANN algorithm with FAISS IVF.
 | Dataset            | deskit    |
-|--------------------|----------|
-| California Housing | 136.6 ms |
-| Bike Sharing       | 115.5 ms |
-| Abalone            | 28.5 ms  |
-| Diabetes           | 8.1 ms   |
-| Conrete Strength   | 9.4 ms   |
-| HAR                | 297.5 ms |
-| Yeast              | 16.3 ms  |
-| Image Segment      | 27.2 ms  |
-| Waveform           | 48.9 ms  |
-| Vowel              | 16.5 ms  |
+|--------------------|-----------|
+| California Housing | 159.8 ms  |
+| Bike Sharing       | 130.3 ms  |
+| Abalone            | 32.9 ms   |
+| Diabetes           | 8.2 ms    |
+| Conrete Strength   | 10.8 ms   |
+| HAR                | 352.0 ms  |
+| Yeast              | 18.6 ms   |
+| Image Segment      | 32.4 ms   |
+| Waveform           | 58.7 ms   |
+| Vowel              | 19.6 ms   |
 deskit caches all model predictions on the validation set at fit time and reads
 from that matrix at inference.

{deskit-0.1.0 → deskit-0.3.0}/src/deskit.egg-info/SOURCES.txt RENAMED Viewed

@@ -17,7 +17,8 @@ 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/dewsi.py
+src/deskit/des/dewsu.py
 src/deskit/des/knorae.py
 src/deskit/des/knoraiu.py
 src/deskit/des/knorau.py