lecrapaud 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

lecrapaud/api.py

@@ -32,6 +32,8 @@ experiment.model_selection(data) : return best_model
 
 import joblib
 import pandas as pd
+import logging
+from lecrapaud.utils import logger
 from lecrapaud.db.session import init_db
 from lecrapaud.feature_selection import FeatureSelectionEngine, PreprocessModel
 from lecrapaud.model_selection import ModelSelectionEngine, ModelEngine
@@ -103,7 +105,12 @@ class Experiment:
         std_data, reshaped_data = self.preprocess_model(train, val, test)
         self.model_selection(std_data, reshaped_data)
 
-    def predict(self, new_data):
+    def predict(self, new_data, verbose: int = 0):
+        if verbose == 0:
+            logger.setLevel(logging.WARNING)
+
+        logger.warning("Running prediction...")
+
         data = self.feature_engineering(
             data=new_data,
             for_training=False,
@@ -127,7 +134,6 @@ class Experiment:
             else:
                 features = self.dataset.get_features(target_number)
             model = ModelEngine(path=training_target_dir)
-            model.load()
 
             # getting data
             if model.recurrent:

lecrapaud/db/alembic/versions/2025_05_31_1834-52b809a34371_make_nullablee.py

@@ -5,6 +5,7 @@ Revises: 339927587383
 Create Date: 2025-05-31 18:34:58.962966
 
 """
+
 from typing import Sequence, Union
 
 from alembic import op
@@ -12,27 +13,38 @@ import sqlalchemy as sa
 from sqlalchemy.dialects import mysql
 
 # revision identifiers, used by Alembic.
-revision: str = '52b809a34371'
-down_revision: Union[str, None] = '339927587383'
+revision: str = "52b809a34371"
+down_revision: Union[str, None] = "339927587383"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('investment_runs', 'initial_portfolio',
-               existing_type=mysql.JSON(),
-               nullable=True)
-    op.create_index(op.f('ix_investment_runs_id'), 'investment_runs', ['id'], unique=False)
-    op.create_foreign_key(None, 'portfolios', 'investment_runs', ['investment_run_id'], ['id'], ondelete='CASCADE')
+    op.alter_column(
+        "investment_runs",
+        "initial_portfolio",
+        existing_type=mysql.JSON(),
+        nullable=True,
+    )
+    op.create_foreign_key(
+        None,
+        "portfolios",
+        "investment_runs",
+        ["investment_run_id"],
+        ["id"],
+        ondelete="CASCADE",
+    )
     # ### end Alembic commands ###
 
 
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint(None, 'portfolios', type_='foreignkey')
-    op.drop_index(op.f('ix_investment_runs_id'), table_name='investment_runs')
-    op.alter_column('investment_runs', 'initial_portfolio',
-               existing_type=mysql.JSON(),
-               nullable=False)
+    op.drop_constraint(None, "portfolios", type_="foreignkey")
+    op.alter_column(
+        "investment_runs",
+        "initial_portfolio",
+        existing_type=mysql.JSON(),
+        nullable=False,
+    )
     # ### end Alembic commands ###

lecrapaud/db/session.py

@@ -4,6 +4,9 @@ from contextlib import contextmanager
 from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker
 from urllib.parse import urlparse
+from alembic.config import Config
+from alembic import command
+import os
 
 from lecrapaud.config import DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_NAME, DB_URI
 
@@ -39,6 +42,14 @@ def init_db(uri: str = None):
     # Step 4: Create session factory
     _SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=_engine)
 
+    # Step 5: Apply Alembic migrations programmatically
+    project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../"))
+    alembic_cfg_path = os.path.join(project_root, "alembic.ini")
+
+    alembic_cfg = Config(alembic_cfg_path)
+    alembic_cfg.set_main_option("sqlalchemy.url", uri or os.getenv("DATABASE_URL"))
+    command.upgrade(alembic_cfg, "head")
+
 
 # Dependency to get a session instance
 @contextmanager

lecrapaud/experiment.py

@@ -5,7 +5,7 @@ from pathlib import Path
 os.environ["COVERAGE_FILE"] = str(Path(".coverage").resolve())
 
 # Internal
-from lecrapaud.directory_management import tmp_dir
+from lecrapaud.directories import tmp_dir
 from lecrapaud.utils import logger
 from lecrapaud.config import PYTHON_ENV
 from lecrapaud.db import (

lecrapaud/feature_engineering.py

@@ -101,7 +101,7 @@ class FeatureEngineeringEngine:
 
     def run(self) -> pd.DataFrame:
         # drop columns
-        self.data = self.data.drop(columns=self.columns_drop)
+        self.data = self.data.drop(columns=self.columns_drop, errors="ignore")
 
         # convert object columns to numeric if possible
         self.data = convert_object_columns_that_are_numeric(self.data)
@@ -324,6 +324,8 @@ class PreprocessFeature:
         **kwargs,
     ):
         self.data = data
+        self.data.columns = self.data.columns.str.upper()
+
         self.dataset = dataset
         self.columns_pca = columns_pca
         self.columns_onehot = columns_onehot
@@ -350,7 +352,7 @@ class PreprocessFeature:
             self.train_val_test_split_time_series()
             if self.time_series
             else self.train_val_test_split(
-                stratify_col=f"target_{self.target_numbers[0]}"
+                stratify_col=f"TARGET_{self.target_numbers[0]}"
             )
         )  # TODO: only stratifying first target for now
 
@@ -359,8 +361,7 @@ class PreprocessFeature:
         val, _ = self.add_pca_features(test, pcas=pcas)
         test, _ = self.add_pca_features(val, pcas=pcas)
 
-        if PYTHON_ENV != "Test":
-            joblib.dump(pcas, f"{self.preprocessing_dir}/pcas.pkl")
+        joblib.dump(pcas, f"{self.preprocessing_dir}/pcas.pkl")
 
         # Encoding
         train, transformer = self.encode_categorical_features(train)
@@ -373,11 +374,10 @@ class PreprocessFeature:
             transformer=transformer,
         )
 
-        if PYTHON_ENV != "Test":
-            joblib.dump(self.data, f"{self.data_dir}/full.pkl")
-            joblib.dump(transformer, f"{self.preprocessing_dir}/column_transformer.pkl")
-            summary = summarize_dataframe(train)
-            summary.to_csv(f"{self.dataset_dir}/feature_summary.csv", index=False)
+        joblib.dump(self.data, f"{self.data_dir}/full.pkl")
+        joblib.dump(transformer, f"{self.preprocessing_dir}/column_transformer.pkl")
+        summary = summarize_dataframe(train)
+        summary.to_csv(f"{self.dataset_dir}/feature_summary.csv", index=False)
 
         return train, val, test
 
@@ -579,8 +579,8 @@ class PreprocessFeature:
         columns_ordinal: list[str] = self.columns_ordinal
         columns_frequency: list[str] = self.columns_frequency
 
-        X = df.loc[:, ~df.columns.str.contains("^target_")]
-        y = df.loc[:, df.columns.str.contains("^target_")]
+        X = df.loc[:, ~df.columns.str.contains("^TARGET_")]
+        y = df.loc[:, df.columns.str.contains("^TARGET_")]
         save_in_db = False
 
         all_columns = (
@@ -643,7 +643,6 @@ class PreprocessFeature:
 
         # Try to convert columns to best possible dtypes
         X_transformed = X_transformed.convert_dtypes()
-        X_transformed.columns = X_transformed.columns.str.upper()
 
         # Insert features in db
         if save_in_db:

lecrapaud/feature_selection.py

@@ -37,7 +37,7 @@ from sklearn.preprocessing import StandardScaler, MinMaxScaler
 from scipy.stats import spearmanr, kendalltau
 
 # Internal
-from lecrapaud.directory_management import tmp_dir, clean_directory
+from lecrapaud.directories import tmp_dir, clean_directory
 from lecrapaud.utils import logger
 from lecrapaud.config import PYTHON_ENV
 from lecrapaud.db import (
@@ -50,10 +50,6 @@ from lecrapaud.db import (
 from lecrapaud.db.session import get_db
 from lecrapaud.search_space import all_models
 
-# Variables for targets handling
-TARGETS_MCLF = [11]
-GROUPING_COLUMN = "STOCK"
-
 # Annoying Warnings
 warnings.filterwarnings("ignore", category=FutureWarning)
 
@@ -103,7 +99,7 @@ class FeatureSelectionEngine:
     # Main feature selection function
     def run(
         self,
-        single_process: bool = False,
+        single_process: bool = True,
     ):
         """Function to do feature selection with a range of different feature selection technics
 
@@ -114,10 +110,7 @@ class FeatureSelectionEngine:
         """
         target_number = self.target_number
         target_type = self.target_type
-        if PYTHON_ENV != "Test":
-            fs_dir_target = self.fs_dir_target
-        else:
-            fs_dir_target = None
+        fs_dir_target = self.fs_dir_target
 
         # Create the feature selection in db
         target = Target.find_by(name=f"TARGET_{target_number}")
@@ -162,7 +155,7 @@ class FeatureSelectionEngine:
         # handling categorical features (only if classification)
         self.X_categorical, self.X_numerical = get_features_by_types(self.X)
 
-        if target_type == "classification":
+        if target_type == "classification" and self.X_categorical.shape[1] > 0:
             feat_scores = self.select_categorical_features(
                 percentile=percentile, save_dir=fs_dir_target
             )
@@ -292,24 +285,22 @@ class FeatureSelectionEngine:
             f"We selected {len(features_selected_list)} features and {len(features_selected_by_every_methods)} were selected unanimously:"
         )
         logger.debug(features_selected_by_every_methods)
-        if PYTHON_ENV != "Test":
-            pd.Series(features_selected_list).to_csv(
-                f"{fs_dir_target}/features_before_corr.csv",
-                index=True,
-                header=True,
-                index_label="ID",
-            )
+        pd.Series(features_selected_list).to_csv(
+            f"{fs_dir_target}/features_before_corr.csv",
+            index=True,
+            header=True,
+            index_label="ID",
+        )
 
         # removing correlated features
         self.X = self.X[features_selected_list]
         features, features_correlated = self.remove_correlated_features(corr_threshold)
-        if PYTHON_ENV != "Test":
-            pd.Series(features).to_csv(
-                f"{fs_dir_target}/features_before_max.csv",
-                index=True,
-                header=True,
-                index_label="ID",
-            )
+        pd.Series(features).to_csv(
+            f"{fs_dir_target}/features_before_max.csv",
+            index=True,
+            header=True,
+            index_label="ID",
+        )
         features = features[:max_features]
 
         # adding categorical features selected
@@ -337,8 +328,7 @@ class FeatureSelectionEngine:
         best_features_path = Path(
             f"{self.preprocessing_dir}/features_{target_number}.pkl"
         ).resolve()
-        if PYTHON_ENV != "Test":
-            joblib.dump(features, best_features_path)
+        joblib.dump(features, best_features_path)
 
         # save in db
         db_features = Feature.filter(name__in=features)
@@ -798,6 +788,7 @@ class PreprocessModel:
 
         self.dataset_dir = dataset.path
         self.data_dir = f"{self.dataset_dir}/data"
+        self.preprocessing_dir = f"{self.dataset_dir}/preprocessing"
 
         self.all_features = dataset.get_all_features(
             date_column=date_column, group_column=group_column
@@ -819,31 +810,23 @@ class PreprocessModel:
 
     def run(self):
         # save data
-        if PYTHON_ENV != "Test":
-            joblib.dump(self.train, f"{self.data_dir}/train.pkl")
-            joblib.dump(self.val, f"{self.data_dir}/val.pkl")
-            joblib.dump(self.test, f"{self.data_dir}/test.pkl")
-            preprocessing_dir = f"{self.dataset_dir}/preprocessing"
-        else:
-            preprocessing_dir = None
+        joblib.dump(self.train, f"{self.data_dir}/train.pkl")
+        joblib.dump(self.val, f"{self.data_dir}/val.pkl")
+        joblib.dump(self.test, f"{self.data_dir}/test.pkl")
 
         # scaling features
         if any(t not in self.target_clf for t in self.target_numbers) and any(
             all_models[i].get("need_scaling") for i in self.models_idx
         ):
             logger.info("Scaling features...")
-            train_scaled, scaler_x, scalers_y = self.scale_data(
-                self.train, save_dir=preprocessing_dir
-            )
+            train_scaled, scaler_x, scalers_y = self.scale_data(self.train)
             val_scaled, _, _ = self.scale_data(
                 self.val,
-                save_dir=preprocessing_dir,
                 scaler_x=scaler_x,
                 scalers_y=scalers_y,
             )
             test_scaled, _, _ = self.scale_data(
                 self.test,
-                save_dir=preprocessing_dir,
                 scaler_x=scaler_x,
                 scalers_y=scalers_y,
             )
@@ -853,10 +836,9 @@ class PreprocessModel:
             test_scaled = None
 
         # save data
-        if PYTHON_ENV != "Test":
-            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(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")
 
         data = {
             "train": self.train,
@@ -923,7 +905,6 @@ class PreprocessModel:
     def scale_data(
         self,
         df: pd.DataFrame,
-        save_dir: str,
         scaler_x=None,
         scalers_y: Optional[list] = None,
     ):
@@ -939,8 +920,7 @@ class PreprocessModel:
             X_scaled = pd.DataFrame(
                 scaler_x.fit_transform(X), columns=list(X.columns), index=X.index
             )
-            if save_dir:
-                joblib.dump(scaler_x, f"{save_dir}/scaler_x.pkl")
+            joblib.dump(scaler_x, f"{self.preprocessing_dir}/scaler_x.pkl")
 
         # Determine which targets need to be scaled
         targets_numbers_to_scale = [
@@ -969,8 +949,9 @@ class PreprocessModel:
                     columns=y.columns,
                     index=y.index,
                 )
-                if save_dir:
-                    joblib.dump(scaler_y, f"{save_dir}/scaler_y_{target_number}.pkl")
+                joblib.dump(
+                    scaler_y, f"{self.preprocessing_dir}/scaler_y_{target_number}.pkl"
+                )
 
                 scalers_y[f"scaler_y_{target_number}"] = scaler_y
                 scaled_targets[target_number] = scaled_y

lecrapaud/model_selection.py

@@ -65,7 +65,7 @@ from ray.air import session
 
 # Internal library
 from lecrapaud.search_space import all_models
-from lecrapaud.directory_management import clean_directory
+from lecrapaud.directories import clean_directory
 from lecrapaud.utils import copy_any, contains_best, logger, serialize_for_json
 from lecrapaud.config import PYTHON_ENV
 from lecrapaud.feature_selection import load_train_data
@@ -120,8 +120,9 @@ class ModelEngine:
         plot: bool = False,
         log_dir: str = None,
     ):
+        self.path = path
         if path:
-            self.load(path)
+            self.load()
         else:
             self.model_name = model_name
             self.target_type = target_type
@@ -134,6 +135,7 @@ class ModelEngine:
                 f"Model {self.model_name} is not supported by this library."
                 f"Choose a model from the list of supported models: {[model['model_name'] for model in all_models].join(', ')}"
             )
+        config = config[0]
 
         self.recurrent = config["recurrent"]
         self.need_scaling = config["need_scaling"]
@@ -147,7 +149,7 @@ class ModelEngine:
         else:
             self.scaler_y = None
 
-        self.path = path
+        self.threshold = None
 
     def fit(self, *args):
         if self.recurrent:
@@ -629,9 +631,6 @@ class ModelEngine:
         self.model_name = self._model.model_name
         self.target_type = self._model.target_type
 
-    def __getattr__(self, attr):
-        return getattr(self._model, attr)
-
 
 def trainable(
     params,
@@ -778,20 +777,20 @@ class ModelSelectionEngine:
             raise ValueError("Please provide a dataset.")
 
         if self.data:
-            self.train = self.data["train"]
-            self.val = self.data["val"]
-            self.test = self.data["test"]
-            self.train_scaled = self.data["train_scaled"]
-            self.val_scaled = self.data["val_scaled"]
-            self.test_scaled = self.data["test_scaled"]
+            train = self.data["train"]
+            val = self.data["val"]
+            test = self.data["test"]
+            train_scaled = self.data["train_scaled"]
+            val_scaled = self.data["val_scaled"]
+            test_scaled = self.data["test_scaled"]
         else:
             (
-                self.train,
-                self.val,
-                self.test,
-                self.train_scaled,
-                self.val_scaled,
-                self.test_scaled,
+                train,
+                val,
+                test,
+                train_scaled,
+                val_scaled,
+                test_scaled,
             ) = load_train_data(self.dataset_dir, self.target_number, self.target_clf)
 
         if (
@@ -810,10 +809,12 @@ class ModelSelectionEngine:
                 raise ValueError("reshaped_data is not provided.")
 
             logger.info("Loading reshaped data...")
-            self.x_train_reshaped = self.reshaped_data["x_train_reshaped"]
-            self.y_train_reshaped = self.reshaped_data["y_train_reshaped"]
-            self.x_val_reshaped = self.reshaped_data["x_val_reshaped"]
-            self.y_val_reshaped = self.reshaped_data["y_val_reshaped"]
+            x_train_reshaped = self.reshaped_data["x_train_reshaped"]
+            y_train_reshaped = self.reshaped_data["y_train_reshaped"]
+            x_val_reshaped = self.reshaped_data["x_val_reshaped"]
+            y_val_reshaped = self.reshaped_data["y_val_reshaped"]
+            x_test_reshaped = self.reshaped_data["x_test_reshaped"]
+            y_test_reshaped = self.reshaped_data["y_test_reshaped"]
 
         # create model selection in db
         target = Target.find_by(name=f"TARGET_{self.target_number}")
@@ -864,42 +865,41 @@ class ModelSelectionEngine:
                     if e in set(self.features)
                 ]
                 # TODO: Verify that features_idx are the right one, because scaling can re-arrange columns...
-                self.x_train = self.x_train_reshaped[:, :, features_idx]
-                self.y_train = self.y_train_reshaped[:, [self.target_number, 0]]
-                self.x_val = self.x_val_reshaped[:, :, features_idx]
-                self.y_val = self.y_val_reshaped[:, [self.target_number, 0]]
+                x_train = x_train_reshaped[:, :, features_idx]
+                y_train = y_train_reshaped[:, [self.target_number, 0]]
+                x_val = x_val_reshaped[:, :, features_idx]
+                y_val = y_val_reshaped[:, [self.target_number, 0]]
+                x_test = x_test_reshaped[:, :, features_idx]
+                y_test = y_test_reshaped[:, [self.target_number, 0]]
             else:
                 config = config[self.target_type]
 
                 if need_scaling and self.target_type == "regression":
-                    self.x_train = self.train_scaled[self.features]
-                    self.y_train = self.train_scaled[
-                        f"TARGET_{self.target_number}"
-                    ].rename("TARGET")
-                    self.x_val = self.val_scaled[self.features]
-                    self.y_val = self.val_scaled[f"TARGET_{self.target_number}"].rename(
+                    x_train = train_scaled[self.features]
+                    y_train = train_scaled[f"TARGET_{self.target_number}"].rename(
                         "TARGET"
                     )
-                else:
-                    self.x_train = self.train[self.features]
-                    self.y_train = self.train[f"TARGET_{self.target_number}"].rename(
-                        "TARGET"
-                    )
-                    self.x_val = self.val[self.features]
-                    self.y_val = self.val[f"TARGET_{self.target_number}"].rename(
+                    x_val = val_scaled[self.features]
+                    y_val = val_scaled[f"TARGET_{self.target_number}"].rename("TARGET")
+                    x_test = test_scaled[self.features]
+                    y_test = test_scaled[f"TARGET_{self.target_number}"].rename(
                         "TARGET"
                     )
+                else:
+                    x_train = train[self.features]
+                    y_train = train[f"TARGET_{self.target_number}"].rename("TARGET")
+                    x_val = val[self.features]
+                    y_val = val[f"TARGET_{self.target_number}"].rename("TARGET")
+                    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)
             # instantiate model
             model = ModelEngine(
                 model_name=model_name,
-                recurrent=recurrent,
-                need_scaling=need_scaling,
                 search_params=config["search_params"],
                 target_type=self.target_type,
                 create_model=config["create_model"],
-                scaler_y=self.scaler_y,
                 plot=self.plot,
                 log_dir=log_dir,
             )
@@ -907,7 +907,7 @@ class ModelSelectionEngine:
             start = time.time()
             # Tuning hyperparameters
             if perform_hyperopt:
-                best_params = self.hyperoptimize(model)
+                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"
@@ -932,8 +932,8 @@ class ModelSelectionEngine:
 
             # Perform cross-validation of the best model on k-folds of train + val set
             if perform_crossval:
-                x_train_val = pd.concat([self.x_train, self.x_val, self.x_test], axis=0)
-                y_train_val = pd.concat([self.y_train, self.y_val, self.y_test], axis=0)
+                x_train_val = pd.concat([x_train, x_val, x_test], axis=0)
+                y_train_val = pd.concat([y_train, y_val, y_test], axis=0)
                 n_splits = 4
                 n_samples = len(x_train_val)
                 test_size = int(n_samples / (n_splits + 4))
@@ -946,7 +946,7 @@ class ModelSelectionEngine:
                     self.type_name = f"crossval_fold_{i}"
 
                     if self.time_series:
-                        date_series = self.train[self.date_column].copy()
+                        date_series = train[self.date_column].copy()
 
                         if need_scaling:
                             date_series = date_series.map(pd.Timestamp.fromordinal)
@@ -1000,10 +1000,10 @@ class ModelSelectionEngine:
                 # Retrain on entire training set, but keep score on cross-validation folds
                 best_score, best_model, best_pred = self.train_model(
                     params=best_params,
-                    x_train=pd.concat([self.x_train, self.x_val], axis=0),
-                    y_train=pd.concat([self.y_train, self.y_val], axis=0),
-                    x_val=self.x_test,
-                    y_val=self.y_test,
+                    x_train=pd.concat([x_train, x_val], axis=0),
+                    y_train=pd.concat([y_train, y_val], axis=0),
+                    x_val=x_test,
+                    y_val=y_test,
                     model=model,
                 )
                 best_score = cross_validation_mean_score
@@ -1012,10 +1012,10 @@ class ModelSelectionEngine:
                 self.type_name = "validation"
                 best_score, best_model, best_pred = self.train_model(
                     params=best_params,
-                    x_train=pd.concat([self.x_train, self.x_val], axis=0),
-                    y_train=pd.concat([self.y_train, self.y_val], axis=0),
-                    x_val=self.x_test,
-                    y_val=self.y_test,
+                    x_train=pd.concat([x_train, x_val], axis=0),
+                    y_train=pd.concat([y_train, y_val], axis=0),
+                    x_val=x_test,
+                    y_val=y_test,
                     model=model,
                 )
 
@@ -1117,7 +1117,7 @@ class ModelSelectionEngine:
 
         logger.info(f"Best model overall is : {best_score_overall}")
 
-    def hyperoptimize(self, model: ModelEngine):
+    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):
@@ -1143,10 +1143,10 @@ class ModelSelectionEngine:
         tuner = Tuner(
             trainable=with_parameters(
                 trainable,
-                x_train=self.x_train,
-                y_train=self.y_train,
-                x_val=self.x_val,
-                y_val=self.y_val,
+                x_train=x_train,
+                y_train=y_train,
+                x_val=x_val,
+                y_val=y_val,
                 model_name=model.model_name,
                 target_type=self.target_type,
                 session_name=self.session_name,

lecrapaud/utils.py

@@ -10,7 +10,7 @@ import unicodedata
 import re
 import string
 
-from lecrapaud.directory_management import logger_dir
+from lecrapaud.directories import logger_dir
 from lecrapaud.config import LOGGING_LEVEL, PYTHON_ENV
 
 _LOGGER_ALREADY_CONFIGURED = False