deskit 1.2.8__tar.gz → 1.3__tar.gz

{deskit-1.2.8/src/deskit.egg-info → deskit-1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deskit
-Version: 1.2.8
+Version: 1.3
 Summary: A Python library for Dynamic Ensemble Selection
 Author: Tikhon Vodyanov
 License-Expression: MIT

{deskit-1.2.8 → deskit-1.3}/pyproject.toml

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

{deskit-1.2.8 → deskit-1.3}/src/deskit/_config.py

@@ -4,6 +4,7 @@ Not part of the public API.
 """
 import numpy as np
 from deskit.metrics import _METRICS, _PROB_METRICS, _SCALAR_METRICS
+from deskit.norms import _NORMS
 from deskit.utils import to_numpy
 
 
@@ -83,6 +84,32 @@ def resolve_metric(metric):
         return name, _METRICS[name]
     return None, metric
 
+# ---------------------------------------------------------------------------
+# Normalization resolution
+# ---------------------------------------------------------------------------
+
+def resolve_norm(norm):
+    """
+    Convert a normalization string or callable to (name_or_None, callable).
+
+    Returns
+    -------
+    norm_name : str or None
+        String name if normalization was passed as a string; None for callables.
+    norm_fn : callable
+        The actual normalization function.
+    """
+    if isinstance(norm, str):
+        name = norm.lower()
+        if name not in _NORMS:
+            raise ValueError(
+                f"Unknown normalization '{norm}'. "
+                f"Built-in options: {sorted(_NORMS)}. "
+                f"Pass a callable for custom normalizations."
+            )
+        return name, _NORMS[name]
+    return None, norm
+
 
 # ---------------------------------------------------------------------------
 # Neighbor finder construction

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/dewsi.py

@@ -2,7 +2,7 @@
 DEWS-I: K-Nearest Neighbors with Distance-Weighted Softmax — Inverse-weighted.
 """
 from deskit.base.knnbase import KNNBase
-from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -44,14 +44,17 @@ class DEWSI(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidian', **kwargs):
+                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
+        norm_name, norm_fn = resolve_norm(normalization)
         finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, task=task)
         self.task = task
         self.threshold = threshold
         self._temperature = temperature
         self._metric_name = metric_name
+        self.norm = norm_fn
+        self.norm_name = norm_name
 
     def fit(self, features, y, preds_dict):
         """
@@ -72,7 +75,7 @@ class DEWSI(KNNBase):
         )
         super().fit(features, y, preds_dict)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
@@ -87,6 +90,10 @@ class DEWSI(KNNBase):
              self._temperature if self._temperature is not None else
              (0.5 if self.mode == 'min' else 1.0))
         th = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         distances, indices = self._kneighbors(x, k=k, loo=loo)           # both (batch, k)
 
@@ -97,10 +104,7 @@ class DEWSI(KNNBase):
         avg_scores = (neighbor_scores * inv_dist_w[:, :, np.newaxis]).sum(axis=1)  # (batch, n_models)
 
         # Normalize per neighborhood: best = 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)
+        norm_scores = norm_fn(avg_scores)
 
         # Zero out models below threshold; fall back to single best if none pass
         if th > 0:

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/dewsiv.py

@@ -2,7 +2,7 @@
 DEWS-IV: Distance-weighted Ensemble with Softmax — Inverse-distance + Variance-penalised.
 """
 from deskit.base.knnbase import KNNBase
-from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -46,8 +46,9 @@ class DEWSIV(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidian', **kwargs):
+                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
+        norm_name, norm_fn = resolve_norm(normalization)
         finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
 
         self._use_signed  = metric_name in _SIGNED_METRICS
@@ -59,6 +60,8 @@ class DEWSIV(KNNBase):
         self.threshold    = threshold
         self._temperature = temperature
         self._var_matrix  = None   # (n_val, n_models) signed residuals, MAE/MSE only
+        self.norm = norm_fn
+        self.norm_name = norm_name
 
     def fit(self, features, y, preds_dict):
         """
@@ -87,7 +90,7 @@ class DEWSIV(KNNBase):
                 preds = np.asarray(preds_dict[name])
                 self._var_matrix[:, j] = np.vectorize(_signed_residual)(y, preds)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
@@ -96,6 +99,10 @@ class DEWSIV(KNNBase):
              self._temperature if self._temperature is not None else
              (0.5 if self.mode == 'min' else 1.0))
         th = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         distances, indices = self._kneighbors(x, k=k, loo=loo)                # both (batch, k)
 
@@ -128,12 +135,11 @@ class DEWSIV(KNNBase):
         var_range = var_max - var_min
         norm_var  = (local_var - var_min) / np.where(var_range > 0, var_range, 1.0)
 
-        # Penalise inconsistent models, then re-normalize
-        norm_scores = norm_scores / (1.0 + norm_var)
-        local_min   = norm_scores.min(axis=1, keepdims=True)
-        local_max   = norm_scores.max(axis=1, keepdims=True)
-        local_range = local_max - local_min
-        norm_scores = (norm_scores - local_min) / np.where(local_range > 0, local_range, 1.0)
+        # Penalise inconsistent models
+        penalized = norm_scores / (1.0 + norm_var)
+
+        # Apply the user-selected normalization
+        norm_scores = norm_fn(penalized)
 
         # Zero out models below threshold; fall back to single best if none pass
         if th > 0:

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/dewst.py

@@ -2,7 +2,7 @@
 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._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -50,9 +50,10 @@ class DEWST(KNNBase):
 
     def __init__(self, task, metric='mae', mode='min', k=10,
                  threshold=0.5, temperature=None, r2_threshold=0.7,
-                 preset='balanced', distance_metric='euclidean', **kwargs):
+                 preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
-        finder = make_finder(preset, k, **kwargs)
+        norm_name, norm_fn = resolve_norm(normalization)
+        finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
 
         self._use_signed = metric_name in _SIGNED_METRICS
         self._metric_name = metric_name
@@ -71,6 +72,9 @@ class DEWST(KNNBase):
         self._temperature = temperature
         self.r2_threshold = r2_threshold
 
+        self.norm = norm_fn
+        self.norm_name = norm_name
+
     def fit(self, features, y, preds_dict):
         """
         Fit the routing model on validation data.
@@ -89,7 +93,7 @@ class DEWST(KNNBase):
         )
         super().fit(features, y, preds_dict)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, r2_threshold=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, r2_threshold=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
@@ -99,6 +103,10 @@ class DEWST(KNNBase):
              (0.5 if self._real_mode == 'min' else 1.0))
         th    = threshold    if threshold    is not None else self.threshold
         r2_th = r2_threshold if r2_threshold is not None else self.r2_threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         distances, indices = self._kneighbors(x, k=k, loo=loo)          # (batch, k)
         k = distances.shape[1]
@@ -164,18 +172,17 @@ class DEWST(KNNBase):
         use_trend  = r2 >= r2_th
         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)
+        # Normalize
+        norm_scores = norm_fn(avg_scores)
 
+        # Threshold
         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:

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/dewsu.py

@@ -2,7 +2,7 @@
 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
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -40,14 +40,17 @@ class DEWSU(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidean', **kwargs):
+                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
-        finder = make_finder(preset, k, **kwargs)
+        norm_name, norm_fn = resolve_norm(normalization)
+        finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, task=task)
         self.task = task
         self.threshold = threshold
         self._temperature = temperature
         self._metric_name = metric_name
+        self.norm = norm_fn
+        self.norm_name = norm_name
 
     def fit(self, features, y, preds_dict):
         """
@@ -68,7 +71,7 @@ class DEWSU(KNNBase):
         )
         super().fit(features, y, preds_dict)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
@@ -77,6 +80,10 @@ class DEWSU(KNNBase):
              self._temperature if self._temperature is not None else
              (0.5 if self.mode == 'min' else 1.0))
         th = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         _, indices = self._kneighbors(x, k=k, loo=loo)                        # (batch, k)
 
@@ -84,16 +91,14 @@ class DEWSU(KNNBase):
         avg_scores = self.matrix[indices].mean(axis=1)               # (batch, n_models)
 
         # Normalize per neighborhood: best = 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)
+
+        norm_scores = norm_fn(avg_scores)
 
         # Zero out models below threshold; fall back to single best if none pass
         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)
+            gate = np.where(any_pass, gate, norm_scores == norm_scores.max(axis=1, keepdims=True))
             norm_scores = norm_scores * gate
 
         # Softmax

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/dewsv.py

@@ -2,7 +2,7 @@
 DEWS-V: Distance-weighted Ensemble with Softmax — Variance-penalised.
 """
 from deskit.base.knnbase import KNNBase
