maj

src/base_trainer.py

@@ -3,7 +3,7 @@
 # =========================
 
 from abc import ABC, abstractmethod
-from typing import Union, Optional, TYPE_CHECKING
+from typing import Union, Optional
 import cupy as cp
 from scipy.sparse import csr_matrix
 
@@ -55,10 +55,12 @@ class BaseTrainer(ABC):
         pass
 
     @abstractmethod
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Méthode abstraite. Évalue le modèle entraîné, par exemple
         sur un jeu de validation ou de test, et calcule les métriques.
+        
+        :return: Dictionnaire contenant les métriques calculées.
         """
         pass
 
@@ -114,7 +116,14 @@ class BaseTrainer(ABC):
         Implementé ici en tant que méthode non-abstraite, mais la logique de logging
         devrait être assurée dans l'environnement MLflow approprié.
         """
-        pass
+        import mlflow
+        # Logue les paramètres du config.model
+        if self.config.model.params:
+            mlflow.log_params(self.config.model.params)
+
+        # Logue aussi les hyperparamètres du classifieur s'il offre get_params()
+        if self.classifier and hasattr(self.classifier, "get_params"):
+            mlflow.log_params(self.classifier.get_params())
 
     def _prepare_input_for_fit(
             self, X: Union[cp.ndarray,

src/cuml_trainer.py

@@ -57,7 +57,9 @@ class CuMLTrainer(BaseTrainer, ABC):
         data = cudf.read_csv(self.data_path)
 
         # Séparation des textes et des étiquettes
-        texts = data.drop(columns=[self.target_column])
+        # Supposons que la colonne de texte est la première colonne qui n'est pas la colonne cible
+        text_column = [col for col in data.columns if col != self.target_column][0]
+        texts = data[text_column]  # Extraire la série de texte
         labels = data[self.target_column].values
 
         # Vectorisation des textes
@@ -66,7 +68,7 @@ class CuMLTrainer(BaseTrainer, ABC):
         # Entraînement du modèle
         self.classifier.fit(X_prepared, labels)
 
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Évalue le classifieur et calcule les métriques.
         Cette implémentation générique fonctionne pour tous les trainers cuML.
@@ -75,7 +77,9 @@ class CuMLTrainer(BaseTrainer, ABC):
         data = cudf.read_csv(self.data_path)
 
         # Séparation des textes et des étiquettes
-        texts = data.drop(columns=[self.target_column])
+        # Supposons que la colonne de texte est la première colonne qui n'est pas la colonne cible
+        text_column = [col for col in data.columns if col != self.target_column][0]
+        texts = data[text_column]  # Extraire la série de texte
         y_true = data[self.target_column].values
 
         # Vectorisation et prédiction
@@ -93,6 +97,8 @@ class CuMLTrainer(BaseTrainer, ABC):
 
         # Afficher les résultats
         print(f"Métriques d'évaluation {prefix}: {metrics}")
+        
+        return metrics
 
     def _prepare_input_for_fit(self, X: Union[cp.ndarray,
                                               csr_matrix]) -> cp.ndarray:

src/main.py

@@ -24,6 +24,7 @@ from mlflow_integration.mlflow_decorator import MLflowDecorator
 
 # Import de la configuration
 from config import Config
+import mlflow
 
 # Configuration du logging
 logger = logging.getLogger(__name__)
@@ -40,7 +41,7 @@ def get_trainer(config: Config):
         Une instance concrète de BaseTrainer
     """
     model_type = config.model.type.lower()
-    
+
     # Mapping des types de modèles vers leurs trainers
     trainer_map = {
         "svm": SvmTrainer,
@@ -49,10 +50,10 @@ def get_trainer(config: Config):
         "linear_regression": LinearRegressionTrainer,
         "transformer": HuggingFaceTransformerTrainer,
     }
-    
+
     if model_type not in trainer_map:
         raise ValueError(f"Type de modèle non supporté: {model_type}")
-    
+
     # Création de l'instance du trainer avec la configuration
     trainer_class = trainer_map[model_type]
     return trainer_class(
@@ -73,16 +74,16 @@ def get_optimizer(config: Config):
         Une instance concrète de HyperparameterOptimizer
     """
     optimizer_type = config.hyperparameters.optimizer.lower()
-    
+
     # Mapping des types d'optimizers
     optimizer_map = {
         "optuna": OptunaOptimizer,
         "raytune": RayTuneOptimizer,
     }
-    
+
     if optimizer_type not in optimizer_map:
         raise ValueError(f"Type d'optimizer non supporté: {optimizer_type}")
-    
+
     # Création de l'instance de l'optimizer
     optimizer_class = optimizer_map[optimizer_type]
     return optimizer_class()
@@ -99,16 +100,17 @@ def main(cfg: DictConfig) -> None:
     # Conversion de la configuration Hydra en configuration Pydantic
     config_dict = OmegaConf.to_container(cfg, resolve=True)
     config = Config(**config_dict)
-    
+
     logger.info(f"Configuration chargée: {config}")
-    
+
     # Création du trainer approprié
     trainer = get_trainer(config)
-    
+
     # Construction des composants (vectorizer, classifier, etc.)
     trainer.build_components()
-    
-    
+
+
+
     mlflow_decorator = MLflowDecorator(
         experiment_name=config.mlflow.experiment_name,
         tracking_uri=config.mlflow.tracking_uri
@@ -117,23 +119,20 @@ def main(cfg: DictConfig) -> None:
     train_with_mlflow = mlflow_decorator(trainer.train)
     evaluate_with_mlflow = mlflow_decorator(trainer.evaluate)
     log_params_with_mlflow = mlflow_decorator(trainer.log_parameters_to_mlflow)
-    optimize_if_needed_with_mlflow = mlflow_decorator(trainer.optimize_if_needed) # Décorer aussi l'optimisation
-    
+    optimize_if_needed_with_mlflow = mlflow_decorator(trainer.optimize_if_needed)
+
     logger.info("Vérification et lancement de l'optimisation des hyperparamètres si nécessaire (avec MLflow)...")
     optimize_if_needed_with_mlflow()
-    
-    # Exécuter l'entraînement (toujours avec MLflow)
+
     logger.info("Lancement de l'entraînement avec MLflow...")
     train_with_mlflow()
-    
-    # Exécuter l'évaluation (toujours avec MLflow)
+
     logger.info("Lancement de l'évaluation avec MLflow...")
     evaluate_with_mlflow()
 
-    # Logger les paramètres (toujours avec MLflow)
     logger.info("Logging des paramètres avec MLflow...")
     log_params_with_mlflow()
-    
+
     logger.info("Entraînement, évaluation et logging des paramètres terminés avec succès via MLflow.")
 
 

src/mlflow_integration/mlflow_decorator.py

@@ -36,7 +36,7 @@ class MLflowDecorator:
         def wrapper(*args, **kwargs):
             mlflow.set_tracking_uri(self.tracking_uri)
             mlflow.set_experiment(self.experiment_name)
-            with mlflow.start_run():
+            with mlflow.start_run(log_system_metrics=True):
                 result = func(*args, **kwargs)
             return result
 

src/trainers/cuml/linear_regression_trainer.py

@@ -68,13 +68,15 @@ class LinearRegressionTrainer(CuMLTrainer):
         # Inheriting from CuMLTrainer => loads data, vectorizes, fits
         super().train()
 
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Évalue le classifieur LinearRegression et calcule les métriques appropriées.
         
         Utilise l'implémentation fournie par la classe parente CuMLTrainer,
         qui s'occupe du chargement des données, de la vectorisation, de la prédiction
         et du calcul des métriques via le metrics_calculator.
+        
+        :return: Dictionnaire contenant les métriques calculées.
         """
         # Inheriting from CuMLTrainer => loads data, vectorizes, calls the metrics calculator
-        super().evaluate()
+        return super().evaluate()

src/trainers/cuml/logistic_regression_trainer.py

@@ -67,12 +67,14 @@ class LogisticRegressionTrainer(CuMLTrainer):
         """
         super().train()
 
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Évalue le classifieur LogisticRegression et calcule les métriques appropriées.
         
         Utilise l'implémentation fournie par la classe parente CuMLTrainer,
         qui s'occupe du chargement des données, de la vectorisation, de la prédiction
         et du calcul des métriques via le metrics_calculator.
+        
+        :return: Dictionnaire contenant les métriques calculées.
         """
-        super().evaluate()
+        return super().evaluate()

src/trainers/cuml/random_forest_trainer.py

@@ -70,15 +70,17 @@ class RandomForestTrainer(CuMLTrainer):
         """
         super().train()
 
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Évalue le classifieur RandomForest et calcule les métriques appropriées.
         
         Utilise l'implémentation fournie par la classe parente CuMLTrainer,
         qui s'occupe du chargement des données, de la vectorisation, de la prédiction
         et du calcul des métriques via le metrics_calculator.
+        
+        :return: Dictionnaire contenant les métriques calculées.
         """
-        super().evaluate()
+        return super().evaluate()
         
     def _get_binary_predictions(self, X: cp.ndarray) -> cp.ndarray:
         """

src/trainers/cuml/svm_trainer.py

@@ -70,15 +70,17 @@ class SvmTrainer(CuMLTrainer):
         """
         super().train()
 
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Évalue le classifieur SVC et calcule les métriques appropriées.
         
         Utilise l'implémentation fournie par la classe parente CuMLTrainer,
         qui s'occupe du chargement des données, de la vectorisation, de la prédiction
         et du calcul des métriques via le metrics_calculator.
+        
+        :return: Dictionnaire contenant les métriques calculées.
         """
-        super().evaluate()
+        return super().evaluate()
 
     def _get_binary_predictions(self, X: cp.ndarray) -> cp.ndarray:
         """

src/trainers/huggingface/huggingface_transformer_trainer.py

@@ -62,12 +62,15 @@ class HuggingFaceTransformerTrainer(BaseTrainer):
         """
         pass
 
-    def evaluate(self) -> None:
+    def evaluate(self) -> dict:
         """
         Évalue le modèle Hugging Face; la logique de calcul
         des métriques est en partie assurée par le HF Trainer.
+        
+        :return: Dictionnaire contenant les métriques calculées.
         """
-        pass
+        # À implémenter
+        return {}
 
     def _create_torch_dataset(self, texts: cudf.Series,
                               labels: cp.ndarray) -> torch.utils.data.Dataset: