lecrapaud 0.8.3__py3-none-any.whl → 0.9.0__py3-none-any.whl

lecrapaud/api.py

@@ -108,17 +108,13 @@ class ExperimentEngine:
         for target_number in self.target_numbers:
 
             # loading model
-            training_target_dir = f"{self.experiment.path}/TARGET_{target_number}"
+            target_dir = f"{self.experiment.path}/TARGET_{target_number}"
             all_features = self.experiment.get_all_features(
                 date_column=self.date_column, group_column=self.group_column
             )
-            if self.experiment.name == "data_28_X_X":
-                features = joblib.load(
-                    f"{self.experiment.path}/preprocessing/features_{target_number}.pkl"
-                )  # we keep this for backward compatibility
-            else:
-                features = self.experiment.get_features(target_number)
-            model = ModelEngine(path=training_target_dir)
+            features = self.experiment.get_features(target_number)
+
+            model = ModelEngine(path=target_dir)
 
             # getting data
             if model.recurrent:

lecrapaud/db/models/experiment.py

@@ -1,4 +1,5 @@
 from itertools import chain
+import joblib
 
 from sqlalchemy import (
     Column,
@@ -106,6 +107,11 @@ class Experiment(Base):
             fs for fs in feature_selections if fs.target_id == target_id
         ][0]
         features = [f.name for f in feature_selection.features]
+
+        # fallback to path if no features found
+        if len(features) == 0:
+            features = joblib.load(f"{self.path}/TARGET_{target_number}/features.pkl")
+
         return features
 
     def get_all_features(self, date_column: str = None, group_column: str = None):
@@ -115,6 +121,11 @@ class Experiment(Base):
             for fs in self.feature_selections
             if fs.target_id in target_idx
         )
+
+        # fallback to path if no features found
+        if len(_all_features) == 0:
+            _all_features = joblib.load(f"{self.path}/preprocessing/all_features.pkl")
+
         all_features = []
         if date_column:
             all_features.append(date_column)

lecrapaud/experiment.py

@@ -2,6 +2,7 @@ import os
 from pathlib import Path
 
 import pandas as pd
+import joblib
 
 # Set up coverage file path
 os.environ["COVERAGE_FILE"] = str(Path(".coverage").resolve())
