wavetrainer 0.0.45__tar.gz → 0.0.46__tar.gz

{wavetrainer-0.0.45/wavetrainer.egg-info → wavetrainer-0.0.46}/PKG-INFO

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

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

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

{wavetrainer-0.0.45 → wavetrainer-0.0.46}/wavetrainer/create.py

@@ -15,6 +15,7 @@ def create(
     dt_column: str | None = None,
     max_train_timeout: datetime.timedelta | None = None,
     cutoff_dt: datetime.datetime | None = None,
+    embedding_cols: list[list[str]] | None = None,
 ) -> Trainer:
     """Create a trainer."""
     return Trainer(
@@ -25,4 +26,5 @@ def create(
         dt_column=dt_column,
         max_train_timeout=max_train_timeout,
         cutoff_dt=cutoff_dt,
+        embedding_cols=embedding_cols,
     )

{wavetrainer-0.0.45 → wavetrainer-0.0.46}/wavetrainer/model/model_router.py

@@ -81,11 +81,11 @@ class ModelRouter(Model):
     def set_options(
         self, trial: optuna.Trial | optuna.trial.FrozenTrial, df: pd.DataFrame
     ) -> None:
-        model = _MODELS[
-            trial.suggest_categorical(
-                "model", [k for k, v in _MODELS.items() if v.supports_x(df)]
-            )
-        ]()
+        model_name = trial.suggest_categorical(
+            "model", [k for k, v in _MODELS.items() if v.supports_x(df)]
+        )
+        print(f"Using {model_name} model")
+        model = _MODELS[model_name]()
         model.set_options(trial, df)
         self._model = model
 

{wavetrainer-0.0.45 → wavetrainer-0.0.46}/wavetrainer/model/xgboost/xgboost_model.py

@@ -109,7 +109,9 @@ class XGBoostModel(Model):
     def feature_importances(self) -> dict[str, float]:
         bst = self._provide_xgboost()
         try:
-            return bst.get_booster().get_score(importance_type="weight")  # type: ignore
+            score_dict = bst.get_booster().get_score(importance_type="weight")  # type: ignore
+            total = sum(score_dict.values())  # type: ignore
+            return {k: v / total for k, v in score_dict.items()}  # type: ignore
         except XGBoostError as exc:
             print(str(exc))
             return {}

{wavetrainer-0.0.45 → wavetrainer-0.0.46}/wavetrainer/reducer/combined_reducer.py

@@ -14,6 +14,7 @@ from .constant_reducer import ConstantReducer
 from .correlation_reducer import CorrelationReducer
 from .duplicate_reducer import DuplicateReducer
 from .nonnumeric_reducer import NonNumericReducer
+from .pca_reducer import PCAReducer
 from .reducer import Reducer
 from .select_by_single_feature_performance_reducer import \
     SelectBySingleFeaturePerformanceReducer
@@ -29,12 +30,14 @@ class CombinedReducer(Reducer):
     """A reducer that combines a series of reducers."""
 
     # pylint: disable=too-many-positional-arguments,too-many-arguments
+    _folder: str | None
 
-    def __init__(self):
+    def __init__(self, embedding_cols: list[list[str]] | None):
         super().__init__()
         self._reducers = [
             UnseenReducer(),
             NonNumericReducer(),
+            PCAReducer(embedding_cols),
             ConstantReducer(),
             DuplicateReducer(),
             CorrelationReducer(),
@@ -42,6 +45,7 @@ class CombinedReducer(Reducer):
             # SelectBySingleFeaturePerformanceReducer(),
         ]
         self._folder = None
+        self._embedding_cols = embedding_cols
 
     @classmethod
     def name(cls) -> str:
@@ -74,6 +78,8 @@ class CombinedReducer(Reducer):
                     self._reducers.append(SmartCorrelationReducer())
                 elif reducer_name == SelectBySingleFeaturePerformanceReducer.name():
                     self._reducers.append(SelectBySingleFeaturePerformanceReducer())
+                elif reducer_name == PCAReducer.name():
+                    self._reducers.append(PCAReducer(self._embedding_cols))
         for reducer in self._reducers:
             reducer.load(folder)
         self._folder = folder

wavetrainer-0.0.46/wavetrainer/reducer/pca_reducer.py

@@ -0,0 +1,78 @@
+"""A reducer that reduces embeddings using PCA."""
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+import hashlib
+import os
+from typing import Self
+
+import joblib  # type: ignore
+import optuna
+import pandas as pd
+from sklearn.decomposition import PCA  # type: ignore
+
+from .reducer import Reducer
+
+_PCA_THRESHOLD = "pca_threshold"
+
+
+class PCAReducer(Reducer):
+    """A class that reduces embeddings using PCA."""
+
+    _pcas: dict[str, PCA]
+
+    @classmethod
+    def name(cls) -> str:
+        return "pca"
+
+    def __init__(self, embedding_cols: list[list[str]] | None):
+        super().__init__()
+        self._embedding_cols = embedding_cols if embedding_cols is not None else []
+        self._pcas = {}
+
+    @property
+    def _embedding_dict(self) -> dict[str, list[str]]:
+        return {
+            hashlib.sha256("|".join(sorted(x)).encode()).hexdigest(): x
+            for x in self._embedding_cols
+        }
+
+    def set_options(
+        self, trial: optuna.Trial | optuna.trial.FrozenTrial, df: pd.DataFrame
+    ) -> None:
+        if self._embedding_cols is None:
+            return
+        threshold = trial.suggest_float(_PCA_THRESHOLD, 0.7, 0.99)
+        self._pcas = {k: PCA(n_components=threshold) for k in self._embedding_dict}
+
+    def load(self, folder: str) -> None:
+        for k in self._embedding_dict:
+            self._pcas[k] = joblib.load(os.path.join(folder, f"{k}_pca_reducer.joblib"))
+
+    def save(self, folder: str, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
+        for k, v in self._pcas.items():
+            joblib.dump(v, os.path.join(folder, f"{k}_pca_reducer.joblib"))
+
+    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 self._embedding_cols is None:
+            return self
+        for k, v in self._pcas.items():
+            v.fit(df[self._embedding_dict[k]])
+        return self
+
+    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        if self._embedding_cols is None:
+            return df
+        for k, v in self._pcas.items():
+            cols = self._embedding_dict[k]
+            compressed_embedding = v.transform(df[cols])
+            embedding_len = compressed_embedding.shape[0]
+            df[cols[:embedding_len]] = compressed_embedding
+            df = df.drop(columns=cols[embedding_len:])
+        return df

{wavetrainer-0.0.45 → wavetrainer-0.0.46}/wavetrainer/selector/selector.py

@@ -83,18 +83,18 @@ class Selector(Params, Fit):
                 current_features = [list(feature_importances.keys())[0]]
             current_features = current_features[:required_features]
             print(
-                f"Current Features:\n{pd.Series(data=list(feature_importances.values()), index=list(feature_importances.keys()))}\n"
+                f"Current Features:\n{pd.Series(data=[feature_importances[x] for x in current_features], index=current_features)}\n"
             )
 
         n_features = len(current_features)
         for i in range(self._steps):
-            print(
-                f"Recursive Feature Elimination Step {i}, current features: {len(current_features)}"
-            )
             ratio_diff = 1.0 - self._feature_ratio
             ratio_step = ratio_diff / float(self._steps)
             current_ratio = 1.0 - (ratio_step * i)
             n_features = max(1, int(total_columns * current_ratio))
+            print(
+                f"Recursive Feature Elimination Step {i}, current features: {len(current_features)} required features: {n_features}"
+            )
             if n_features >= len(current_features):
                 continue
 

{wavetrainer-0.0.45 → wavetrainer-0.0.46}/wavetrainer/trainer.py

@@ -63,6 +63,7 @@ class Trainer(Fit):
         dt_column: str | None = None,
         max_train_timeout: datetime.timedelta | None = None,
         cutoff_dt: datetime.datetime | None = None,
+        embedding_cols: list[list[str]] | None = None,
     ):
         tqdm.tqdm.pandas()
 
@@ -153,6 +154,7 @@ class Trainer(Fit):
         self._dt_column = dt_column
         self._max_train_timeout = max_train_timeout
         self._cutoff_dt = cutoff_dt
+        self._embedding_cols = embedding_cols
 
     def _provide_study(self, column: str) -> optuna.Study:
         storage_name = f"sqlite:///{self._folder}/{column}/{_STUDYDB_FILENAME}"
@@ -247,7 +249,7 @@ class Trainer(Fit):
 
                     # Perform common reductions
                     start_reducer = time.time()
-                    reducer = CombinedReducer()
+                    reducer = CombinedReducer(self._embedding_cols)
                     reducer.set_options(trial, x)
                     x_train = reducer.fit_transform(x_train, y=y_train)
                     x_test = reducer.transform(x_test)
@@ -415,7 +417,14 @@ class Trainer(Fit):
                         break
                 if found:
                     last_processed_dt = test_dt
-                    _fit(study.best_trial, test_df, test_series, True, test_idx, True)
+                    _fit(
+                        study.best_trial,
+                        test_df.copy(),
+                        test_series,
+                        True,
+                        test_idx,
+                        True,
+                    )
                     continue
                 if (
                     last_processed_dt is not None
@@ -431,7 +440,7 @@ class Trainer(Fit):
                     def validate_objctive(
                         trial: optuna.Trial, idx: datetime.datetime, series: pd.Series
                     ) -> float:
-                        return _fit(trial, test_df, series, False, idx, False)
+                        return _fit(trial, test_df.copy(), series, False, idx, False)
 
                     study.optimize(
                         functools.partial(
@@ -445,7 +454,9 @@ class Trainer(Fit):
                 else:
                     break
 
-                _fit(study.best_trial, test_df, test_series, True, test_idx, True)
+                _fit(
+                    study.best_trial, test_df.copy(), test_series, True, test_idx, True
+                )
                 last_processed_dt = test_idx
 
         if isinstance(y, pd.Series):
@@ -503,7 +514,7 @@ class Trainer(Fit):
                 date_str = dates[-1].isoformat()
                 folder = os.path.join(column_path, date_str)
 
-                reducer = CombinedReducer()
+                reducer = CombinedReducer(self._embedding_cols)
                 reducer.load(folder)
 
                 model = ModelRouter()

{wavetrainer-0.0.45 → wavetrainer-0.0.46/wavetrainer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavetrainer
-Version: 0.0.45
+Version: 0.0.46
 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.45 → wavetrainer-0.0.46}/wavetrainer.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ wavetrainer/reducer/correlation_reducer.py
 wavetrainer/reducer/duplicate_reducer.py
 wavetrainer/reducer/non_categorical_numeric_columns.py
 wavetrainer/reducer/nonnumeric_reducer.py
+wavetrainer/reducer/pca_reducer.py
 wavetrainer/reducer/reducer.py
 wavetrainer/reducer/select_by_single_feature_performance_reducer.py
 wavetrainer/reducer/smart_correlation_reducer.py