wavetrainer 0.0.38__tar.gz → 0.0.40__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.38
+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.38 → 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.38 → 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.38 → wavetrainer-0.0.40}/setup.py

@@ -23,7 +23,7 @@ def install_requires() -> typing.List[str]:
 
 setup(
     name='wavetrainer',
-    version='0.0.38',
+    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.38 → 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.38 → 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.38 → wavetrainer-0.0.40}/wavetrainer/__init__.py

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

{wavetrainer-0.0.38 → 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.38 → 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.38/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"
@@ -148,7 +148,7 @@ class CatboostModel(Model):
             )
         catboost = self._provide_catboost()
         catboost.save_model(os.path.join(folder, _MODEL_FILENAME))
-        trial.user_attrs[_BEST_ITERATION_KEY] = self._best_iteration
+        trial.set_user_attr(_BEST_ITERATION_KEY, self._best_iteration)
 
     def fit(
         self,
@@ -219,9 +219,10 @@ class CatboostModel(Model):
                 best_iteration if best_iteration is not None else self._iterations
             )
             logging.info(
-                "Creating catboost model with depth %d, boosting type %s",
+                "Creating catboost model with depth %d, boosting type %s, best iteration %d",
                 self._depth,
                 self._boosting_type,
+                -1 if best_iteration is None else best_iteration,
             )
             match self._model_type:
                 case ModelType.BINARY:

{wavetrainer-0.0.38 → 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.38/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.38 → wavetrainer-0.0.40}/wavetrainer/reducer/combined_reducer.py

@@ -3,6 +3,7 @@
 import json
 import logging
 import os
+import time
 from typing import Self
 
 import optuna
@@ -37,7 +38,7 @@ class CombinedReducer(Reducer):
             DuplicateReducer(),
             CorrelationReducer(),
             SmartCorrelationReducer(),
-            SelectBySingleFeaturePerformanceReducer(),
+            # SelectBySingleFeaturePerformanceReducer(),
         ]
         self._folder = None
 
@@ -99,12 +100,16 @@ class CombinedReducer(Reducer):
     ) -> Self:
         removed_columns_dict = {}
         for reducer in self._reducers:
+            start_reducer = time.time()
             before_columns = set(df.columns.values)
             df = reducer.fit_transform(df, y=y)
             after_columns = set(df.columns.values)
             removed_columns = before_columns.difference(after_columns)
             if removed_columns:
                 removed_columns_dict[reducer.name()] = list(removed_columns)
+            logging.info(
+                "%s reducer took %f", reducer.name(), time.time() - start_reducer
+            )
         if self._folder is not None:
             with open(
                 os.path.join(self._folder, _REMOVED_COLUMNS_FILE), encoding="utf8"

{wavetrainer-0.0.38 → 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.38 → wavetrainer-0.0.40}/wavetrainer/reducer/select_by_single_feature_performance_reducer.py

@@ -1,5 +1,6 @@
 """A reducer that removes features by their single performance via further heuristics."""
 
+# pylint: disable=too-many-arguments,too-many-positional-arguments
 from typing import Self
 
 import optuna
@@ -7,8 +8,8 @@ import pandas as pd
 from feature_engine.selection import SelectBySingleFeaturePerformance
 from sklearn.ensemble import RandomForestClassifier  # type: ignore
 
-from .base_selector_reducer import BaseSelectorReducer
 from ..model_type import ModelType, determine_model_type
+from .base_selector_reducer import BaseSelectorReducer
 
 _SINGLE_FEATURE_PERFORMANCE_REDUCER_FILENAME = (
     "single_feature_performance_reducer.joblib"
@@ -23,7 +24,7 @@ class SelectBySingleFeaturePerformanceReducer(BaseSelectorReducer):
 
     def __init__(self) -> None:
         self._singlefeatureperformance_selector = SelectBySingleFeaturePerformance(
-            RandomForestClassifier(random_state=42), scoring="accuracy"
+            RandomForestClassifier(random_state=42, n_jobs=-1), scoring="accuracy", cv=1
         )
         super().__init__(
             self._singlefeatureperformance_selector,
@@ -53,5 +54,7 @@ class SelectBySingleFeaturePerformanceReducer(BaseSelectorReducer):
         eval_x: pd.DataFrame | None = None,
         eval_y: pd.Series | pd.DataFrame | None = None,
     ) -> Self:
-        self._singlefeatureperformance_selector.scoring = "r2" if determine_model_type(y) == ModelType.REGRESSION else "accuracy"
+        self._singlefeatureperformance_selector.scoring = (
+            "r2" if determine_model_type(y) == ModelType.REGRESSION else "accuracy"  # type: ignore
+        )
         return super().fit(df, y=y, w=w, eval_x=eval_x, eval_y=eval_y)

{wavetrainer-0.0.38 → wavetrainer-0.0.40}/wavetrainer/trainer.py

@@ -6,6 +6,7 @@ import json
 import logging
 import os
 import pickle
+import time
 from typing import Self
 
 import optuna
@@ -231,6 +232,7 @@ class Trainer(Fit):
 
                 try:
                     # Window the data
+                    start_windower = time.time()
                     windower = Windower(self._dt_column)
                     windower.set_options(trial, x)
                     x_train = windower.fit_transform(x_train)
@@ -240,25 +242,31 @@ class Trainer(Fit):
                             os.removedirs(folder)
                         logging.warning("Y train only contains 1 unique datapoint.")
                         return _BAD_OUTPUT
+                    logging.info("Windowing took %f", time.time() - start_windower)
 
                     # Perform common reductions
+                    start_reducer = time.time()
                     reducer = CombinedReducer()
                     reducer.set_options(trial, x)
                     x_train = reducer.fit_transform(x_train, y=y_train)
                     x_test = reducer.transform(x_test)
+                    logging.info("Reducing took %f", time.time() - start_reducer)
 
                     # Calculate the row weights
+                    start_row_weights = time.time()
                     weights = CombinedWeights()
                     weights.set_options(trial, x)
                     w = weights.fit(x_train, y=y_train).transform(y_train.to_frame())[
                         WEIGHTS_COLUMN
                     ]
+                    logging.info("Row weights took %f", time.time() - start_row_weights)
 
                     # Create model
                     model = ModelRouter()
                     model.set_options(trial, x)
 
                     # Train
+                    start_train = time.time()
                     selector = Selector(model)
                     selector.set_options(trial, x)
                     selector.fit(x_train, y=y_train, w=w, eval_x=x_test, eval_y=y_test)
@@ -267,11 +275,14 @@ class Trainer(Fit):
                     x_pred = model.fit_transform(
                         x_train, y=y_train, w=w, eval_x=x_test, eval_y=y_test
                     )
+                    logging.info("Training took %f", time.time() - start_train)
 
                     # Calibrate
+                    start_calibrate = time.time()
                     calibrator = CalibratorRouter(model)
                     calibrator.set_options(trial, x)
                     calibrator.fit(x_pred, y=y_train)
+                    logging.info("Calibrating took %f", time.time() - start_calibrate)
 
                     # Output
                     y_pred = model.transform(x_test)
@@ -521,8 +532,11 @@ class Trainer(Fit):
                 date_path = os.path.join(column_path, date_str)
                 if not os.path.isdir(date_path):
                     continue
-                model = ModelRouter()
-                model.load(date_path)
-                feature_importances[date_str] = model.feature_importances
+                try:
+                    model = ModelRouter()
+                    model.load(date_path)
+                    feature_importances[date_str] = model.feature_importances
+                except FileNotFoundError as exc:
+                    logging.warning(str(exc))
 
         return feature_importances

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.38
+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.38 → 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.38 → 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