-from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -46,8 +46,9 @@ class DEWSV(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidean', **kwargs):
+                 threshold=0.5, temperature=None, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
+        norm_name, norm_fn = resolve_norm(normalization)
         finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
 
         self._use_signed = metric_name in _SIGNED_METRICS
@@ -60,6 +61,9 @@ class DEWSV(KNNBase):
         self._temperature = temperature
         self._var_matrix = None   # (n_val, n_models) signed residuals, MAE/MSE only
 
+        self.norm = norm_fn
+        self.norm_name = norm_name
+
     def fit(self, features, y, preds_dict):
         """
         Fit the routing model on validation data.
@@ -87,7 +91,7 @@ class DEWSV(KNNBase):
                 preds = np.asarray(preds_dict[name])
                 self._var_matrix[:, j] = np.vectorize(_signed_residual)(y, preds)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
@@ -96,6 +100,10 @@ class DEWSV(KNNBase):
              self._temperature if self._temperature is not None else
              (0.5 if self.mode == 'min' else 1.0))
         th = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         _, indices = self._kneighbors(x, k=k, loo=loo)                        # (batch, k)
 
@@ -119,12 +127,11 @@ class DEWSV(KNNBase):
         var_range = var_max - var_min
         norm_var  = (local_var - var_min) / np.where(var_range > 0, var_range, 1.0)
 
-        # Penalise inconsistent models, then re-normalize
-        norm_scores = norm_scores / (1.0 + norm_var)
-        local_min   = norm_scores.min(axis=1, keepdims=True)
-        local_max   = norm_scores.max(axis=1, keepdims=True)
-        local_range = local_max - local_min
-        norm_scores = (norm_scores - local_min) / np.where(local_range > 0, local_range, 1.0)
+        # Penalise inconsistent models
+        penalized = norm_scores / (1.0 + norm_var)
+
+        # Apply the user-selected normalization
+        norm_scores = norm_fn(penalized)
 
         # Zero out models below threshold; fall back to single best if none pass
         if th > 0:

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/knorae.py

@@ -2,7 +2,7 @@
 KNORA-E: K-Nearest Oracles — Eliminate.
 """
 from deskit.base.knnbase import KNNBase
-from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -35,14 +35,18 @@ class KNORAE(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, preset='balanced', distance_metric='euclidean', **kwargs):
+                 threshold=0.5, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
-        finder = make_finder(preset, k, **kwargs)
-        super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, task=task)
+        norm_name, norm_fn = resolve_norm(normalization)
+        finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
+        super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, normalization='bestrel', task=task)
         self.task = task
         self.threshold = threshold
         self._metric_name = metric_name
 
+        self.norm = norm_fn
+        self.norm_name = norm_name
+
     def fit(self, features, y, preds_dict):
         """
         Fit the routing model on validation data.
@@ -58,13 +62,17 @@ class KNORAE(KNNBase):
         )
         super().fit(features, y, preds_dict)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
         temperature is accepted for API compatibility but has no effect.
         """
         th       = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
         n_models = len(self.models)
 
         _, indices      = self._kneighbors(x, k=k, loo=loo)
@@ -72,12 +80,7 @@ class KNORAE(KNNBase):
         neighbor_scores = self.matrix[indices]                        # (batch, k, n_models)
 
         # Normalize per neighbor: best model = 1.0, worst = 0.0
-        n_min   = neighbor_scores.min(axis=2, keepdims=True)
-        n_max   = neighbor_scores.max(axis=2, keepdims=True)
-        n_range = n_max - n_min
-        norm    = np.where(n_range > 0,
-                           (neighbor_scores - n_min) / n_range,
-                           1.0)
+        norm = norm_fn(neighbor_scores)
 
         competent   = norm >= th                                      # (batch, k, n_models)
         batch_size  = x.shape[0]

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/knoraiu.py

@@ -2,7 +2,7 @@
 KNORA-IU: K-Nearest Oracles — Inverse-weighted Union.
 """
 from deskit.base.knnbase import KNNBase
-from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -36,14 +36,18 @@ class KNORAIU(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, preset='balanced', distance_metric='euclidean', **kwargs):
+                 threshold=0.5, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
-        finder = make_finder(preset, k, **kwargs)
+        norm_name, norm_fn = resolve_norm(normalization)
+        finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, task=task)
         self.task = task
         self.threshold = threshold
         self._metric_name = metric_name
 
+        self.norm = norm_fn
+        self.norm_name = norm_name
+
     def fit(self, features, y, preds_dict):
         """
         Fit the routing model on validation data.
