correction bug config

src/base_trainer.py

@@ -6,9 +6,11 @@ from abc import ABC, abstractmethod
 from typing import Union, Optional
 import cupy as cp
 from scipy.sparse import csr_matrix
+from src.optimizers.optuna_optimizer import OptunaOptimizer
+from src.optimizers.ray_tune_optimizer import RayTuneOptimizer
 
-from config import Config
-from interfaces.metrics_calculator import MetricsCalculator
+from src.config import Config
+from src.interfaces.metrics_calculator import MetricsCalculator
 
 
 class BaseTrainer(ABC):
@@ -73,34 +75,32 @@ class BaseTrainer(ABC):
         logger = logging.getLogger(__name__)
 
         # Vérifier si l'optimisation est configurée
-        if (self.config.hyperparameters.optimizer and 
-            self.config.hyperparameters.param_grid and 
+        if (self.config.hyperparameters.optimizer and
+            self.config.hyperparameters.param_grid and
             self.config.hyperparameters.n_trials > 0):
-            
+
             logger.info("Démarrage de l'optimisation des hyperparamètres")
-            
+
             # Importation et instanciation de l'optimiseur
             optimizer_type = self.config.hyperparameters.optimizer.lower()
             if optimizer_type == "optuna":
-                from optimizers.optuna_optimizer import OptunaOptimizer
                 optimizer = OptunaOptimizer()
             elif optimizer_type == "raytune":
-                from optimizers.ray_tune_optimizer import RayTuneOptimizer
                 optimizer = RayTuneOptimizer()
             else:
                 raise ValueError(f"Type d'optimizer non supporté: {optimizer_type}")
-            
+
             # Lancement de l'optimisation
             best_params = optimizer.optimize(
                 trainer=self,  # Passe l'instance actuelle du trainer
                 param_grid=self.config.hyperparameters.param_grid
             )
-            
+
             logger.info(f"Meilleurs hyperparamètres trouvés: {best_params}")
-            
+
             # Mise à jour de la configuration du modèle avec les meilleurs paramètres
             self.config.model.params.update(best_params)
-            
+
             # Reconstruire les composants avec les nouveaux paramètres
             logger.info("Reconstruction des composants avec les hyperparamètres optimisés.")
             self.build_components()

src/conf/config.yaml

@@ -1,7 +1,7 @@
 # conf/config.yaml
 
 defaults:
-  - models: models  
+  - model: model  
   - _self_
 
 model:

src/config.py

@@ -68,12 +68,28 @@ class HyperparameterConfig(BaseModel):
         description="Nombre d'essais pour la recherche d'hyperparamètres.")
 
 
+class MLflowConfig(BaseModel):
+    """
+    Représente la configuration pour MLflow, incluant le nom de l'expérience
+    et l'URI de tracking.
+    """
+    experiment_name: str = Field(
+        ...,
+        description="Nom de l'expérience MLflow."
+    )
+    tracking_uri: str = Field(
+        ...,
+        description="URI de tracking MLflow."
+    )
+
+
 class Config(BaseModel):
     """
     Objet de configuration global combinant la section modèle, vectorisation,
-    données et hyperparamètres.
+    données, hyperparamètres et MLflow.
     """
     model: ModelConfig
     vectorization: VectorizationConfig
     data: DataConfig
     hyperparameters: HyperparameterConfig
+    mlflow: MLflowConfig

src/cuml_trainer.py

@@ -6,10 +6,11 @@ from abc import ABC, abstractmethod
 from typing import Union
 import cupy as cp
 from scipy.sparse import csr_matrix
+import cudf
 
-from config import Config
-from base_trainer import BaseTrainer
-from interfaces.vectorizer import Vectorizer
+from src.config import Config
+from src.base_trainer import BaseTrainer
+from src.interfaces.vectorizer import Vectorizer
 
 
 class CuMLTrainer(BaseTrainer, ABC):
@@ -52,17 +53,16 @@ class CuMLTrainer(BaseTrainer, ABC):
         Cette implémentation générique fonctionne pour tous les trainers cuML.
         """
         # Chargement des données
-        import cudf
+
         data = cudf.read_csv(self.data_path)
-        
+
         # Séparation des textes et des étiquettes
         texts = data.drop(columns=[self.target_column])
         labels = data[self.target_column].values
-        
+
         # Vectorisation des textes
         X = self.vectorizer.fit_transform(texts)
         X_prepared = self._prepare_input_for_fit(X)
-        
         # Entraînement du modèle
         self.classifier.fit(X_prepared, labels)
 
@@ -72,18 +72,17 @@ class CuMLTrainer(BaseTrainer, ABC):
         Cette implémentation générique fonctionne pour tous les trainers cuML.
         """
         # Chargement des données (idéalement un jeu de test séparé)
-        import cudf
         data = cudf.read_csv(self.data_path)
-        
+
         # Séparation des textes et des étiquettes
         texts = data.drop(columns=[self.target_column])
         y_true = data[self.target_column].values
-        
+
         # Vectorisation et prédiction
         X = self.vectorizer.transform(texts)
         X_prepared = self._prepare_input_for_predict(X)
         y_pred = self.classifier.predict(X_prepared)
-        
+
         # Calcul et logging des métriques
         prefix = self.config.model.type.lower()
         metrics = self.metrics_calculator.calculate_and_log(
@@ -91,7 +90,7 @@ class CuMLTrainer(BaseTrainer, ABC):
             y_pred=y_pred,
             prefix=prefix
         )
-        
+
         # Afficher les résultats
         print(f"Métriques d'évaluation {prefix}: {metrics}")
 

src/interfaces/metrics_calculator.py

@@ -1,9 +1,34 @@
 import cupy as cp
 import numpy as np
-from typing import Dict
+from typing import Dict, Protocol
 import logging
 from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
-from interfaces.metrics_calculator import MetricsCalculator
+
+class MetricsCalculator(Protocol):
+    """
+    Interface pour les calculateurs de métriques.
+    """
+    def calculate_and_log(
+        self,
+        y_true: cp.ndarray,
+        y_pred: cp.ndarray,
+        prefix: str
+    ) -> Dict[str, float]:
+        """
+        Calcule et log les métriques pour un problème binaire.
+        """
+        pass
+    
+    def calculate_and_log_multiclass(
+        self,
+        y_true: cp.ndarray,
+        y_pred: cp.ndarray,
+        prefix: str
+    ) -> Dict[str, float]:
+        """
+        Calcule et log les métriques pour un problème multiclasses.
+        """
+        pass
 
 logger = logging.getLogger(__name__)
 
@@ -81,4 +106,4 @@ class DefaultMetricsCalculator(MetricsCalculator):
             f"{prefix}_auc_roc"   : auc
         }
         logger.info(f"[{prefix}] Multiclass metrics: {metrics}")
-        return metrics
+        return metrics

src/main.py

@@ -10,21 +10,21 @@ from omegaconf import DictConfig, OmegaConf
 import mlflow
 
 # Import des trainers
-from trainers.cuml.svm_trainer import SvmTrainer
-from trainers.cuml.random_forest_trainer import RandomForestTrainer
-from trainers.cuml.logistic_regression_trainer import LogisticRegressionTrainer
-from trainers.cuml.linear_regression_trainer import LinearRegressionTrainer
-from trainers.huggingface.huggingface_transformer_trainer import HuggingFaceTransformerTrainer
+from src.trainers.cuml.svm_trainer import SvmTrainer
+from src.trainers.cuml.random_forest_trainer import RandomForestTrainer
+from src.trainers.cuml.logistic_regression_trainer import LogisticRegressionTrainer
+from src.trainers.cuml.linear_regression_trainer import LinearRegressionTrainer
+from src.trainers.huggingface.huggingface_transformer_trainer import HuggingFaceTransformerTrainer
 
 # Import des optimizers
-from optimizers.optuna_optimizer import OptunaOptimizer
-from optimizers.ray_tune_optimizer import RayTuneOptimizer
+from src.optimizers.optuna_optimizer import OptunaOptimizer
+from src.optimizers.ray_tune_optimizer import RayTuneOptimizer
 
 # Import du décorateur MLflow
-from mlflow_integration.mlflow_decorator import MLflowDecorator
+from src.mlflow_integration.mlflow_decorator import MLflowDecorator
 
 # Import de la configuration
-from config import Config
+from src.config import Config
 
 # Configuration du logging
 logger = logging.getLogger(__name__)
@@ -89,7 +89,7 @@ def get_optimizer(config: Config):
     return optimizer_class()
 
 
-@hydra.main(config_path="conf", config_name="config")
+@hydra.main(config_path="conf", config_name="config", version_base=None)
 def main(cfg: DictConfig) -> None:
     """
     Point d'entrée principal de l'application.
@@ -139,4 +139,4 @@ def main(cfg: DictConfig) -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

src/trainers/cuml/linear_regression_trainer.py

@@ -4,10 +4,10 @@
 
 from cuml.linear_model import LinearRegression
 
-from cuml_trainer import CuMLTrainer
-from config import Config
-from interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
-from interfaces.metrics_calculator import DefaultMetricsCalculator
+from src.cuml_trainer import CuMLTrainer
+from src.config import Config
+from src.interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
+from src.interfaces.metrics_calculator import DefaultMetricsCalculator
 
 class LinearRegressionTrainer(CuMLTrainer):
     """

src/trainers/cuml/logistic_regression_trainer.py

@@ -4,10 +4,10 @@
 
 from cuml.linear_model import LogisticRegression
 
-from cuml_trainer import CuMLTrainer
-from config import Config
-from interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
-from interfaces.metrics_calculator import DefaultMetricsCalculator
+from src.cuml_trainer import CuMLTrainer
+from src.config import Config
+from src.interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
+from src.interfaces.metrics_calculator import DefaultMetricsCalculator
 
 class LogisticRegressionTrainer(CuMLTrainer):
     """

src/trainers/cuml/random_forest_trainer.py

@@ -6,10 +6,10 @@ from typing import Optional
 from cuml.ensemble import RandomForestClassifier
 import cupy as cp
 
-from cuml_trainer import CuMLTrainer
-from config import Config
-from interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
-from interfaces.metrics_calculator import DefaultMetricsCalculator
+from src.cuml_trainer import CuMLTrainer
+from src.config import Config
+from src.interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
+from src.interfaces.metrics_calculator import DefaultMetricsCalculator
 
 class RandomForestTrainer(CuMLTrainer):
     """

src/trainers/cuml/svm_trainer.py

@@ -6,10 +6,10 @@ from cuml.svm import SVC
 import cupy as cp
 from typing import Optional
 
-from cuml_trainer import CuMLTrainer
-from config import Config
-from interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
-from interfaces.metrics_calculator import DefaultMetricsCalculator
+from src.cuml_trainer import CuMLTrainer
+from src.config import Config
+from src.interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
+from src.interfaces.metrics_calculator import DefaultMetricsCalculator
 
 class SvmTrainer(CuMLTrainer):
     """

src/trainers/huggingface/huggingface_transformer_trainer.py

@@ -8,8 +8,8 @@ import cudf
 import torch
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
 
-from base_trainer import BaseTrainer
-from config import Config
+from src.base_trainer import BaseTrainer
+from src.config import Config
 
 
 class HuggingFaceTransformerTrainer(BaseTrainer):