maj pour sauvegarder le model

src/base_trainer.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod
 from typing import Union, Optional
 import cupy as cp
 from scipy.sparse import csr_matrix
+import mlflow
 
 from config import Config
 from interfaces.metrics_calculator import MetricsCalculator
@@ -116,7 +117,7 @@ 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é.
         """
-        import mlflow
+        
         # Logue les paramètres du config.model
         if self.config.model.params:
             mlflow.log_params(self.config.model.params)

src/main.py

@@ -7,26 +7,15 @@ import os
 import logging
 import hydra
 from omegaconf import DictConfig, OmegaConf
-
-# 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
-
-# Import des optimizers
 from optimizers.optuna_optimizer import OptunaOptimizer
 from optimizers.ray_tune_optimizer import RayTuneOptimizer
-
-# Import du décorateur MLflow
 from mlflow_integration.mlflow_decorator import MLflowDecorator
-
-# Import de la configuration
 from config import Config
-import mlflow
-
-# Configuration du logging
 logger = logging.getLogger(__name__)
 
 

src/mlflow_integration/mlflow_decorator.py

@@ -4,6 +4,8 @@
 
 from typing import Callable, Dict, Any
 import mlflow
+from hydra.utils import get_original_cwd
+import os
 
 
 class MLflowDecorator:
@@ -66,12 +68,24 @@ class MLflowDecorator:
 
     def _log_artifacts(self, artifacts: Dict[str, Any]) -> None:
         """
-        Logue dans MLflow différents artefacts (fichiers, images, etc.).
-        L'UML mentionne la méthode, mais pas la logique interne.
+        Logue dans MLflow différents artefacts en utilisant mlflow.pyfunc.
+        Gère spécifiquement les modèles cuML avec leur exemple d'entrée.
 
-        :param artifacts: Dictionnaire décrivant les artefacts à logguer.
+        :param artifacts: Dictionnaire contenant les artefacts à logger.
         """
-        pass
+        if "model" in artifacts and "input_example" in artifacts:
+            mlflow.pyfunc.log_model(
+                artifact_path="model",
+                python_model=artifacts["model"],
+                artifacts=artifacts.get("components", {}),
+                input_example=artifacts["input_example"],
+                pip_requirements=os.path.join(get_original_cwd(), "requirements.txt")
+            )
+        else:
+            # Pour les autres types d'artefacts
+            for name, path in artifacts.items():
+                if isinstance(path, str):
+                    mlflow.log_artifact(path, name)
 
     def _end_run(self, status: str) -> None:
         """

src/utilities/cuml_pyfunc_wrapper.py

@@ -5,6 +5,10 @@
 from typing import Any, Dict, Optional
 import pandas as pd
 import numpy as np
+import cudf
+import cupy as cp
+import pickle
+import os
 
 from interfaces.vectorizer import Vectorizer
 
@@ -33,24 +37,38 @@ class CuMLPyFuncWrapper:
         :param context: Contexte de chargement contenant d'éventuelles informations
                         sur l'environnement ou l'emplacement d'artefacts.
         """
-        # Le diagramme UML n'indique pas de logique interne, donc on reste concis.
-        pass
+        
+
+        # Charger le vectorizer depuis les artefacts
+        vectorizer_path = os.path.join(context.artifacts["vectorizer"])
+        with open(vectorizer_path, "rb") as f:
+            self.vectorizer = pickle.load(f)
+
+        # Charger le classifier depuis les artefacts
+        classifier_path = os.path.join(context.artifacts["classifier"])
+        with open(classifier_path, "rb") as f:
+            self.classifier = pickle.load(f)
 
     def predict(self, context: Dict[str, Any],
                 model_input: pd.DataFrame) -> np.ndarray:
         """
         Fonction de prédiction, appelée par MLflow PyFunc.
-        Convertit éventuellement model_input en cudf, vectorise,
-        puis appelle le modèle cuML.
+        Convertit model_input en cudf, vectorise, puis appelle le modèle cuML.
 
-        :param context: Contexte d'exécution éventuel (non défini par l'UML).
+        :param context: Contexte d'exécution éventuel.
         :param model_input: Données d'entrée sous forme de DataFrame pandas.
         :return: Un vecteur numpy des prédictions.
         """
-        # On ne fait aucune hypothèse supplémentaire sur la forme de model_input.
-        # On se contente de renvoyer un np.ndarray.
-        # Logique d'exemple : conversion en array et appel classifier.predict(...)
-        # A adapter selon la forme réelle du classifier.
-        raise NotImplementedError(
-            "La méthode 'predict' doit intégrer la logique de conversion et d'appel cuML."
-        )
+        
+
+        # Convertir le DataFrame pandas en DataFrame cuDF
+        cudf_input = cudf.DataFrame(model_input)
+
+        # Vectoriser les données d'entrée
+        X_vectorized = self.vectorizer.transform(cudf_input)
+
+        # Effectuer la prédiction avec le classifieur cuML
+        predictions_gpu = self.classifier.predict(X_vectorized)
+
+        # Convertir les prédictions GPU en array numpy pour MLflow
+        return cp.asnumpy(predictions_gpu)