@@ -59,24 +63,23 @@ class KNORAIU(KNNBase):
         )
         super().fit(features, y, preds_dict)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
         temperature is accepted for API compatibility but has no effect.
         """
         th = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         distances, indices = self._kneighbors(x, k=k, loo=loo)                # both (batch, k)
         neighbor_scores    = self.matrix[indices]                     # (batch, k, n_models)
 
         # Normalize per neighbor: best model = 1.0, worst = 0.0
-        n_min   = neighbor_scores.min(axis=2, keepdims=True)
-        n_max   = neighbor_scores.max(axis=2, keepdims=True)
-        n_range = n_max - n_min
-        norm    = np.where(n_range > 0,
-                           (neighbor_scores - n_min) / n_range,
-                           1.0)
+        norm = norm_fn(neighbor_scores)
 
         competent = norm >= th                                        # (batch, k, n_models)
 

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/knorau.py

@@ -2,7 +2,7 @@
 KNORA-U: K-Nearest Oracles — Union.
 """
 from deskit.base.knnbase import KNNBase
-from deskit._config import make_finder, resolve_metric, prep_fit_inputs
+from deskit._config import make_finder, resolve_metric, resolve_norm, prep_fit_inputs
 import numpy as np
 
 
@@ -36,14 +36,18 @@ class KNORAU(KNNBase):
     """
 
     def __init__(self, task, metric='mae', mode='min', k=10,
-                 threshold=0.5, preset='balanced', distance_metric='euclidean', **kwargs):
+                 threshold=0.5, preset='balanced', distance_metric='euclidean', normalization='bestrel', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
-        finder = make_finder(preset, k, **kwargs)
+        norm_name, norm_fn = resolve_norm(normalization)
+        finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, task=task)
         self.task = task
         self.threshold = threshold
         self._metric_name = metric_name
 
+        self.norm = norm_fn
+        self.norm_name = norm_name
+
     def fit(self, features, y, preds_dict):
         """
         Fit the routing model on validation data.
@@ -59,24 +63,23 @@ class KNORAU(KNNBase):
         )
         super().fit(features, y, preds_dict)
 
-    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False):
+    def _weights_batch(self, x, temperature=None, threshold=None, k=None, loo=False, normalization=None):
         """
         Core weight computation. x is a 2-D float64 numpy array (batch, n_features).
         Returns (batch, n_models) weight array.
         temperature is accepted for API compatibility but has no effect.
         """
         th = threshold if threshold is not None else self.threshold
+        if normalization is not None:
+            _, norm_fn = resolve_norm(normalization)
+        else:
+            norm_fn = self.norm
 
         _, indices      = self._kneighbors(x, k=k, loo=loo)
         neighbor_scores = self.matrix[indices]                        # (batch, k, n_models)
 
         # Normalize per neighbor: best model = 1.0, worst = 0.0
-        n_min   = neighbor_scores.min(axis=2, keepdims=True)
-        n_max   = neighbor_scores.max(axis=2, keepdims=True)
-        n_range = n_max - n_min
-        norm    = np.where(n_range > 0,
-                           (neighbor_scores - n_min) / n_range,
-                           1.0)   # tied → all equally competent
+        norm = norm_fn(neighbor_scores)
 
         # votes[b, j] = number of neighbours where model j exceeds the threshold
         votes       = (norm >= th).sum(axis=1).astype(float)         # (batch, n_models)

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/lwsei.py

@@ -30,7 +30,7 @@ class LWSEI(PredictBase):
     def __init__(self, task, k=10, preset='balanced', distance_metric='euclidean', **kwargs):
         self.task    = task
         self.k       = k
-        self._finder = make_finder(preset, k, **kwargs)
+        self._finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         self.models  = None
 
         self._val_preds = None   # (n_val, n_models) or (n_val, n_models, n_classes)

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/lwseu.py

@@ -30,7 +30,7 @@ class LWSEU(PredictBase):
     def __init__(self, task, k=10, preset='balanced', distance_metric='euclidean', **kwargs):
         self.task    = task
         self.k       = k
-        self._finder = make_finder(preset, k, **kwargs)
+        self._finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         self.models  = None
 
         self._val_preds = None   # (n_val, n_models) or (n_val, n_models, n_classes)

{deskit-1.2.8 → deskit-1.3}/src/deskit/des/ola.py

@@ -33,7 +33,7 @@ class OLA(KNNBase):
     def __init__(self, task, metric='mae', mode='min', k=10,
                  preset='balanced', threshold=None, distance_metric='euclidean', **kwargs):
         metric_name, metric_fn = resolve_metric(metric)
