wavetrainer 0.0.3__tar.gz → 0.0.5__tar.gz

{wavetrainer-0.0.3/wavetrainer.egg-info → wavetrainer-0.0.5}/PKG-INFO

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

@@ -23,7 +23,7 @@ def install_requires() -> typing.List[str]:
 
 setup(
     name='wavetrainer',
-    version='0.0.3',
+    version='0.0.5',
     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.3 → wavetrainer-0.0.5}/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=1), trials=10)
+            trainer = Trainer(tmpdir, walkforward_timedelta=datetime.timedelta(days=7), trials=1)
             x_data = [i for i in range(100)]
             x_index = [datetime.datetime(2022, 1, 1) + datetime.timedelta(days=i) for i in range(len(x_data))]
             df = pd.DataFrame(

wavetrainer-0.0.5/wavetrainer/__init__.py

@@ -0,0 +1,6 @@
+"""The wavetrain main module."""
+
+from .create import create
+
+__VERSION__ = "0.0.5"
+__all__ = ("create",)

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/calibrator/mapie_calibrator.py

@@ -49,12 +49,17 @@ class MAPIECalibrator(Calibrator):
         return self
 
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:
-        alpha = [0.05, 0.32]
-        _, y_pis = self._mapie.predict(df, alpha=alpha)
-        df = pd.DataFrame(data=None, index=df.index)
-        for i in range(y_pis.shape[1]):
-            for ii in range(y_pis.shape[2]):
-                df[f"{PROBABILITY_COLUMN_PREFIX}{alpha[i]}_{ii == 1}"] = (
-                    y_pis[:, i, ii].flatten().tolist()
-                )
+        alpha = []
+        for potential_alpha in [0.05, 0.32]:
+            if len(df) > int(1.0 / potential_alpha):
+                alpha.append(potential_alpha)
+        if alpha:
+            _, y_pis = self._mapie.predict(df, alpha=alpha)
+            for i in range(y_pis.shape[1]):
+                if i >= len(alpha):
+                    continue
+                for ii in range(y_pis.shape[2]):
+                    alpha_val = alpha[i]
+                    values = y_pis[:, i, ii].flatten().tolist()
+                    df[f"{PROBABILITY_COLUMN_PREFIX}{alpha_val}_{ii == 1}"] = values
         return df

wavetrainer-0.0.5/wavetrainer/model/catboost_model.py

@@ -0,0 +1,187 @@
+"""A model that wraps catboost."""
+
+import json
+import os
+from typing import Any, Self
+
+import optuna
+import pandas as pd
+from catboost import CatBoostClassifier  # type: ignore
+from catboost import CatBoost, CatBoostRegressor, Pool
+
+from ..model_type import ModelType, determine_model_type
+from .model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
+
+_MODEL_FILENAME = "model.cbm"
+_MODEL_PARAMS_FILENAME = "model_params.json"
+_ITERATIONS_KEY = "iterations"
+_LEARNING_RATE_KEY = "learning_rate"
+_DEPTH_KEY = "depth"
+_L2_LEAF_REG_KEY = "l2_leaf_reg"
+_BOOSTING_TYPE_KEY = "boosting_type"
+_MODEL_TYPE_KEY = "model_type"
+
+
+class CatboostModel(Model):
+    """A class that uses Catboost as a model."""
+
+    _catboost: CatBoost | None
+    _iterations: None | int
+    _learning_rate: None | float
+    _depth: None | int
+    _l2_leaf_reg: None | float
+    _boosting_type: None | str
+    _model_type: None | ModelType
+
+    @classmethod
+    def name(cls) -> str:
+        return "catboost"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._catboost = None
+        self._iterations = None
+        self._learning_rate = None
+        self._depth = None
+        self._l2_leaf_reg = None
+        self._boosting_type = None
+        self._model_type = None
+
+    @property
+    def estimator(self) -> Any:
+        return self._provide_catboost()
+
+    def pre_fit(self, y: pd.Series | pd.DataFrame | None):
+        if y is None:
+            raise ValueError("y is null.")
+        self._model_type = determine_model_type(y)
+
+    def set_options(self, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
+        self._iterations = trial.suggest_int(_ITERATIONS_KEY, 100, 10000)
+        self._learning_rate = trial.suggest_float(_LEARNING_RATE_KEY, 0.001, 0.3)
+        self._depth = trial.suggest_int(_DEPTH_KEY, 1, 12)
+        self._l2_leaf_reg = trial.suggest_float(_L2_LEAF_REG_KEY, 3.0, 50.0)
+        self._boosting_type = trial.suggest_categorical(
+            _BOOSTING_TYPE_KEY, ["Ordered", "Plain"]
+        )
+
+    def load(self, folder: str) -> None:
+        with open(
+            os.path.join(folder, _MODEL_PARAMS_FILENAME), encoding="utf8"
+        ) as handle:
+            params = json.load(handle)
+            self._iterations = params[_ITERATIONS_KEY]
+            self._learning_rate = params[_LEARNING_RATE_KEY]
+            self._depth = params[_DEPTH_KEY]
+            self._l2_leaf_reg = params[_L2_LEAF_REG_KEY]
+            self._boosting_type = params[_BOOSTING_TYPE_KEY]
+            self._model_type = ModelType(params[_MODEL_TYPE_KEY])
+        catboost = self._provide_catboost()
+        catboost.load_model(os.path.join(folder, _MODEL_FILENAME))
+
+    def save(self, folder: str) -> None:
+        with open(
+            os.path.join(folder, _MODEL_PARAMS_FILENAME), "w", encoding="utf8"
+        ) as handle:
+            json.dump(
+                {
+                    _ITERATIONS_KEY: self._iterations,
+                    _LEARNING_RATE_KEY: self._learning_rate,
+                    _DEPTH_KEY: self._depth,
+                    _L2_LEAF_REG_KEY: self._l2_leaf_reg,
+                    _BOOSTING_TYPE_KEY: self._boosting_type,
+                    _MODEL_TYPE_KEY: str(self._model_type),
+                },
+                handle,
+            )
+        catboost = self._provide_catboost()
+        catboost.save_model(os.path.join(folder, _MODEL_FILENAME))
+
+    def fit(
+        self,
+        df: pd.DataFrame,
+        y: pd.Series | pd.DataFrame | None = None,
+        w: pd.Series | None = None,
+    ) -> Self:
+        if y is None:
+            raise ValueError("y is null.")
+        self._model_type = determine_model_type(y)
+        catboost = self._provide_catboost()
+
+        train_pool = Pool(
+            df,
+            label=y,
+            weight=w,
+        )
+        catboost.fit(
+            train_pool,
+            early_stopping_rounds=100,
+            verbose=False,
+            metric_period=100,
+        )
+        return self
+
+    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        pred_pool = Pool(df)
+        catboost = self._provide_catboost()
+        pred = catboost.predict(pred_pool)
+        df = pd.DataFrame(
+            index=df.index,
+            data={
+                PREDICTION_COLUMN: pred.flatten(),
+            },
+        )
+        if self._model_type != ModelType.REGRESSION:
+            proba = catboost.predict_proba(pred_pool)  # type: ignore
+            for i in range(proba.shape[1]):
+                df[f"{PROBABILITY_COLUMN_PREFIX}{i}"] = proba[:, i]
+        return df
+
+    def _provide_catboost(self) -> CatBoost:
+        catboost = self._catboost
+        if catboost is None:
+            match self._model_type:
+                case ModelType.BINARY:
+                    catboost = CatBoostClassifier(
+                        iterations=self._iterations,
+                        learning_rate=self._learning_rate,
+                        depth=self._depth,
+                        l2_leaf_reg=self._l2_leaf_reg,
+                        boosting_type=self._boosting_type,
+                        early_stopping_rounds=100,
+                        metric_period=100,
+                    )
+                case ModelType.REGRESSION:
+                    catboost = CatBoostRegressor(
+                        iterations=self._iterations,
+                        learning_rate=self._learning_rate,
+                        depth=self._depth,
+                        l2_leaf_reg=self._l2_leaf_reg,
+                        boosting_type=self._boosting_type,
+                        early_stopping_rounds=100,
+                        metric_period=100,
+                    )
+                case ModelType.BINNED_BINARY:
+                    catboost = CatBoostClassifier(
+                        iterations=self._iterations,
+                        learning_rate=self._learning_rate,
+                        depth=self._depth,
+                        l2_leaf_reg=self._l2_leaf_reg,
+                        boosting_type=self._boosting_type,
+                        early_stopping_rounds=100,
+                        metric_period=100,
+                    )
+                case ModelType.MULTI_CLASSIFICATION:
+                    catboost = CatBoostClassifier(
+                        iterations=self._iterations,
+                        learning_rate=self._learning_rate,
+                        depth=self._depth,
+                        l2_leaf_reg=self._l2_leaf_reg,
+                        boosting_type=self._boosting_type,
+                        early_stopping_rounds=100,
+                        metric_period=100,
+                    )
+            self._catboost = catboost
+        if catboost is None:
+            raise ValueError("catboost is null")
+        return catboost

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/model/model.py

@@ -2,6 +2,8 @@
 
 from typing import Any
 
+import pandas as pd
+
 from ..fit import Fit
 from ..params import Params
 
@@ -21,3 +23,7 @@ class Model(Params, Fit):
     def estimator(self) -> Any:
         """The estimator backing the model."""
         raise NotImplementedError("estimator not implemented in parent class.")
+
+    def pre_fit(self, y: pd.Series | pd.DataFrame | None) -> None:
+        """A call to make sure the model is prepared for the target type."""
+        raise NotImplementedError("pre_fit not implemented in parent class.")

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/model/model_router.py

@@ -37,10 +37,17 @@ class ModelRouter(Model):
             raise ValueError("model is null")
         return model.estimator
 
+    def pre_fit(self, y: pd.Series | pd.DataFrame | None):
+        model = self._model
+        if model is None:
+            raise ValueError("model is null")
+        model.pre_fit(y)
+
     def set_options(self, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
         self._model = _MODELS[
             trial.suggest_categorical("model", list(_MODELS.keys()))
         ]()
+        self._model.set_options(trial)
 
     def load(self, folder: str) -> None:
         with open(os.path.join(folder, _MODEL_ROUTER_FILE), encoding="utf8") as handle:

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/model_type.py

@@ -1,17 +1,17 @@
 """An enum to define the model type."""
 
-from enum import Enum
+from enum import StrEnum, auto
 
 import pandas as pd
 
 
-class ModelType(Enum):
+class ModelType(StrEnum):
     """The type of model being run."""
 
-    BINARY = 1
-    REGRESSION = 2
-    BINNED_BINARY = 3
-    MULTI_CLASSIFICATION = 4
+    BINARY = auto()
+    REGRESSION = auto()
+    BINNED_BINARY = auto()
+    MULTI_CLASSIFICATION = auto()
 
 
 def determine_model_type(y: pd.Series | pd.DataFrame) -> ModelType:

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/reducer/combined_reducer.py

@@ -10,6 +10,7 @@ import pandas as pd
 from .constant_reducer import ConstantReducer
 from .correlation_reducer import CorrelationReducer
 from .duplicate_reducer import DuplicateReducer
+from .nonnumeric_reducer import NonNumericReducer
 from .reducer import Reducer
 
 _COMBINED_REDUCER_FILE = "combined_reducer.json"
@@ -21,7 +22,12 @@ class CombinedReducer(Reducer):
 
     def __init__(self):
         super().__init__()
-        self._reducers = [ConstantReducer(), DuplicateReducer(), CorrelationReducer()]
+        self._reducers = [
+            ConstantReducer(),
+            DuplicateReducer(),
+            CorrelationReducer(),
+            NonNumericReducer(),
+        ]
 
     @classmethod
     def name(cls) -> str:
@@ -44,6 +50,8 @@ class CombinedReducer(Reducer):
                     self._reducers.append(DuplicateReducer())
                 elif reducer_name == CorrelationReducer.name():
                     self._reducers.append(CorrelationReducer())
+                elif reducer_name == NonNumericReducer.name():
+                    self._reducers.append(NonNumericReducer())
         for reducer in self._reducers:
             reducer.load(folder)
 
@@ -67,7 +75,7 @@ class CombinedReducer(Reducer):
         w: pd.Series | None = None,
     ) -> Self:
         for reducer in self._reducers:
-            reducer.fit(df)
+            df = reducer.fit_transform(df)
         return self
 
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:

wavetrainer-0.0.5/wavetrainer/reducer/nonnumeric_reducer.py

@@ -0,0 +1,39 @@
+"""A reducer that removes non-numeric columns."""
+
+from typing import Self
+
+import optuna
+import pandas as pd
+
+from .reducer import Reducer
+
+
+class NonNumericReducer(Reducer):
+    """A class that removes non numeric columns from a dataframe."""
+
+    @classmethod
+    def name(cls) -> str:
+        return "nonnumeric"
+
+    def set_options(self, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
+        pass
+
+    def load(self, folder: str) -> None:
+        pass
+
+    def save(self, folder: str) -> None:
+        pass
+
+    def fit(
+        self,
+        df: pd.DataFrame,
+        y: pd.Series | pd.DataFrame | None = None,
+        w: pd.Series | None = None,
+    ) -> Self:
+        return self
+
+    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
+        return df[keep_cols]

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/selector/selector.py

@@ -19,24 +19,18 @@ _SELECTOR_FILE = "selector.joblib"
 class Selector(Params, Fit):
     """The selector class."""
 
-    def __init__(self, model: Model, total_features: int):
+    _selector: RFE | None
+
+    def __init__(self, model: Model):
         super().__init__()
         self._model = model
         self._feature_ratio = 0.0
         self._steps = 0
-        n_features_to_select = max(1, total_features * self._feature_ratio)
-        self._selector = RFE(
-            model.estimator,
-            n_features_to_select=n_features_to_select,
-            step=self._steps,
-            verbose=1,
-        )
+        self._selector = None
 
     def set_options(self, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
         self._feature_ratio = trial.suggest_float("feature_ratio", 0.0, 1.0)
-        steps = trial.suggest_int("steps", 1, 16)
-        self._steps = steps
-        self._selector.step = steps
+        self._steps = trial.suggest_int("steps", 1, 16)
 
     def load(self, folder: str) -> None:
         self._selector = joblib.load(os.path.join(folder, _SELECTOR_FILE))
@@ -50,9 +44,18 @@ class Selector(Params, Fit):
         y: pd.Series | pd.DataFrame | None = None,
         w: pd.Series | None = None,
     ) -> Self:
+        self._model.pre_fit(y)
         if not isinstance(y, pd.Series):
             raise ValueError("y is not a series.")
-
+        n_features_to_select = max(1, int(len(df.columns) * self._feature_ratio))
+        self._selector = RFE(
+            self._model.estimator,
+            n_features_to_select=n_features_to_select,
+            step=max(
+                1,
+                int((len(df.columns) - n_features_to_select) / self._steps),
+            ),
+        )
         try:
             self._selector.fit(df, y=y, sample_weight=w)
         except ValueError as exc:
@@ -61,8 +64,11 @@ class Selector(Params, Fit):
         return self
 
     def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        selector = self._selector
+        if selector is None:
+            raise ValueError("selector is null.")
         try:
-            return df[self._selector.get_feature_names_out()]
+            return df[selector.get_feature_names_out()]
         except AttributeError as exc:
             # Catch issues with 1 feature as a reduction target.
             logging.warning(str(exc))

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/trainer.py

@@ -11,7 +11,7 @@ from typing import Self
 import optuna
 import pandas as pd
 import tqdm
-from sklearn.metrics import accuracy_score, f1_score  # type: ignore
+from sklearn.metrics import f1_score, mean_absolute_error  # type: ignore
 
 from .calibrator.calibrator_router import CalibratorRouter
 from .exceptions import WavetrainException
@@ -215,7 +215,7 @@ class Trainer(Fit):
                     model.set_options(trial)
 
                     # Train
-                    selector = Selector(model, len(x_train.columns.values))
+                    selector = Selector(model)
                     selector.set_options(trial)
                     selector.fit(x_train, y=y_train, w=w)
                     x_train = selector.transform(x_train)
@@ -243,7 +243,7 @@ class Trainer(Fit):
                     y_pred = model.transform(x_test)
                     y_pred = calibrator.transform(y_pred)
                     if determine_model_type(y_series) == ModelType.REGRESSION:
-                        return accuracy_score(y_test, y_pred[[PREDICTION_COLUMN]])
+                        return mean_absolute_error(y_test, y_pred[[PREDICTION_COLUMN]])
                     return f1_score(y_test, y_pred[[PREDICTION_COLUMN]])
                 except WavetrainException as exc:
                     logging.warning(str(exc))
@@ -252,14 +252,16 @@ class Trainer(Fit):
             start_validation_index = (
                 dt_index[-int(len(dt_index) * self._validation_size) - 1]
                 if isinstance(self._validation_size, float)
-                else dt_index[dt_index >= self._validation_size][0]
+                else dt_index[
+                    dt_index >= (dt_index.to_list()[-1] - self._validation_size)
+                ].to_list()[0]
             )
             test_df = df[dt_index < start_validation_index]
             test_dt_index = (
                 test_df.index if self._dt_column is None else test_df[self._dt_column]
             )
             start_test_index = (
-                test_dt_index[-int(len(test_dt_index) * self._test_size)]
+                test_dt_index.to_list()[-int(len(test_dt_index) * self._test_size)]
                 if isinstance(self._test_size, float)
                 else test_dt_index[test_dt_index >= self._test_size][0]
             )
@@ -284,9 +286,15 @@ class Trainer(Fit):
             train_len = len(df[dt_index < start_test_index])
             test_len = len(df.loc[start_test_index:start_validation_index])
 
+            last_processed_dt = None
             for count, test_idx in tqdm.tqdm(
-                enumerate(df[dt_index >= start_test_index].index)
+                enumerate(test_dt_index[test_dt_index >= start_test_index])
             ):
+                if (
+                    last_processed_dt is not None
+                    and test_idx < last_processed_dt + self._walkforward_timedelta
+                ):
+                    continue
                 test_dt = test_idx.to_pydatetime()
                 found = False
                 for trial in study.trials:
@@ -371,7 +379,7 @@ class Trainer(Fit):
                 model = ModelRouter()
                 model.load(folder)
 
-                selector = Selector(model, len(df.columns.values))
+                selector = Selector(model)
                 selector.load(folder)
 
                 calibrator = CalibratorRouter(model)

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/weights/class_weights.py

@@ -47,7 +47,7 @@ class ClassWeights(Weights):
             self._class_weights = {}
             return self
 
-        arr = df.astype(int).to_numpy().flatten().astype(float)
+        arr = y.astype(int).to_numpy().flatten().astype(float)
         unique_vals = np.unique(arr)
         w_arr = compute_class_weight(
             class_weight="balanced", classes=unique_vals, y=arr

{wavetrainer-0.0.3 → wavetrainer-0.0.5}/wavetrainer/windower/windower.py

@@ -52,7 +52,9 @@ class Windower(Params, Fit):
         lookback_ratio = self._lookback_ratio
         if lookback_ratio is None:
             raise ValueError("lookback_ratio is null")
-        dt_index = df.index if self._dt_column is None else df[self._dt_column]
+        dt_index = (
+            df.index if self._dt_column is None else df[self._dt_column].to_list()
+        )
         start_idx = dt_index[int(len(df) * lookback_ratio)]
         end_idx = dt_index[-1]
         td = end_idx.to_pydatetime() - start_idx.to_pydatetime()
@@ -66,5 +68,6 @@ class Windower(Params, Fit):
         dt_index = df.index if self._dt_column is None else df[self._dt_column]
         return df[
             dt_index
-            >= dt_index[-1].to_pydatetime() - datetime.timedelta(seconds=lookback)
+            >= dt_index.to_list()[-1].to_pydatetime()
+            - datetime.timedelta(seconds=lookback)
         ]

{wavetrainer-0.0.3 → wavetrainer-0.0.5/wavetrainer.egg-info}/PKG-INFO

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

@@ -9,7 +9,6 @@ wavetrainer/__init__.py
 wavetrainer/create.py
 wavetrainer/exceptions.py
 wavetrainer/fit.py
-wavetrainer/load.py
 wavetrainer/model_type.py
 wavetrainer/params.py
 wavetrainer/trainer.py
@@ -34,6 +33,7 @@ wavetrainer/reducer/combined_reducer.py
 wavetrainer/reducer/constant_reducer.py
 wavetrainer/reducer/correlation_reducer.py
 wavetrainer/reducer/duplicate_reducer.py
+wavetrainer/reducer/nonnumeric_reducer.py
 wavetrainer/reducer/reducer.py
 wavetrainer/selector/__init__.py
 wavetrainer/selector/selector.py

wavetrainer-0.0.3/wavetrainer/__init__.py

@@ -1,10 +0,0 @@
-"""The wavetrain main module."""
-
-from .create import create
-from .load import load
-
-__VERSION__ = "0.0.3"
-__all__ = (
-    "create",
-    "load",
-)

wavetrainer-0.0.3/wavetrainer/load.py

@@ -1,8 +0,0 @@
-"""The function for loading the trainer state from disk."""
-
-from .trainer import Trainer
-
-
-def load(folder: str) -> Trainer:
-    """Loads the trainer from the folder."""
-    raise NotImplementedError("load isn't implemented.")

wavetrainer-0.0.3/wavetrainer/model/catboost_model.py

@@ -1,80 +0,0 @@
-"""A model that wraps catboost."""
-
-import os
-from typing import Any, Self
-
-import optuna
-import pandas as pd
-from catboost import CatBoostClassifier, Pool  # type: ignore
-
-from .model import PREDICTION_COLUMN, PROBABILITY_COLUMN_PREFIX, Model
-
-_MODEL_FILENAME = "model.cbm"
-
-
-class CatboostModel(Model):
-    """A class that uses Catboost as a model."""
-
-    @classmethod
-    def name(cls) -> str:
-        return "catboost"
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._catboost = CatBoostClassifier()
-
-    @property
-    def estimator(self) -> Any:
-        return self._catboost
-
-    def set_options(self, trial: optuna.Trial | optuna.trial.FrozenTrial) -> None:
-        iterations = trial.suggest_int("iterations", 100, 10000)
-        learning_rate = trial.suggest_float("learning_rate", 0.001, 0.3)
-        depth = trial.suggest_int("depth", 1, 12)
-        l2_leaf_reg = trial.suggest_float("l2_leaf_reg", 3.0, 50.0)
-        boosting_type = trial.suggest_categorical("boosting_type", ["Ordered", "Plain"])
-        self._catboost.set_params(
-            iterations=iterations,
-            learning_rate=learning_rate,
-            depth=depth,
-            l2_leaf_reg=l2_leaf_reg,
-            boosting_type=boosting_type,
-            early_stopping_rounds=100,
-        )
-
-    def load(self, folder: str) -> None:
-        self._catboost.load_model(os.path.join(folder, _MODEL_FILENAME))
-
-    def save(self, folder: str) -> None:
-        self._catboost.save_model(os.path.join(folder, _MODEL_FILENAME))
-
-    def fit(
-        self,
-        df: pd.DataFrame,
-        y: pd.Series | pd.DataFrame | None = None,
-        w: pd.Series | None = None,
-    ) -> Self:
-        train_pool = Pool(
-            df,
-            label=y,
-            weight=w,
-        )
-        self._catboost.fit(
-            train_pool,
-            early_stopping_rounds=100,
-        )
-        return self
-
-    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
-        pred_pool = Pool(df)
-        pred = self._catboost.predict(pred_pool)
-        proba = self._catboost.predict_proba(pred_pool)
-        df = pd.DataFrame(
-            index=df.index,
-            data={
-                PREDICTION_COLUMN: pred.flatten(),
-            },
-        )
-        for i in range(proba.shape[1]):
-            df[f"{PROBABILITY_COLUMN_PREFIX}{i}"] = proba[:, i]
-        return df