deskit 0.1.0__tar.gz

deskit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TikaaVo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deskit-0.1.0/PKG-INFO

@@ -0,0 +1,289 @@
+Metadata-Version: 2.4
+Name: deskit
+Version: 0.1.0
+Summary: A Python library for Dynamic Ensemble Selection
+Author: Tikhon Vodyanov
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/TikaaVo/deskit
+Project-URL: Repository, https://github.com/TikaaVo/deskit.git
+Keywords: ensemble,machine learning,dynamic ensemble selection,model routing
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Provides-Extra: exact
+Requires-Dist: scikit-learn>=1.0; extra == "exact"
+Provides-Extra: faiss
+Requires-Dist: faiss-cpu>=1.7; extra == "faiss"
+Provides-Extra: hnsw
+Requires-Dist: hnswlib>=0.7; extra == "hnsw"
+Provides-Extra: annoy
+Requires-Dist: annoy>=1.17; extra == "annoy"
+Provides-Extra: all
+Requires-Dist: scikit-learn>=1.0; extra == "all"
+Requires-Dist: faiss-cpu>=1.7; extra == "all"
+Requires-Dist: hnswlib>=0.7; extra == "all"
+Requires-Dist: annoy>=1.17; extra == "all"
+Dynamic: license-file
+
+# deskit
+
+[deskit](https://TikaaVo.github.io/deskit/) is a flexible, light, and easy-to-use ensembling library that implements
+Dynamic Ensemble Selection (DES) algorithms for ensembling multiple ML models
+on a singular dataset. 
+
+The library works entirely with data, taking as input a validation dataset 
+along with pre-computed 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
+and regression.
+
+# Dynamic Ensemble Selection
+
+Ensemble learning in machine learning refers to when multiple models trained on a 
+single dataset combine their predictions to create a single, more accurate prediction,
+usually through weighted voting or picking the best model.
+
+DES refers to techniques where the models or their voting weights are selected dynamically
+for every test case. This selection bases on the idea of competence regions, which is the 
+concept that there are regions of feature space where certain models perform particularly well,
+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 
+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.
+
+However, DES is not an automatic improvement. It tends to perform worse when datasets are homogeneous or have low diversity, 
+when the validation set isn't a good representation of the test set, when using very high dimensional data or few training samples,
+or when a single model dominates a dataset.
+
+---
+
+## Installation
+
+```bash
+pip install deskit
+
+# The library runs with Nearest Neighbors from sklearn for exact KNN
+pip install scikit-learn
+
+# Alternatively, ANN can be used for faster runtimes at the cost of
+# slightly lower accuracy. The following three are supported;
+# Install the one you want to use.
+pip install faiss-cpu   # FAISS (good default for most datasets)
+pip install annoy       # Annoy (memory-efficient, simple)
+pip install hnswlib     # HNSW (best for high-dimensional data)
+```
+
+---
+
+## Dependencies
+
+Python (>= 3.9)
+
+NumPy (>= 1.21)
+
+---
+
+## Quick start
+
+Full explanation of the algorithms, syntax, and parameters is available in the [documentation](https://TikaaVo.github.io/deskit/).
+
+```python
+from deskit.des.knorau  import KNORAU
+
+# 1. Train your models
+models = {"rf": rf, "xgb": xgb, "mlp": mlp}
+
+# 2. Get predictions on a held-out validation set
+#    Regression: scalar arrays
+#    Classification: probability arrays OR hard predictions
+val_preds = {name: m.predict_proba(X_val) for name, m in models.items()}
+
+# 3. Fit the router
+router = KNORAU(task="classification", metric="accuracy", mode="max", k=20)
+router.fit(X_val, y_val, val_preds)
+
+# 4. Route test samples
+test_preds = {name: m.predict_proba(X_test) for name, m in models.items()}
+
+for i, x in enumerate(X_test):
+    weights = router.predict(x, temperature=0.1)
+    # weights example: {"rf": 0.7, "xgb": 0.2, "mlp": 0.1}
+    prediction = sum(weights[n] * test_preds[n][i] for n in weights)
+```
+
+For classification with probability arrays, blend the output the same way to
+get a final probability distribution, then take the argmax.
+
+---
+
+## Why deskit?
+
+Most DES libraries are tied to scikit-learn. deskit only ever sees a numpy
+feature matrix and a dict of prediction arrays, so the models themselves are
+never touched after training. This allows for more flexibility and a lighter library.
+
+Furthermore, deskit works with both classification and regression, while the majority of DES
+libraries and literature is focused only on classification tasks.
+
+```python
+# PyTorch example 
+with torch.no_grad():
+    val_preds  = {name: m(X_val_t).cpu().numpy()  for name, m in models.items()}
+    test_preds = {name: m(X_test_t).cpu().numpy() for name, m in models.items()}
+
+router = KNORAU(task="classification", metric="accuracy", mode="max", k=20)
+router.fit(X_val, y_val, val_preds)
+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. |
+
+---
+
+## ANN backends
+
+deskit supports three Approximate Nearest Neighbour backends plus exact search:
+
+| Preset | Backend | Install | Notes |
+|---|---|---|---|
+| `exact` | sklearn KNN |  `scikit-learn` | Exact, no extra deps |
+| `balanced` | FAISS IVF | `faiss-cpu` | ~98% recall, good default |
+| `fast` | FAISS IVF | `faiss-cpu` | ~95% recall, faster queries |
+| `turbo` | FAISS flat | `faiss-cpu` | Exact via FAISS, GPU-friendly |
+| `high_dim_balanced` | HNSW | `hnswlib` | Best for >100 features, balanced |
+| `high_dim_fast` | HNSW | `hnswlib` | Best for >100 features, faster |
+
+Annoy is also available as a custom backend — memory-efficient and simple,
+good for datasets that need to be persisted to disk.
+
+```python
+# Exact search (no extra deps)
+router = KNORAU(..., preset="exact")
+
+# High-dimensional data
+router = KNORAU(..., preset="high_dim_balanced")
+
+# Custom FAISS config
+router = KNORAU(..., preset="custom", finder="faiss",
+                index_type="ivf", n_probes=50)
+
+# Annoy
+router = KNORAU(..., preset="custom", finder="annoy",
+                n_trees=100, search_k=-1)
+```
+
+---
+
+## Custom metrics
+
+Any callable `(y_true, y_pred) -> float` works:
+
+```python
+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)
+```
+
+Built-in metric strings: `accuracy`, `mae`, `mse`, `rmse`, `log_loss`, `prob_correct`.
+
+---
+
+## Benchmark results
+
+20-seed benchmark (seeds 0–19) 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.
+
+It is important to consider that these experiments were run with the default hyperparameters, meaning that
+they could vary greatly with different values, and results could improve with tuning.
+For a more detailed benchmark breakdown, see the [documentation](https://TikaaVo.github.io/deskit/).
+To see the full results, see `results.txt` in the `tests` folder.
+
+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.
+
+### Regression (MAE, lower is better)
+
+% shown as delta vs Best Single. 10-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) |
+
+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
+and classification-like (like in Abalone).
+
+### Classification (Accuracy, higher is better)
+
+% shown as delta vs Best Single. 10-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)      |
+
+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,
+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  |
+
+deskit caches all model predictions on the validation set at fit time and reads
+from that matrix at inference.
+
+---
+
+## Contributing
+
+Issues and PRs welcome.

deskit-0.1.0/README.md

@@ -0,0 +1,258 @@
+# deskit
+
+[deskit](https://TikaaVo.github.io/deskit/) is a flexible, light, and easy-to-use ensembling library that implements
+Dynamic Ensemble Selection (DES) algorithms for ensembling multiple ML models
+on a singular dataset. 
+
+The library works entirely with data, taking as input a validation dataset 
+along with pre-computed 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
+and regression.
+
+# Dynamic Ensemble Selection
+
+Ensemble learning in machine learning refers to when multiple models trained on a 
+single dataset combine their predictions to create a single, more accurate prediction,
+usually through weighted voting or picking the best model.
+
+DES refers to techniques where the models or their voting weights are selected dynamically
+for every test case. This selection bases on the idea of competence regions, which is the 
+concept that there are regions of feature space where certain models perform particularly well,
+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 
+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.
+
+However, DES is not an automatic improvement. It tends to perform worse when datasets are homogeneous or have low diversity, 
+when the validation set isn't a good representation of the test set, when using very high dimensional data or few training samples,
+or when a single model dominates a dataset.
+
+---
+
+## Installation
+
+```bash
+pip install deskit
+
+# The library runs with Nearest Neighbors from sklearn for exact KNN
+pip install scikit-learn
+
+# Alternatively, ANN can be used for faster runtimes at the cost of
+# slightly lower accuracy. The following three are supported;
+# Install the one you want to use.
+pip install faiss-cpu   # FAISS (good default for most datasets)
+pip install annoy       # Annoy (memory-efficient, simple)
+pip install hnswlib     # HNSW (best for high-dimensional data)
+```
+
+---
+
+## Dependencies
+
+Python (>= 3.9)
+
+NumPy (>= 1.21)
+
+---
+
+## Quick start
+
+Full explanation of the algorithms, syntax, and parameters is available in the [documentation](https://TikaaVo.github.io/deskit/).
+
+```python
+from deskit.des.knorau  import KNORAU
+
+# 1. Train your models
+models = {"rf": rf, "xgb": xgb, "mlp": mlp}
+
+# 2. Get predictions on a held-out validation set
+#    Regression: scalar arrays
+#    Classification: probability arrays OR hard predictions
+val_preds = {name: m.predict_proba(X_val) for name, m in models.items()}
+
+# 3. Fit the router
+router = KNORAU(task="classification", metric="accuracy", mode="max", k=20)
+router.fit(X_val, y_val, val_preds)
+
+# 4. Route test samples
+test_preds = {name: m.predict_proba(X_test) for name, m in models.items()}
+
+for i, x in enumerate(X_test):
+    weights = router.predict(x, temperature=0.1)
+    # weights example: {"rf": 0.7, "xgb": 0.2, "mlp": 0.1}
+    prediction = sum(weights[n] * test_preds[n][i] for n in weights)
+```
+
+For classification with probability arrays, blend the output the same way to
+get a final probability distribution, then take the argmax.
+
+---
+
+## Why deskit?
+
+Most DES libraries are tied to scikit-learn. deskit only ever sees a numpy
+feature matrix and a dict of prediction arrays, so the models themselves are
+never touched after training. This allows for more flexibility and a lighter library.
+
+Furthermore, deskit works with both classification and regression, while the majority of DES
+libraries and literature is focused only on classification tasks.
+
+```python
+# PyTorch example 
+with torch.no_grad():
+    val_preds  = {name: m(X_val_t).cpu().numpy()  for name, m in models.items()}
+    test_preds = {name: m(X_test_t).cpu().numpy() for name, m in models.items()}
+
+router = KNORAU(task="classification", metric="accuracy", mode="max", k=20)
+router.fit(X_val, y_val, val_preds)
+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. |
+
+---
+
+## ANN backends
+
+deskit supports three Approximate Nearest Neighbour backends plus exact search:
+
+| Preset | Backend | Install | Notes |
+|---|---|---|---|
+| `exact` | sklearn KNN |  `scikit-learn` | Exact, no extra deps |
+| `balanced` | FAISS IVF | `faiss-cpu` | ~98% recall, good default |
+| `fast` | FAISS IVF | `faiss-cpu` | ~95% recall, faster queries |
+| `turbo` | FAISS flat | `faiss-cpu` | Exact via FAISS, GPU-friendly |
+| `high_dim_balanced` | HNSW | `hnswlib` | Best for >100 features, balanced |
+| `high_dim_fast` | HNSW | `hnswlib` | Best for >100 features, faster |
+
+Annoy is also available as a custom backend — memory-efficient and simple,
+good for datasets that need to be persisted to disk.
+
+```python
+# Exact search (no extra deps)
+router = KNORAU(..., preset="exact")
+
+# High-dimensional data
+router = KNORAU(..., preset="high_dim_balanced")
+
+# Custom FAISS config
+router = KNORAU(..., preset="custom", finder="faiss",
+                index_type="ivf", n_probes=50)
+
+# Annoy
+router = KNORAU(..., preset="custom", finder="annoy",
+                n_trees=100, search_k=-1)
+```
+
+---
+
+## Custom metrics
+
+Any callable `(y_true, y_pred) -> float` works:
+
+```python
+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)
+```
+
+Built-in metric strings: `accuracy`, `mae`, `mse`, `rmse`, `log_loss`, `prob_correct`.
+
+---
+
+## Benchmark results
+
+20-seed benchmark (seeds 0–19) 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.
+
+It is important to consider that these experiments were run with the default hyperparameters, meaning that
+they could vary greatly with different values, and results could improve with tuning.
+For a more detailed benchmark breakdown, see the [documentation](https://TikaaVo.github.io/deskit/).
+To see the full results, see `results.txt` in the `tests` folder.
+
+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.
+
+### Regression (MAE, lower is better)
+
+% shown as delta vs Best Single. 10-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) |
+
+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
+and classification-like (like in Abalone).
+
+### Classification (Accuracy, higher is better)
+
+% shown as delta vs Best Single. 10-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)      |
+
+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,
+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  |
+
+deskit caches all model predictions on the validation set at fit time and reads
+from that matrix at inference.
+
+---
+
+## Contributing
+
+Issues and PRs welcome.

deskit-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deskit"
+version = "0.1.0"
+description = "A Python library for Dynamic Ensemble Selection"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    { name = "Tikhon Vodyanov" }
+]
+keywords = ["ensemble", "machine learning", "dynamic ensemble selection", "model routing"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=1.21",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.optional-dependencies]
+exact = ["scikit-learn>=1.0"]
+faiss  = ["faiss-cpu>=1.7"]
+hnsw  = ["hnswlib>=0.7"]
+annoy = ["annoy>=1.17"]
+all   = ["scikit-learn>=1.0", "faiss-cpu>=1.7", "hnswlib>=0.7", "annoy>=1.17"]
+
+[project.urls]
+Homepage = "https://github.com/TikaaVo/deskit"
+Repository = "https://github.com/TikaaVo/deskit.git"

deskit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

deskit-0.1.0/src/deskit/__init__.py

@@ -0,0 +1,43 @@
+"""
+deskit — Dynamic Ensemble Selection library.
+
+Metrics
+-------
+Pass a metric name string:
+
+    KNNDWS(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')
+
+Available built-in metrics:
+    Scalar predictions (pass predict() output):
+        'mae', 'mse', 'rmse', 'accuracy'
+
+    Probability predictions (pass predict_proba() output):
+        'log_loss', 'prob_correct'
+"""
+
+from deskit.des.knndws   import KNNDWS
+from deskit.des.ola      import OLA
+from deskit.des.knorau   import KNORAU
+from deskit.des.knorae   import KNORAE
+from deskit.des.knoraiu import KNORAIU
+from deskit.router       import DynamicRouter
+from deskit._config      import SPEED_PRESETS, list_presets
+from deskit.analysis     import analyze
+
+__all__ = [
+    'KNNDWS',
+    'OLA',
+    'KNORAU',
+    'KNORAE',
+    'KNORAIU',
+    'DynamicRouter',
+    'SPEED_PRESETS',
+    'list_presets',
+    'analyze',
+]