-        finder = make_finder(preset, k, **kwargs)
+        finder = make_finder(preset, k, distance_metric=distance_metric, **kwargs)
         super().__init__(metric=metric_fn, mode=mode, neighbor_finder=finder, task=task)
         self.task = task
         self._metric_name = metric_name

deskit-1.3/src/deskit/norms.py

@@ -0,0 +1,82 @@
+"""
+Normalization functions for Dynamic Ensemble Selection.
+
+All functions operate row-wise: each row corresponds to a query instance,
+and columns are the base models. They return a matrix of the same shape,
+with values in a suitable range (usually [0,1]) and "higher = better".
+
+Built‑in options:
+    'minmax'   : classic min‑max scaling per row → [0,1]
+    'zscore'   : z‑score per row (mean 0, std 1) – may be negative
+    'bestrel'  : ratio‑to‑best, automatically handles sign -> [0,1]:
+                 - if scores are all negative (e.g., -errors): best / score
+                 - if scores are all non‑negative (e.g., V/IV): score / best
+    'softmax'  : softmax with temperature=1 (optional)
+    'rank'     : rank‑based (0 for worst, 1 for best) – robust to outliers
+
+Custom functions can be passed via the `normalization` parameter in DEWS.
+"""
+
+import numpy as np
+
+EPS = 1e-12
+
+def minmax(x):
+    """Row‑wise min‑max scaling to [0,1]."""
+    x_min = x.min(axis=1, keepdims=True)
+    x_max = x.max(axis=1, keepdims=True)
+    x_range = x_max - x_min
+    # Avoid division by zero (if range is 0, set to 1.0)
+    safe_range = np.where(x_range > 0, x_range, 1.0)
+    return (x - x_min) / safe_range
+
+def zscore(x):
+    """Row‑wise z‑score (standard score) with bias‑corrected std."""
+    mean = x.mean(axis=1, keepdims=True)
+    std = x.std(axis=1, keepdims=True, ddof=1)  # sample std
+    safe_std = np.where(std > EPS, std, 1.0)
+    return (x - mean) / safe_std
+
+def bestrel(x):
+    """
+    Ratio‑to‑best normalization.
+
+    """
+    max_val = x.max(axis=1, keepdims=True)
+    # Determine per‑row which normalization to use based on the max
+    eps = 1e-12
+    safe_x = np.minimum(x, -eps)
+    norm_neg = max_val / safe_x   # this will be <=1 because max is the least negative
+    safe_max = np.where(max_val > eps, max_val, eps)
+    norm_pos = x / safe_max       # will be in [0,1]
+
+    neg_mask = max_val < -eps
+    result = np.where(neg_mask, norm_neg, norm_pos)
+    return result
+
+def softmax(x, temperature=1.0):
+    """Row‑wise softmax with optional temperature (higher temperature → more uniform)."""
+    x_scaled = x / temperature
+    x_shifted = x_scaled - x_scaled.max(axis=1, keepdims=True)  # stability
+    exp_x = np.exp(x_shifted)
+    return exp_x / exp_x.sum(axis=1, keepdims=True)
+
+def rank_norm(x):
+    """
+    Convert each row to fractional ranks: worst → 0, best → 1.
+    Ties are averaged.
+    """
+    # Get ranks along axis=1 (method='average' gives average rank for ties)
+    ranks = x.argsort(axis=1).argsort(axis=1) + 1  # ranks from 1 to M
+    # Convert to [0,1] with 1 for best (highest original value)
+    M = x.shape[1]
+    # For 'higher is better', we invert: rank 1 (lowest original) gets 0, rank M (highest) gets 1
+    return (ranks - 1) / (M - 1) if M > 1 else np.ones_like(x) * 0.5
+
+_NORMS = {
+    'minmax': minmax,
+    'z': zscore,
+    'bestrel': bestrel,
+    'softmax': softmax,
+    'rank_norm': rank_norm
+}

{deskit-1.2.8 → deskit-1.3/src/deskit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deskit
-Version: 1.2.8
+Version: 1.3
 Summary: A Python library for Dynamic Ensemble Selection
 Author: Tikhon Vodyanov
 License-Expression: MIT

{deskit-1.2.8 → deskit-1.3}/src/deskit.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/deskit/__init__.py
 src/deskit/_config.py
 src/deskit/metrics.py
 src/deskit/neighbors.py
+src/deskit/norms.py
 src/deskit/router.py
 src/deskit/utils.py
 src/deskit.egg-info/PKG-INFO