wavetrainer 0.0.39__tar.gz → 0.0.40__tar.gz

{wavetrainer-0.0.39/wavetrainer.egg-info → wavetrainer-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.39
+Version: 0.0.40
 Summary: A library for automatically finding the optimal model within feature and hyperparameter space.
 Home-page: https://github.com/8W9aG/wavetrainer
 Author: Will Sackfield
@@ -24,10 +24,8 @@ Requires-Dist: mapie>=0.9.2
 Requires-Dist: pytz>=2025.1
 Requires-Dist: torch>=2.6.0
 Requires-Dist: tabpfn>=2.0.6
-Requires-Dist: tabpfn-extensions>=0.0.4
-Requires-Dist: shap>=0.47.2
-Requires-Dist: hyperopt>=0.2.7
 Requires-Dist: pytest-is-running>=1.5.1
+Requires-Dist: xgboost>=3.0.0
 
 # wavetrainer
 
@@ -58,10 +56,8 @@ Python 3.11.6:
 - [pytz](https://pythonhosted.org/pytz/)
 - [torch](https://pytorch.org/)
 - [tabpfn](https://github.com/PriorLabs/TabPFN)
-- [tabpfn-extensions](https://github.com/PriorLabs/tabpfn-extensions)
-- [shap](https://shap.readthedocs.io/en/latest/)
-- [hyperopt](https://hyperopt.github.io/hyperopt/)
 - [pytest-is-running](https://github.com/adamchainz/pytest-is-running)
+- [xgboost](https://xgboost.readthedocs.io/en/release_3.0.0/)
 
 ## Raison D'être :thought_balloon:
 

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/README.md

@@ -27,10 +27,8 @@ Python 3.11.6:
 - [pytz](https://pythonhosted.org/pytz/)
 - [torch](https://pytorch.org/)
 - [tabpfn](https://github.com/PriorLabs/TabPFN)
-- [tabpfn-extensions](https://github.com/PriorLabs/tabpfn-extensions)
-- [shap](https://shap.readthedocs.io/en/latest/)
-- [hyperopt](https://hyperopt.github.io/hyperopt/)
 - [pytest-is-running](https://github.com/adamchainz/pytest-is-running)
+- [xgboost](https://xgboost.readthedocs.io/en/release_3.0.0/)
 
 ## Raison D'être :thought_balloon:
 

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/requirements.txt

@@ -11,7 +11,5 @@ mapie>=0.9.2
 pytz>=2025.1
 torch>=2.6.0
 tabpfn>=2.0.6
-tabpfn-extensions>=0.0.4
-shap>=0.47.2
-hyperopt>=0.2.7
-pytest-is-running>=1.5.1
+pytest-is-running>=1.5.1
+xgboost>=3.0.0

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/setup.py

@@ -23,7 +23,7 @@ def install_requires() -> typing.List[str]:
 
 setup(
     name='wavetrainer',
-    version='0.0.39',
+    version='0.0.40',
     description='A library for automatically finding the optimal model within feature and hyperparameter space.',
     long_description=long_description,
     long_description_content_type='text/markdown',

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/tests/model/catboost_kwargs_test.py

@@ -3,7 +3,7 @@ import unittest
 
 import pandas as pd
 
-from wavetrainer.model.catboost_kwargs import handle_fit_kwargs
+from wavetrainer.model.catboost.catboost_kwargs import handle_fit_kwargs
 
 
 class TestCatboostKwargs(unittest.TestCase):

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/tests/trainer_test.py

@@ -13,7 +13,7 @@ class TestTrainer(unittest.TestCase):
 
     def test_trainer(self):
         with tempfile.TemporaryDirectory() as tmpdir:
-            trainer = Trainer(tmpdir, walkforward_timedelta=datetime.timedelta(days=7), trials=1)
+            trainer = Trainer(tmpdir, walkforward_timedelta=datetime.timedelta(days=7), trials=5)
             x_data = [i for i in range(101)]
             x_index = [datetime.datetime(2022, 1, 1) + datetime.timedelta(days=i) for i in range(len(x_data))]
             df = pd.DataFrame(

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer/__init__.py

@@ -2,5 +2,5 @@
 
 from .create import create
 
-__VERSION__ = "0.0.39"
+__VERSION__ = "0.0.40"
 __all__ = ("create",)

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer/calibrator/calibrator_router.py

@@ -78,7 +78,9 @@ class CalibratorRouter(Calibrator):
     ) -> Self:
         # pylint: disable=no-else-return
         calibrator: Calibrator | None = None
-        if determine_model_type(df) == ModelType.REGRESSION:
+        if y is None:
+            raise ValueError("y is null")
+        if determine_model_type(y) == ModelType.REGRESSION:
             calibrator = MAPIECalibrator(self._model)
         else:
             calibrator = VennabersCalibrator(self._model)

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer/calibrator/vennabers_calibrator.py

@@ -1,5 +1,6 @@
 """A calibrator that implements venn abers."""
 
+import logging
 import os
 from typing import Self
 
@@ -54,7 +55,11 @@ class VennabersCalibrator(Calibrator):
         prob_columns = [
             x for x in df.columns.values if x.startswith(PROBABILITY_COLUMN_PREFIX)
         ]
-        vennabers.fit(df[prob_columns].to_numpy(), y.to_numpy())
+        try:
+            vennabers.fit(df[prob_columns].to_numpy(), y.to_numpy())
+        except IndexError:
+            logging.error(df)
+            raise
         return self
 
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:

wavetrainer-0.0.40/wavetrainer/model/catboost/__init__.py

@@ -0,0 +1 @@
+"""The wavetrain catboost model module."""

{wavetrainer-0.0.39/wavetrainer/model → wavetrainer-0.0.40/wavetrainer/model/catboost}/catboost_model.py

@@ -10,12 +10,12 @@ import pandas as pd
 import torch
 from catboost import CatBoost, Pool  # type: ignore
 
-from ..model_type import ModelType, determine_model_type
+from ...model_type import ModelType, determine_model_type
+from ..model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
 from .catboost_classifier_wrap import CatBoostClassifierWrapper
 from .catboost_kwargs import (CAT_FEATURES_ARG_KEY, EVAL_SET_ARG_KEY,
                               ORIGINAL_X_ARG_KEY)
 from .catboost_regressor_wrap import CatBoostRegressorWrapper
-from .model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
 
 _MODEL_FILENAME = "model.cbm"
 _MODEL_PARAMS_FILENAME = "model_params.json"
@@ -222,7 +222,7 @@ class CatboostModel(Model):
                 "Creating catboost model with depth %d, boosting type %s, best iteration %d",
                 self._depth,
                 self._boosting_type,
-                best_iteration,
+                -1 if best_iteration is None else best_iteration,
             )
             match self._model_type:
                 case ModelType.BINARY:

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer/model/model_router.py

@@ -7,15 +7,17 @@ from typing import Any, Self
 import optuna
 import pandas as pd
 
-from .catboost_model import CatboostModel
+from .catboost.catboost_model import CatboostModel
 from .model import Model
-from .tabpfn_model import TabPFNModel
+from .tabpfn.tabpfn_model import TabPFNModel
+from .xgboost.xgboost_model import XGBoostModel
 
 _MODEL_ROUTER_FILE = "model_router.json"
 _MODEL_KEY = "model"
 _MODELS = {
     CatboostModel.name(): CatboostModel,
     TabPFNModel.name(): TabPFNModel,
+    XGBoostModel.name(): XGBoostModel,
 }
 
 

wavetrainer-0.0.40/wavetrainer/model/tabpfn/__init__.py

@@ -0,0 +1 @@
+"""The wavetrain tabpfn model module."""

{wavetrainer-0.0.39/wavetrainer/model → wavetrainer-0.0.40/wavetrainer/model/tabpfn}/tabpfn_model.py

@@ -14,9 +14,9 @@ import torch
 from tabpfn_extensions.post_hoc_ensembles.sklearn_interface import (  # type: ignore
     AutoTabPFNClassifier, AutoTabPFNRegressor)
 
-from ..exceptions import WavetrainException
-from ..model_type import ModelType, determine_model_type
-from .model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
+from ...exceptions import WavetrainException
+from ...model_type import ModelType, determine_model_type
+from ..model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
 
 _MODEL_FILENAME = "model.pkl"
 _MODEL_PARAMS_FILENAME = "model_params.json"

wavetrainer-0.0.40/wavetrainer/model/xgboost/__init__.py

@@ -0,0 +1 @@
+"""The wavetrain xgboost model module."""

wavetrainer-0.0.40/wavetrainer/model/xgboost/early_stopper.py

@@ -0,0 +1,16 @@
+"""A callback function for early stopping."""
+
+from typing import Any
+
+from xgboost.callback import EarlyStopping, TrainingCallback
+
+
+class XGBoostEarlyStoppingCallback(EarlyStopping):
+    """A callback for early stopping in XGBoost models."""
+
+    def after_iteration(
+        self, model: Any, epoch: int, evals_log: TrainingCallback.EvalsLog
+    ) -> bool:
+        if len(evals_log.keys()) < 1:
+            return False
+        return super().after_iteration(model, epoch, evals_log)

wavetrainer-0.0.40/wavetrainer/model/xgboost/xgboost_logger.py

@@ -0,0 +1,23 @@
+"""An XGBoost callback class for logging epochs."""
+
+from typing import Any
+
+from xgboost.callback import TrainingCallback
+
+
+class XGBoostEpochsLogger(TrainingCallback):
+    """Log the epochs in XGBoost."""
+
+    def after_iteration(
+        self, model: Any, epoch: int, evals_log: TrainingCallback.EvalsLog
+    ) -> bool:
+        if epoch % 100 != 0:
+            return False
+        log_items = []
+        for dataset, metrics in evals_log.items():
+            for metric_name, values in metrics.items():
+                current_val = values[-1]
+                log_items.append(f"{dataset}-{metric_name}: {current_val:.5f}")
+
+        print(f"XGBoost: [{epoch}] " + " | ".join(log_items))
+        return False

wavetrainer-0.0.40/wavetrainer/model/xgboost/xgboost_model.py

@@ -0,0 +1,277 @@
+"""A model that wraps xgboost."""
+# pylint: disable=duplicate-code,too-many-arguments,too-many-positional-arguments,too-many-instance-attributes
+
+import json
+import os
+from typing import Any, Self
+
+import optuna
+import pandas as pd
+import torch
+from xgboost import XGBClassifier, XGBRegressor
+from xgboost.callback import TrainingCallback
+
+from ...model_type import ModelType, determine_model_type
+from ..model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
+from .early_stopper import XGBoostEarlyStoppingCallback
+from .xgboost_logger import XGBoostEpochsLogger
+
+_MODEL_FILENAME = "xgboost_model.json"
+_MODEL_PARAMS_FILENAME = "xgboost_model_params.json"
+_MODEL_TYPE_KEY = "model_type"
+_BEST_ITERATION_KEY = "best_iteration"
+
+
+def _convert_categoricals(input_df: pd.DataFrame) -> pd.DataFrame:
+    output_df = input_df.copy()
+    for col in input_df.select_dtypes(include=["category"]).columns:
+        output_df[col] = output_df[col].cat.codes
+    return output_df
+
+
+class XGBoostModel(Model):
+    """A class that uses XGBoost as a model."""
+
+    _xgboost: XGBRegressor | XGBClassifier | None
+    _model_type: None | ModelType
+    _booster: str | None
+    _lambda: float | None
+    _alpha: float | None
+    _subsample: float | None
+    _colsample_bytree: float | None
+    _max_depth: int | None
+    _min_child_weight: int | None
+    _eta: float | None
+    _gamma: float | None
+    _grow_policy: str | None
+    _sample_type: str | None
+    _normalize_type: str | None
+    _rate_drop: float | None
+    _skip_drop: float | None
+    _num_boost_rounds: int | None
+    _early_stopping_rounds: int | None
+    _best_iteration: int | None
+
+    @classmethod
+    def name(cls) -> str:
+        return "xgboost"
+
+    @classmethod
+    def supports_x(cls, df: pd.DataFrame) -> bool:
+        return True
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._xgboost = None
+        self._model_type = None
+        self._booster = None
+        self._lambda = None
+        self._alpha = None
+        self._subsample = None
+        self._colsample_bytree = None
+        self._max_depth = None
+        self._min_child_weight = None
+        self._eta = None
+        self._gamma = None
+        self._grow_policy = None
+        self._sample_type = None
+        self._normalize_type = None
+        self._rate_drop = None
+        self._skip_drop = None
+        self._num_boost_rounds = None
+        self._early_stopping_rounds = None
+        self._best_iteration = None
+
+    @property
+    def estimator(self) -> Any:
+        return self._provide_xgboost()
+
+    @property
+    def supports_importances(self) -> bool:
+        return True
+
+    @property
+    def feature_importances(self) -> dict[str, float]:
+        bst = self._provide_xgboost()
+        return bst.get_score(importance_type="weight")  # type: ignore
+
+    def pre_fit(
+        self,
+        df: pd.DataFrame,
+        y: pd.Series | pd.DataFrame | None,
+        eval_x: pd.DataFrame | None = None,
+        eval_y: pd.Series | pd.DataFrame | None = None,
+        w: pd.Series | None = None,
+    ):
+        if y is None:
+            raise ValueError("y is null.")
+        self._model_type = determine_model_type(y)
+        return {
+            "eval_set": (eval_x, eval_y),
+            "sample_weight": w,
+        }
+
+    def set_options(
+        self, trial: optuna.Trial | optuna.trial.FrozenTrial, df: pd.DataFrame
+    ) -> None:
+        self._booster = trial.suggest_categorical(
+            "booster", ["gbtree", "gblinear", "dart"]
+        )
+        self._lambda = trial.suggest_float("lambda", 1e-8, 1.0, log=True)
+        self._alpha = trial.suggest_float("alpha", 1e-8, 1.0, log=True)
+        self._subsample = trial.suggest_float("subsample", 0.2, 1.0)
+        self._colsample_bytree = trial.suggest_float("colsample_bytree", 0.2, 1.0)
+        if self._booster in ["gbtree", "dart"]:
+            self._max_depth = trial.suggest_int("max_depth", 3, 9, step=2)
+            self._min_child_weight = trial.suggest_int(
+                "min_child_weight", 2, 10, log=True
+            )
+            self._eta = trial.suggest_float("eta", 1e-8, 1.0, log=True)
+            self._gamma = trial.suggest_float("gamma", 1e-8, 1.0, log=True)
+            self._grow_policy = trial.suggest_categorical(
+                "grow_policy", ["depthwise", "lossguide"]
+            )
+        else:
+            self._sample_type = trial.suggest_categorical(
+                "sample_type", ["uniform", "weighted"]
+            )
+            self._normalize_type = trial.suggest_categorical(
+                "normalize_type", ["tree", "forest"]
+            )
+            self._rate_drop = trial.suggest_float("rate_drop", 1e-8, 1.0, log=True)
+            self._skip_drop = trial.suggest_float("skip_drop", 1e-8, 1.0, log=True)
+        self._num_boost_rounds = trial.suggest_int("num_boost_rounds", 100, 10000)
+        self._early_stopping_rounds = trial.suggest_int(
+            "early_stopping_rounds", 50, 500
+        )
+        self._best_iteration = trial.user_attrs.get(_BEST_ITERATION_KEY)
+
+    def load(self, folder: str) -> None:
+        with open(
+            os.path.join(folder, _MODEL_PARAMS_FILENAME), encoding="utf8"
+        ) as handle:
+            params = json.load(handle)
+            self._model_type = ModelType(params[_MODEL_TYPE_KEY])
+            self._best_iteration = params.get(_BEST_ITERATION_KEY)
+        bst = self._provide_xgboost()
+        bst.load_model(os.path.join(folder, _MODEL_FILENAME))
+
+    def save(self, folder: str, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
+        bst = self._provide_xgboost()
+        bst.save_model(os.path.join(folder, _MODEL_FILENAME))
+        with open(
+            os.path.join(folder, _MODEL_PARAMS_FILENAME), "w", encoding="utf8"
+        ) as handle:
+            json.dump(
+                {
+                    _MODEL_TYPE_KEY: str(self._model_type),
+                    _BEST_ITERATION_KEY: self._best_iteration,
+                },
+                handle,
+            )
+        trial.set_user_attr(_BEST_ITERATION_KEY, self._best_iteration)
+
+    def fit(
+        self,
+        df: pd.DataFrame,
+        y: pd.Series | pd.DataFrame | None = None,
+        w: pd.Series | None = None,
+        eval_x: pd.DataFrame | None = None,
+        eval_y: pd.Series | pd.DataFrame | None = None,
+    ) -> Self:
+        if y is None:
+            raise ValueError("y is null.")
+        self._model_type = determine_model_type(y)
+        xgboost = self._provide_xgboost()
+        df = _convert_categoricals(df)
+        evals = [(df, y)]
+        if eval_x is not None and eval_y is not None and self._best_iteration is None:
+            eval_x = _convert_categoricals(eval_x)
+            evals.append((eval_x, eval_y))
+        xgboost.fit(  # type: ignore
+            df,
+            y,
+            eval_set=evals,
+            sample_weight=w,
+            verbose=False,
+        )
+        return self
+
+    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        x_df = _convert_categoricals(df)
+        xgboost = self._provide_xgboost()
+        pred = xgboost.predict(x_df)
+        df = pd.DataFrame(
+            index=df.index,
+            data={
+                PREDICTION_COLUMN: pred.flatten(),
+            },
+        )
+        if self._model_type != ModelType.REGRESSION:
+            proba = xgboost.predict_proba(x_df)  # type: ignore
+            for i in range(proba.shape[1]):
+                df[f"{PROBABILITY_COLUMN_PREFIX}{i}"] = proba[:, i]
+        return df
+
+    def _provide_xgboost(self) -> XGBClassifier | XGBRegressor:
+        xgboost = self._xgboost
+        if xgboost is None:
+            callbacks: list[TrainingCallback] = [
+                XGBoostEpochsLogger(),
+            ]
+            if self._best_iteration is not None:
+                callbacks.append(
+                    XGBoostEarlyStoppingCallback(rounds=self._early_stopping_rounds)
+                )
+            param = {
+                "objective": "binary:logistic",
+                "tree_method": "gpu_hist" if torch.cuda.is_available() else "exact",
+                # defines booster, gblinear for linear functions.
+                "booster": self._booster,
+                # L2 regularization weight.
+                "reg_lambda": self._lambda,
+                # L1 regularization weight.
+                "alpha": self._alpha,
+                # sampling ratio for training data.
+                "subsample": self._subsample,
+                # sampling according to each tree.
+                "colsample_bytree": self._colsample_bytree,
+                "n_estimators": self._best_iteration
+                if self._best_iteration is not None
+                else self._num_boost_rounds,
+                "base_score": 0.5,
+                "verbosity": 0,
+                "verbose": False,
+                "callbacks": callbacks,
+                "eval_metric": ["logloss", "error"],
+            }
+            if param["booster"] in ["gbtree", "dart"]:
+                # maximum depth of the tree, signifies complexity of the tree.
+                param["max_depth"] = self._max_depth
+                # minimum child weight, larger the term more conservative the tree.
+                param["min_child_weight"] = self._min_child_weight
+                param["eta"] = self._eta
+                # defines how selective algorithm is.
+                param["gamma"] = self._gamma
+                param["grow_policy"] = self._grow_policy
+
+            if param["booster"] == "dart":
+                param["sample_type"] = self._sample_type
+                param["normalize_type"] = self._normalize_type
+                param["rate_drop"] = self._rate_drop
+                param["skip_drop"] = self._skip_drop
+            match self._model_type:
+                case ModelType.BINARY:
+                    xgboost = XGBClassifier(**param)
+                case ModelType.REGRESSION:
+                    param["objective"] = "reg:squarederror"
+                    param["eval_metric"] = ["rmse", "mae"]
+                    xgboost = XGBRegressor(**param)
+                case ModelType.BINNED_BINARY:
+                    xgboost = XGBClassifier(**param)
+                case ModelType.MULTI_CLASSIFICATION:
+                    xgboost = XGBClassifier(**param)
+            self._xgboost = xgboost
+        if xgboost is None:
+            raise ValueError("xgboost is null")
+        return xgboost

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer/reducer/nonnumeric_reducer.py

@@ -41,5 +41,6 @@ class NonNumericReducer(Reducer):
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:
         categorical_cols = df.select_dtypes(include="category").columns.tolist()
         numeric_cols = df.select_dtypes(include="number").columns.tolist()
-        keep_cols = categorical_cols + numeric_cols
+        boolean_cols = df.select_dtypes(include="bool").columns.tolist()
+        keep_cols = categorical_cols + numeric_cols + boolean_cols
         return df[keep_cols]

{wavetrainer-0.0.39 → wavetrainer-0.0.40/wavetrainer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.39
+Version: 0.0.40
 Summary: A library for automatically finding the optimal model within feature and hyperparameter space.
 Home-page: https://github.com/8W9aG/wavetrainer
 Author: Will Sackfield
@@ -24,10 +24,8 @@ Requires-Dist: mapie>=0.9.2
 Requires-Dist: pytz>=2025.1
 Requires-Dist: torch>=2.6.0
 Requires-Dist: tabpfn>=2.0.6
-Requires-Dist: tabpfn-extensions>=0.0.4
-Requires-Dist: shap>=0.47.2
-Requires-Dist: hyperopt>=0.2.7
 Requires-Dist: pytest-is-running>=1.5.1
+Requires-Dist: xgboost>=3.0.0
 
 # wavetrainer
 
@@ -58,10 +56,8 @@ Python 3.11.6:
 - [pytz](https://pythonhosted.org/pytz/)
 - [torch](https://pytorch.org/)
 - [tabpfn](https://github.com/PriorLabs/TabPFN)
-- [tabpfn-extensions](https://github.com/PriorLabs/tabpfn-extensions)
-- [shap](https://shap.readthedocs.io/en/latest/)
-- [hyperopt](https://hyperopt.github.io/hyperopt/)
 - [pytest-is-running](https://github.com/adamchainz/pytest-is-running)
+- [xgboost](https://xgboost.readthedocs.io/en/release_3.0.0/)
 
 ## Raison D'être :thought_balloon:
 

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer.egg-info/SOURCES.txt

@@ -26,13 +26,19 @@ wavetrainer/calibrator/calibrator_router.py
 wavetrainer/calibrator/mapie_calibrator.py
 wavetrainer/calibrator/vennabers_calibrator.py
 wavetrainer/model/__init__.py
-wavetrainer/model/catboost_classifier_wrap.py
-wavetrainer/model/catboost_kwargs.py
-wavetrainer/model/catboost_model.py
-wavetrainer/model/catboost_regressor_wrap.py
 wavetrainer/model/model.py
 wavetrainer/model/model_router.py
-wavetrainer/model/tabpfn_model.py
+wavetrainer/model/catboost/__init__.py
+wavetrainer/model/catboost/catboost_classifier_wrap.py
+wavetrainer/model/catboost/catboost_kwargs.py
+wavetrainer/model/catboost/catboost_model.py
+wavetrainer/model/catboost/catboost_regressor_wrap.py
+wavetrainer/model/tabpfn/__init__.py
+wavetrainer/model/tabpfn/tabpfn_model.py
+wavetrainer/model/xgboost/__init__.py
+wavetrainer/model/xgboost/early_stopper.py
+wavetrainer/model/xgboost/xgboost_logger.py
+wavetrainer/model/xgboost/xgboost_model.py
 wavetrainer/reducer/__init__.py
 wavetrainer/reducer/base_selector_reducer.py
 wavetrainer/reducer/combined_reducer.py

{wavetrainer-0.0.39 → wavetrainer-0.0.40}/wavetrainer.egg-info/requires.txt

@@ -11,7 +11,5 @@ mapie>=0.9.2
 pytz>=2025.1
 torch>=2.6.0
 tabpfn>=2.0.6
-tabpfn-extensions>=0.0.4
-shap>=0.47.2
-hyperopt>=0.2.7
 pytest-is-running>=1.5.1
+xgboost>=3.0.0