@@ -13,7 +14,7 @@ from lecrapaud.db.session import get_db
 
 
 def create_experiment(
-    data: pd.DataFrame,
+    data: pd.DataFrame | str,
     corr_threshold,
     percentile,
     max_features,
@@ -22,6 +23,10 @@ def create_experiment(
     experiment_name,
     **kwargs,
 ):
+    if isinstance(data, str):
+        path = f"{data}/data/full.pkl" if "data" not in data else f"{data}/full.pkl"
+        data = joblib.load(path)
+
     dates = {}
     if date_column:
         dates["start_date"] = pd.to_datetime(data[date_column].iat[0])

lecrapaud/feature_selection.py

@@ -54,7 +54,7 @@ from lecrapaud.search_space import all_models
 warnings.filterwarnings("ignore", category=FutureWarning)
 
 
-def load_train_data(experiment_dir, target_number, target_type="regression"):
+def load_train_data(experiment_dir):
     data_dir = f"{experiment_dir}/data"
 
     logger.info("Loading data...")
@@ -90,11 +90,9 @@ class FeatureSelectionEngine:
         self.experiment_dir = self.experiment.path
         self.experiment_id = self.experiment.id
         self.data_dir = f"{self.experiment_dir}/data"
-        self.preprocessing_dir = f"{self.experiment_dir}/preprocessing"
-        self.fs_dir_target = (
-            f"{self.experiment_dir}/{f"TARGET_{self.target_number}"}/feature_selection"
-        )
-        os.makedirs(self.fs_dir_target, exist_ok=True)
+        self.target_dir = f"{self.experiment_dir}/TARGET_{self.target_number}"
+        self.feature_selection_dir = f"{self.target_dir}/feature_selection"
+        os.makedirs(self.feature_selection_dir, exist_ok=True)
 
     # Main feature selection function
     def run(
@@ -110,7 +108,6 @@ class FeatureSelectionEngine:
         """
         target_number = self.target_number
         target_type = self.target_type
-        fs_dir_target = self.fs_dir_target
 
         # Create the feature selection in db
         target = Target.find_by(name=f"TARGET_{target_number}")
@@ -133,7 +130,7 @@ class FeatureSelectionEngine:
         self.y = self.train[f"TARGET_{target_number}"]
 
         logger.info(f"Starting feature selection for TARGET_{target_number}...")
-        clean_directory(self.fs_dir_target)
+        clean_directory(self.feature_selection_dir)
 
         # Let's start by removing very low variance feature and extremly correlated features
         # This is needed to reduce nb of feature but also for methods such as anova or chi2 that requires independent, non constant, non full 0 features
@@ -158,9 +155,7 @@ class FeatureSelectionEngine:
         self.X_categorical, self.X_numerical = get_features_by_types(self.X)
 
         if target_type == "classification" and self.X_categorical.shape[1] > 0:
-            feat_scores = self.select_categorical_features(
-                percentile=percentile, save_dir=fs_dir_target
-            )
+            feat_scores = self.select_categorical_features(percentile=percentile)
             with get_db() as db:
                 for row in feat_scores.itertuples(index=False):
                     feature = Feature.find_by(name=row.features, db=db)
@@ -181,7 +176,7 @@ class FeatureSelectionEngine:
             ].values.tolist()
 
         results = []
-        params = {"percentile": percentile, "save_dir": fs_dir_target}
+        params = {"percentile": percentile}
         if single_process:
             results = [
                 self.select_feature_by_linear_correlation(**params),
@@ -288,7 +283,7 @@ class FeatureSelectionEngine:
         )
         logger.debug(features_selected_by_every_methods)
         pd.Series(features_selected_list).to_csv(
-            f"{fs_dir_target}/features_before_corr.csv",
+            f"{self.feature_selection_dir}/features_before_corr.csv",
             index=True,
             header=True,
             index_label="ID",
@@ -298,7 +293,7 @@ class FeatureSelectionEngine:
         self.X = self.X[features_selected_list]
         features, features_correlated = self.remove_correlated_features(corr_threshold)
         pd.Series(features).to_csv(
-            f"{fs_dir_target}/features_before_max.csv",
+            f"{self.feature_selection_dir}/features_before_max.csv",
             index=True,
             header=True,
             index_label="ID",
@@ -327,9 +322,7 @@ class FeatureSelectionEngine:
         )
 
         # save to path
-        best_features_path = Path(
-            f"{self.preprocessing_dir}/features_{target_number}.pkl"
-        ).resolve()
+        best_features_path = Path(f"{self.target_dir}/features.pkl").resolve()
         joblib.dump(features, best_features_path)
 
         # save in db
@@ -423,7 +416,7 @@ class FeatureSelectionEngine:
     # Filter methods
     # ----------------
 
-    def select_categorical_features(self, percentile, save_dir: Optional[str] = None):
+    def select_categorical_features(self, percentile):
         X, y = self.X_categorical, self.y
 
         start = time.time()
@@ -446,15 +439,16 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/Chi2.csv", index=True, header=True, index_label="ID"
+            f"{self.feature_selection_dir}/Chi2.csv",
+            index=True,
+            header=True,
+            index_label="ID",
         )
 
         return feat_scores
 
     # Linear correlation (Person's R for regression and ANOVA for classification)
-    def select_feature_by_linear_correlation(
-        self, percentile: int = 20, save_dir: Optional[str] = None
-    ):
+    def select_feature_by_linear_correlation(self, percentile: int = 20):
         X, y, target_type = self.X_numerical, self.y, self.target_type
 
         start = time.time()
@@ -480,7 +474,7 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/{test_type}.csv",
+            f"{self.feature_selection_dir}/{test_type}.csv",
             index=True,
             header=True,
             index_label="ID",
@@ -489,9 +483,7 @@ class FeatureSelectionEngine:
         return feat_scores
 
     # Non-Linear correlation (Spearsman's R for regression and Kendall's Tau for classification)
-    def select_feature_by_nonlinear_correlation(
-        self, percentile: int = 20, save_dir: Optional[str] = None
-    ):
+    def select_feature_by_nonlinear_correlation(self, percentile: int = 20):
         X, y, target_type = self.X_numerical, self.y, self.target_type
 
         start = time.time()
@@ -537,7 +529,7 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/{test_type}.csv",
+            f"{self.feature_selection_dir}/{test_type}.csv",
             index=True,
             header=True,
             index_label="ID",
@@ -546,9 +538,7 @@ class FeatureSelectionEngine:
         return feat_scores
 
     # Mutual Information
-    def select_feature_by_mi(
-        self, percentile: int = 20, save_dir: Optional[str] = None
-    ):
+    def select_feature_by_mi(self, percentile: int = 20):
         X, y, target_type = self.X_numerical, self.y, self.target_type
 
         start = time.time()
@@ -575,7 +565,10 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/MI.csv", index=True, header=True, index_label="ID"
+            f"{self.feature_selection_dir}/MI.csv",
+            index=True,
+            header=True,
+            index_label="ID",
         )
 
         return feat_scores
@@ -584,9 +577,7 @@ class FeatureSelectionEngine:
     # ----------------
 
     # feature importance
-    def select_feature_by_feat_imp(
-        self, percentile: int = 20, save_dir: Optional[str] = None
-    ):
+    def select_feature_by_feat_imp(self, percentile: int = 20):
         X, y, target_type = self.X_numerical, self.y, self.target_type
 
         start = time.time()
@@ -628,7 +619,10 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/FI.csv", index=True, header=True, index_label="ID"
+            f"{self.feature_selection_dir}/FI.csv",
+            index=True,
+            header=True,
+            index_label="ID",
         )
 
         return feat_scores
@@ -637,9 +631,7 @@ class FeatureSelectionEngine:
     # ----------------
 
     # recursive feature elimination
-    def select_feature_by_rfe(
-        self, percentile: int = 20, save_dir: Optional[str] = None
-    ):
+    def select_feature_by_rfe(self, percentile: int = 20):
         X, y, target_type = self.X_numerical, self.y, self.target_type
 
         start = time.time()
@@ -681,15 +673,16 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/RFE.csv", index=True, header=True, index_label="ID"
+            f"{self.feature_selection_dir}/RFE.csv",
+            index=True,
+            header=True,
+            index_label="ID",
         )
 
         return feat_scores
 
     # SequentialFeatureSelector (loss based, possibility to do forwards or backwards selection or removal)
-    def select_feature_by_sfs(
-        self, percentile: int = 20, save_dir: Optional[str] = None
-    ):
+    def select_feature_by_sfs(self, percentile: int = 20):
         X, y, target_type = self.X_numerical, self.y, self.target_type
 
         start = time.time()
@@ -782,7 +775,10 @@ class FeatureSelectionEngine:
         )
 
         feat_scores.to_csv(
-            f"{save_dir}/SFS.csv", index=True, header=True, index_label="ID"
+            f"{self.feature_selection_dir}/SFS.csv",
+            index=True,
+            header=True,
+            index_label="ID",
         )
 
         return feat_scores
@@ -862,11 +858,13 @@ class PreprocessModel:
             train_scaled = None
             val_scaled = None
             test_scaled = None
+            scaler_x = None
 
         # save data
         joblib.dump(train_scaled, f"{self.data_dir}/train_scaled.pkl")
         joblib.dump(val_scaled, f"{self.data_dir}/val_scaled.pkl")
         joblib.dump(test_scaled, f"{self.data_dir}/test_scaled.pkl")
+        joblib.dump(scaler_x, f"{self.preprocessing_dir}/scaler_x.pkl")
 
         data = {
             "train": self.train,
@@ -875,7 +873,6 @@ class PreprocessModel:
             "train_scaled": train_scaled,
             "val_scaled": val_scaled,
             "test_scaled": test_scaled,
-            "scalers_y": scalers_y,
         }
 
         # reshape data for time series
@@ -902,7 +899,7 @@ class PreprocessModel:
         self.train = self.train[columns_to_keep]
 
         scaler_x = joblib.load(f"{self.preprocessing_dir}/scaler_x.pkl")
-        scaled_data = scaler_x.transform(self.train)  # TODO: utiliser scale_data
+        scaled_data = scaler_x.transform(self.train)
         scaled_data = pd.DataFrame(
             scaled_data, columns=self.train.columns, index=self.train.index
         )
@@ -951,7 +948,6 @@ class PreprocessModel:
             X_scaled = pd.DataFrame(
                 scaler_x.fit_transform(X), columns=list(X.columns), index=X.index
             )
-            joblib.dump(scaler_x, f"{self.preprocessing_dir}/scaler_x.pkl")
 
         # Determine which targets need to be scaled
         targets_numbers_to_scale = [
@@ -980,9 +976,8 @@ class PreprocessModel:
                     columns=y.columns,
                     index=y.index,
                 )
-                joblib.dump(
-                    scaler_y, f"{self.preprocessing_dir}/scaler_y_{target_number}.pkl"
-                )
+                target_dir = f"{self.experiment_dir}/TARGET_{target_number}"
+                joblib.dump(scaler_y, f"{target_dir}/scaler_y.pkl")
 
                 scalers_y[f"scaler_y_{target_number}"] = scaler_y
                 scaled_targets[target_number] = scaled_y

lecrapaud/model_selection.py

@@ -145,11 +145,7 @@ class ModelEngine:
         self.log_dir = log_dir
 
         if self.path and self.need_scaling and self.target_type == "regression":
-            preprocessing_dir = Path(f"{self.path}/../preprocessing")
-            target_number = self.path.split("/")[-1].split("_")[-1]
-            self.scaler_y = joblib.load(
-                preprocessing_dir / f"scaler_y_{target_number}.pkl"
-            )
+            self.scaler_y = joblib.load(f"{self.path}/scaler_y.pkl")
         else:
             self.scaler_y = None
 
@@ -571,10 +567,10 @@ class ModelEngine:
         if not self.path:
             raise ValueError("Path is not set, cannot load model")
 
-        training_target_dir = Path(self.path)
+        target_dir = Path(self.path)
 
         # Load threshold
-        scores_tracking = pd.read_csv(f"{training_target_dir}/scores_tracking.csv")
+        scores_tracking = pd.read_csv(f"{target_dir}/scores_tracking.csv")
         self.threshold = (
             scores_tracking["THRESHOLD"].values[0]
             if "THRESHOLD" in scores_tracking.columns
@@ -582,8 +578,8 @@ class ModelEngine:
         )
 
         # Search for files that contain '.best' or '.keras' in the name
-        best_files = list(training_target_dir.glob("*.best*")) + list(
-            training_target_dir.glob("*.keras*")
+        best_files = list(target_dir.glob("*.best*")) + list(
+            target_dir.glob("*.keras*")
         )
         # If any files are found, try loading the first one (or process as needed)
         if best_files:
@@ -610,7 +606,7 @@ class ModelEngine:
                     )
         else:
             raise FileNotFoundError(
-                f"No files with '.best' or '.keras' found in the specified folder: {training_target_dir}"
+                f"No files with '.best' or '.keras' found in the specified folder: {target_dir}"
             )
 
         self.model_name = self._model.model_name
@@ -737,7 +733,7 @@ class ModelSelectionEngine:
         self.experiment_id = self.experiment.id
         self.data_dir = f"{self.experiment_dir}/data"
         self.preprocessing_dir = f"{self.experiment_dir}/preprocessing"
-        self.training_target_dir = f"{self.experiment_dir}/TARGET_{self.target_number}"
+        self.target_dir = f"{self.experiment_dir}/TARGET_{self.target_number}"
         self.metric = "RMSE" if self.target_type == "regression" else "LOGLOSS"
         self.features = self.experiment.get_features(self.target_number)
         self.all_features = self.experiment.get_all_features(
@@ -826,7 +822,7 @@ class ModelSelectionEngine:
             if recurrent is False and config[self.target_type] is None:
                 continue  # for naive bayes models that cannot be used in regression
 
-            self.results_dir = f"{self.training_target_dir}/{model_name}"
+            self.results_dir = f"{self.target_dir}/{model_name}"
             if not os.path.exists(f"{self.results_dir}"):
                 os.makedirs(f"{self.results_dir}")
             elif preserve_model and contains_best(self.results_dir):
@@ -885,7 +881,7 @@ class ModelSelectionEngine:
                     x_test = test[self.features]
                     y_test = test[f"TARGET_{self.target_number}"].rename("TARGET")
 
-            log_dir = get_log_dir(self.training_target_dir, model_name)
+            log_dir = get_log_dir(self.target_dir, model_name)
             # instantiate model
             model = ModelEngine(
                 model_name=model_name,
@@ -902,7 +898,7 @@ class ModelSelectionEngine:
                 best_params = self.hyperoptimize(x_train, y_train, x_val, y_val, model)
 
                 # save best params
-                best_params_file = f"{self.training_target_dir}/best_params.json"
+                best_params_file = f"{self.target_dir}/best_params.json"
                 try:
                     with open(best_params_file, "r") as f:
                         json_dict = json.load(f)
@@ -914,7 +910,7 @@ class ModelSelectionEngine:
                     json.dump(json_dict, f, indent=4)
             else:
                 try:
-                    with open(f"{self.training_target_dir}/best_params.json") as f:
+                    with open(f"{self.target_dir}/best_params.json") as f:
                         json_dict = json.load(f)
                         best_params = json_dict[model_name]
                 except Exception:
@@ -1028,7 +1024,7 @@ class ModelSelectionEngine:
             best_score["MODEL_PATH"] = model_path
 
             # Track scores
-            scores_tracking_path = f"{self.training_target_dir}/scores_tracking.csv"
+            scores_tracking_path = f"{self.target_dir}/scores_tracking.csv"
             best_score_df = pd.DataFrame([best_score])
 
             if os.path.exists(scores_tracking_path):
@@ -1072,26 +1068,26 @@ class ModelSelectionEngine:
             logger.info(f"Model training finished in {training_time:.2f} seconds")
 
         # find best model type
-        scores_tracking_path = f"{self.training_target_dir}/scores_tracking.csv"
+        scores_tracking_path = f"{self.target_dir}/scores_tracking.csv"
         scores_tracking = pd.read_csv(scores_tracking_path)
         best_score_overall = scores_tracking.iloc[0, :]
         best_model_name = best_score_overall["MODEL_NAME"]
 
         # Remove any .best or .keras files
-        for file_path in glob.glob(
-            os.path.join(self.training_target_dir, "*.best")
-        ) + glob.glob(os.path.join(self.training_target_dir, "*.keras")):
+        for file_path in glob.glob(os.path.join(self.target_dir, "*.best")) + glob.glob(
+            os.path.join(self.target_dir, "*.keras")
+        ):
             os.remove(file_path)
         # Copy the best model in root training folder for this target
         best_model_path = Path(
-            f"{self.training_target_dir}/{os.path.basename(best_score_overall['MODEL_PATH'])}"
+            f"{self.target_dir}/{os.path.basename(best_score_overall['MODEL_PATH'])}"
         ).resolve()
         copy_any(
             best_score_overall["MODEL_PATH"],
             best_model_path,
         )
 
-        with open(f"{self.training_target_dir}/best_params.json", "r") as f:
+        with open(f"{self.target_dir}/best_params.json", "r") as f:
             best_model_params = json.load(f)[best_model_name]
 
         # save model_selection results to db
@@ -1111,8 +1107,8 @@ class ModelSelectionEngine:
     def hyperoptimize(self, x_train, y_train, x_val, y_val, model: ModelEngine):
         self.type_name = "hyperopts"
 
-        def collect_error_logs(training_target_dir: int, storage_path: str):
-            output_error_file = f"{training_target_dir}/errors.log"
+        def collect_error_logs(target_dir: int, storage_path: str):
+            output_error_file = f"{target_dir}/errors.log"
 
             with open(output_error_file, "a") as outfile:
                 # Walk through the ray_results directory
@@ -1176,9 +1172,7 @@ class ModelSelectionEngine:
                 f"Markdown table with all trials :\n{results.get_dataframe().to_markdown()}"
             )
             # Collect errors in single file
-            collect_error_logs(
-                training_target_dir=self.training_target_dir, storage_path=storage_path
-            )
+            collect_error_logs(target_dir=self.target_dir, storage_path=storage_path)
 
         except Exception as e:
             raise Exception(e)
@@ -1321,21 +1315,19 @@ def evaluate(
 
 
 # utils
-def get_log_dir(training_target_dir: str, model_name="test_model"):
+def get_log_dir(target_dir: str, model_name="test_model"):
     """Generates a structured log directory path for TensorBoard."""
     timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M")
-    log_dir = (
-        Path(training_target_dir + "/tensorboard") / model_name / f"run_{timestamp}"
-    )
+    log_dir = Path(target_dir + "/tensorboard") / model_name / f"run_{timestamp}"
     log_dir.mkdir(parents=True, exist_ok=True)  # Create directories if they don't exist
     return str(log_dir)
 
 
-def print_scores(training_target_dir: str):
+def print_scores(target_dir: str):
     """
     Monitor scores
     """
-    scores_tracking = pd.read_csv(f"{training_target_dir}/scores_tracking.csv")
+    scores_tracking = pd.read_csv(f"{target_dir}/scores_tracking.csv")
     return scores_tracking
 
 
@@ -1631,22 +1623,22 @@ def plot_threshold(prediction, threshold, precision, recall):
 
 
 # OLD - to sort out
-def get_pred_distribution(training_target_dir: str, model_name="linear"):
+def get_pred_distribution(target_dir: str, model_name="linear"):
     """
     Look at prediction distributions
     """
     prediction = pd.read_csv(
-        f"{training_target_dir}/{model_name}/prediction.csv",
+        f"{target_dir}/{model_name}/prediction.csv",
         index_col="ID",
     )
     prediction.describe()
 
 
-def plot_feature_importance(training_target_dir: str, model_name="linear"):
+def plot_feature_importance(target_dir: str, model_name="linear"):
     """
     Monitor feature importance ranking to filter out unrelevant features
     """
-    model = joblib.load(f"{training_target_dir}/{model_name}/{model_name}.best")
+    model = joblib.load(f"{target_dir}/{model_name}/{model_name}.best")
     if hasattr(model, "feature_importances_"):
         feature_importances_ = model.feature_importances_.flatten()
     elif hasattr(model, "feature_importance"):
@@ -1664,11 +1656,11 @@ def plot_feature_importance(training_target_dir: str, model_name="linear"):
     )
 
 
-def print_model_estimators(training_target_dir: str, model_name="linear"):
+def print_model_estimators(target_dir: str, model_name="linear"):
     """
     Look at a specific trained model
     """
-    model = joblib.load(f"{training_target_dir}/{model_name}/{model_name}.best")
+    model = joblib.load(f"{target_dir}/{model_name}/{model_name}.best")
     for i in range(0, 100):
         logger.info(model.estimators_[i].get_depth())
 

{lecrapaud-0.8.3.dist-info → lecrapaud-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lecrapaud
-Version: 0.8.3
+Version: 0.9.0
 Summary: Framework for machine and deep learning, with regression, classification and time series analysis
 License: Apache License
 Author: Pierre H. Gallet

{lecrapaud-0.8.3.dist-info → lecrapaud-0.9.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 lecrapaud/__init__.py,sha256=oCxbtw_nk8rlOXbXbWo0RRMlsh6w-hTiZ6e5PRG_wp0,28
-lecrapaud/api.py,sha256=S4YCj6Ulpomnp9fs0WKwodHt4Yb6HSubqxIrQr9_klE,10799
+lecrapaud/api.py,sha256=MJgu7gaZ2Ip0lF_TP1t8vkADRooaVRsBDALJvM6vSsg,10516
 lecrapaud/config.py,sha256=WJglRV6-lUfYUy5LZjwv3aO_X6ossHY9BUT7_NCSY1I,942
 lecrapaud/db/__init__.py,sha256=82o9fMfaqKXPh2_rt44EzNRVZV1R4LScEnQYvj_TjK0,34
 lecrapaud/db/alembic/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
@@ -11,7 +11,7 @@ lecrapaud/db/alembic/versions/2025_06_24_1711-86457e2f333f_.py,sha256=dl6tfvcqEr
 lecrapaud/db/alembic.ini,sha256=zgvur-5jnLsT66_98FaTOTNgjwObGZCE0HqMwRAeJrs,3587
 lecrapaud/db/models/__init__.py,sha256=Lhyw9fVLdom0Fc6yIP-ip8FjkU1EwVwjae5q2VM815Q,740
 lecrapaud/db/models/base.py,sha256=CYtof_UjFwX3C7XUifequh_UtLHJ25bU7LCwT501uGE,7508
-lecrapaud/db/models/experiment.py,sha256=WNV5gz78JljL0xlAjy121K3cgDqwC0r6zL3bpH6b0dY,3642
+lecrapaud/db/models/experiment.py,sha256=KwFbPTDAEXU0I9_33xMg6Ujx8QR_ffcjKA2YBOUuys4,3997
 lecrapaud/db/models/feature.py,sha256=5o77O2FyRObnLOCGNj8kaPSGM3pLv1Ov6mXXHYkmnYY,1136
 lecrapaud/db/models/feature_selection.py,sha256=nXy_Lg3uDxid71vYll_qzdo8ajYsJEXskI7vLQ3uyW0,3315
 lecrapaud/db/models/feature_selection_rank.py,sha256=PvEpdv-JJt2wZMtX5TO0wyZ3IONlPkeDaC49i0VA-qU,2074
@@ -22,22 +22,22 @@ lecrapaud/db/models/score.py,sha256=_yaa6yBxugcOZMvLxqqIaMN7QGvzAOzOGCYQO0_gBjw,
 lecrapaud/db/models/target.py,sha256=DKnfeaLU8eT8J_oh_vuFo5-o1CaoXR13xBbswme6Bgk,1649
 lecrapaud/db/session.py,sha256=K9dTyXmO-aF_2r9RRHsDsbW9_zLNDaOcchXlpiv7cSo,2719
 lecrapaud/directories.py,sha256=t4PrnJR48MpDfBOTYTyGlDVMUr39mcaj7uCPTaocBRw,725
-lecrapaud/experiment.py,sha256=NwwGDZqUyvvRu5EDK3_Oh0_kF29bNIPDawVFFpzFvZM,2350
+lecrapaud/experiment.py,sha256=_kuRARuw1pXe13K3MHz22KOJSiRmvhPb7Q2Mkli32t8,2519
 lecrapaud/feature_engineering.py,sha256=U3YOftZBB3PEqGbu2aFY_3B3Ks9Hiu04UxixOkBz0UU,31168
-lecrapaud/feature_selection.py,sha256=CUekyBet6AehobFJV_RWmKCOjMHKWadcXJUDb6FbRZM,43671
+lecrapaud/feature_selection.py,sha256=_Je2817Ah1v-6Rls4EiYC-fn3EbpBj6Uaq81KWBpQG4,43430
 lecrapaud/integrations/openai_integration.py,sha256=hHLF3fk5Bps8KNbNrEL3NUFa945jwClE6LrLpuMZOd4,7459
 lecrapaud/jobs/__init__.py,sha256=ZkrsyTOR21c_wN7RY8jPhm8jCrL1oCEtTsf3VFIlQiE,292
 lecrapaud/jobs/config.py,sha256=AmO0j3RFjx8H66dfKw_7vnshaOJb9Ox5BAZ9cwwLFMY,377
 lecrapaud/jobs/scheduler.py,sha256=SiYWPxokpKnR8V6btLOO6gbK0PEjSRoeG0kCbQvYPf4,990
 lecrapaud/jobs/tasks.py,sha256=jfhOCsgZlZGTnsLB_K7-Y3NgJqpzpUCFu7EfDQuIeSY,1655
-lecrapaud/model_selection.py,sha256=CZCIxPyFuKcr-jU8Lg-kiPA4idQUv3Tw9788HvHVq7M,62012
+lecrapaud/model_selection.py,sha256=GCA21LGs2G6RqQF188BiJZFP-DNpEhzpTvJlewHFAi4,61504
 lecrapaud/search_space.py,sha256=-JkzuMhaomdwiWi4HvVQY5hiw3-oREemJA16tbwEIp4,34854
 lecrapaud/speed_tests/test-gpu-bilstm.ipynb,sha256=4nLuZRJVe2kn6kEmauhRiz5wkWT9AVrYhI9CEk_dYUY,9608
 lecrapaud/speed_tests/test-gpu-resnet.ipynb,sha256=27Vu7nYwujYeh3fOxBNCnKJn3MXNPKZU-U8oDDUbymg,4944
 lecrapaud/speed_tests/test-gpu-transformers.ipynb,sha256=k6MBSs_Um1h4PykvE-LTBcdpbWLbIFST_xl_AFW2jgI,8444
 lecrapaud/speed_tests/tests.ipynb,sha256=RjI7LDHSsbadUkea_hT14sD7ivljtIQk4NB5McXJ1bE,3835
 lecrapaud/utils.py,sha256=Dy2uhK9cslzoqRHiIE6MdkxjNJWjmKmzGr6i7EYM28A,8106
-lecrapaud-0.8.3.dist-info/LICENSE,sha256=MImCryu0AnqhJE_uAZD-PIDKXDKb8sT7v0i1NOYeHTM,11350
-lecrapaud-0.8.3.dist-info/METADATA,sha256=w6Nq7AP4_mybzw_dTveQm6PbAddeWMtYswdNe2qoVxc,11623
-lecrapaud-0.8.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lecrapaud-0.8.3.dist-info/RECORD,,
+lecrapaud-0.9.0.dist-info/LICENSE,sha256=MImCryu0AnqhJE_uAZD-PIDKXDKb8sT7v0i1NOYeHTM,11350
+lecrapaud-0.9.0.dist-info/METADATA,sha256=GZItqrsRZu_QUCY0hFsdN03454boqWlYIaZh4fIEaHY,11623
+lecrapaud-0.9.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+lecrapaud-0.9.0.dist-info/RECORD,,