wavetrainer 0.0.37__tar.gz → 0.0.39__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.37
+Version: 0.0.39
 Summary: A library for automatically finding the optimal model within feature and hyperparameter space.
 Home-page: https://github.com/8W9aG/wavetrainer
 Author: Will Sackfield

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

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

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

{wavetrainer-0.0.37 → wavetrainer-0.0.39}/wavetrainer/model/catboost_model.py

@@ -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,
+                best_iteration,
             )
             match self._model_type:
                 case ModelType.BINARY:

{wavetrainer-0.0.37 → wavetrainer-0.0.39}/wavetrainer/model/tabpfn_model.py

@@ -2,6 +2,7 @@
 # pylint: disable=duplicate-code,too-many-arguments,too-many-positional-arguments
 
 import json
+import logging
 import os
 import pickle
 from typing import Any, Self
@@ -13,6 +14,7 @@ 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
 
@@ -104,7 +106,11 @@ class TabPFNModel(Model):
             raise ValueError("y is null.")
         self._model_type = determine_model_type(y)
         tabpfn = self._provide_tabpfn()
-        tabpfn.fit(df, y)
+        try:
+            tabpfn.fit(df, y)
+        except ValueError as exc:
+            logging.warning(str(exc))
+            raise WavetrainException() from exc
         return self
 
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:

{wavetrainer-0.0.37 → wavetrainer-0.0.39}/wavetrainer/reducer/base_selector_reducer.py

@@ -56,8 +56,8 @@ class BaseSelectorReducer(Reducer):
         if len(df.columns) <= 1:
             return self
         try:
-            self._base_selector.fit(df)  # type: ignore
-        except ValueError as exc:
+            self._base_selector.fit(df, y=y)  # type: ignore
+        except (ValueError, AttributeError) as exc:
             logging.warning(str(exc))
             if self.should_raise():
                 raise WavetrainException() from exc
@@ -66,4 +66,10 @@ class BaseSelectorReducer(Reducer):
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:
         if len(df.columns) <= 1:
             return df
-        return self._base_selector.transform(df)
+        try:
+            return self._base_selector.transform(df)
+        except (ValueError, AttributeError) as exc:
+            logging.warning(str(exc))
+            if self.should_raise():
+                raise WavetrainException() from exc
+            return df

{wavetrainer-0.0.37 → wavetrainer-0.0.39}/wavetrainer/reducer/combined_reducer.py

@@ -3,6 +3,7 @@
 import json
 import logging
 import os
+import time
 from typing import Self
 
 import optuna
@@ -13,6 +14,8 @@ from .correlation_reducer import CorrelationReducer
 from .duplicate_reducer import DuplicateReducer
 from .nonnumeric_reducer import NonNumericReducer
 from .reducer import Reducer
+from .select_by_single_feature_performance_reducer import \
+    SelectBySingleFeaturePerformanceReducer
 from .smart_correlation_reducer import SmartCorrelationReducer
 from .unseen_reducer import UnseenReducer
 
@@ -35,6 +38,7 @@ class CombinedReducer(Reducer):
             DuplicateReducer(),
             CorrelationReducer(),
             SmartCorrelationReducer(),
+            # SelectBySingleFeaturePerformanceReducer(),
         ]
         self._folder = None
 
@@ -67,6 +71,8 @@ class CombinedReducer(Reducer):
                     self._reducers.append(UnseenReducer())
                 elif reducer_name == SmartCorrelationReducer.name():
                     self._reducers.append(SmartCorrelationReducer())
+                elif reducer_name == SelectBySingleFeaturePerformanceReducer.name():
+                    self._reducers.append(SelectBySingleFeaturePerformanceReducer())
         for reducer in self._reducers:
             reducer.load(folder)
         self._folder = folder
@@ -94,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)
+            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.39/wavetrainer/reducer/select_by_single_feature_performance_reducer.py

@@ -0,0 +1,60 @@
+"""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
+import pandas as pd
+from feature_engine.selection import SelectBySingleFeaturePerformance
+from sklearn.ensemble import RandomForestClassifier  # type: ignore
+
+from ..model_type import ModelType, determine_model_type
+from .base_selector_reducer import BaseSelectorReducer
+
+_SINGLE_FEATURE_PERFORMANCE_REDUCER_FILENAME = (
+    "single_feature_performance_reducer.joblib"
+)
+_SINGLE_FEATURE_PERFORMANCE_REDUCER_THRESHOLD = (
+    "single_feature_performance_reducer_threshold"
+)
+
+
+class SelectBySingleFeaturePerformanceReducer(BaseSelectorReducer):
+    """A class that removes smart correlated values from a dataset."""
+
+    def __init__(self) -> None:
+        self._singlefeatureperformance_selector = SelectBySingleFeaturePerformance(
+            RandomForestClassifier(random_state=42, n_jobs=-1), scoring="accuracy", cv=1
+        )
+        super().__init__(
+            self._singlefeatureperformance_selector,
+            _SINGLE_FEATURE_PERFORMANCE_REDUCER_FILENAME,
+        )
+
+    @classmethod
+    def name(cls) -> str:
+        return "single_feature_performance"
+
+    @classmethod
+    def should_raise(cls) -> bool:
+        return False
+
+    def set_options(
+        self, trial: optuna.Trial | optuna.trial.FrozenTrial, df: pd.DataFrame
+    ) -> None:
+        self._singlefeatureperformance_selector.threshold = trial.suggest_float(
+            _SINGLE_FEATURE_PERFORMANCE_REDUCER_THRESHOLD, 0.1, 0.9
+        )
+
+    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:
+        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.37 → wavetrainer-0.0.39}/wavetrainer/reducer/smart_correlation_reducer.py

@@ -29,6 +29,10 @@ class SmartCorrelationReducer(BaseSelectorReducer):
     def name(cls) -> str:
         return "smart_correlation"
 
+    @classmethod
+    def should_raise(cls) -> bool:
+        return False
+
     def set_options(
         self, trial: optuna.Trial | optuna.trial.FrozenTrial, df: pd.DataFrame
     ) -> None:

{wavetrainer-0.0.37 → wavetrainer-0.0.39}/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)
+                    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.37 → wavetrainer-0.0.39/wavetrainer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.37
+Version: 0.0.39
 Summary: A library for automatically finding the optimal model within feature and hyperparameter space.
 Home-page: https://github.com/8W9aG/wavetrainer
 Author: Will Sackfield

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

@@ -42,6 +42,7 @@ wavetrainer/reducer/duplicate_reducer.py
 wavetrainer/reducer/non_categorical_numeric_columns.py
 wavetrainer/reducer/nonnumeric_reducer.py
 wavetrainer/reducer/reducer.py
+wavetrainer/reducer/select_by_single_feature_performance_reducer.py
 wavetrainer/reducer/smart_correlation_reducer.py
 wavetrainer/reducer/unseen_reducer.py
 wavetrainer/selector/__init__.py