initialisation

.gitattributes

@@ -25,7 +25,6 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +32,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+aim_repo.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,183 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+chunks/
+
+check_ins
+
+meta/
+
+seqs/
+locks/

Dockerfile

@@ -0,0 +1,47 @@
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04 AS runtime
+
+# Désactiver l'interactivité
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Installer les outils de base nécessaires
+RUN apt-get update && apt-get install -y \
+      bash \
+      curl \
+      git \
+      git-lfs \
+      wget \
+      procps \
+      build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV XDG_BIN_HOME=/usr/local/bin
+
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Créer l'utilisateur non privilégié avec UID 1000 et préparer le répertoire de l'application
+RUN useradd -m -u 1000 aim_user && \
+    mkdir -p /app && \
+    chown -R 1000:1000 /app
+
+RUN echo "alias venv='source .venv/bin/activate'" >> /etc/bash.bashrc
+
+WORKDIR /app
+
+USER 1000
+
+COPY --chown=1000:1000 requirements.txt /app/
+
+# Initialiser UV, créer l'environnement virtuel, installer les dépendances et purger le cache pip
+RUN uv init --python 3.11 --no-managed-python --no-workspace && \
+    uv venv && \
+    . /app/.venv/bin/activate && \
+    uv add -r requirements.txt && \
+    uv run --with pip --with spacy -- spacy download en_core_web_sm && \
+    uv cache prune
+    
+# Copier le reste du code source dans /app
+COPY --chown=1000:1000 src/ /app/
+
+ENV PATH="/app/.venv/bin:${PATH}"
+
+CMD ["mlflow", "ui", "--backend-store-uri", "file:///data/mlruns", "--host", "0.0.0.0", "--port", "7860"]

requirements.txt

@@ -0,0 +1,23 @@
+hydra-core
+omegaconf
+mlflow
+pydantic
+cupy
+cudf
+scikit-learn
+scipy
+numpy
+pandas
+optuna
+ray[tune]
+transformers
+torch
+datasets
+seaborn
+matplotlib
+cupy-cuda12x
+cuml-cu12==25.2.*
+cudf-cu12==25.2.*
+torchvision
+accelerate
+transformers

src/base_trainer.py

@@ -0,0 +1,174 @@
+# =========================
+# Fichier: base_trainer.py
+# =========================
+
+from abc import ABC, abstractmethod
+from typing import Union, Optional
+import cupy as cp
+from scipy.sparse import csr_matrix
+
+from config import Config
+from interfaces.metrics_calculator import MetricsCalculator
+
+
+class BaseTrainer(ABC):
+    """
+    Classe de base abstraite représentant un entraîneur (trainer) générique,
+    tel que défini dans le diagramme UML.
+
+    Attributs:
+        config (Config): Configuration globale du système (modèle, data, etc.).
+        classifier (object): Référence vers le classifieur ou le modèle entraîné.
+        metrics_calculator (MetricsCalculator): Outil de calcul et de logging des métriques.
+        data_path (str): Chemin vers les données.
+        target_column (str): Nom de la colonne cible dans les données.
+    """
+
+    def __init__(self, config: Config, data_path: str,
+                 target_column: str) -> None:
+        """
+        Initialise un trainer générique avec la configuration et les informations de chemin de données.
+
+        :param config: Objet de configuration global.
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible pour l'entraînement/prédiction.
+        """
+        self.config: Config = config
+        self.data_path: str = data_path
+        self.target_column: str = target_column
+        self.classifier: object = None
+        self.metrics_calculator: MetricsCalculator = None
+
+    @abstractmethod
+    def build_components(self) -> None:
+        """
+        Méthode abstraite. Instancie les composants nécessaires
+        (e.g. le classifieur, éventuellement le vectorizer) selon la config.
+        """
+        pass
+
+    @abstractmethod
+    def train(self) -> None:
+        """
+        Méthode abstraite. Lance la procédure d'entraînement.
+        """
+        pass
+
+    @abstractmethod
+    def evaluate(self) -> None:
+        """
+        Méthode abstraite. Évalue le modèle entraîné, par exemple
+        sur un jeu de validation ou de test, et calcule les métriques.
+        """
+        pass
+
+    def optimize_if_needed(self) -> None:
+        """
+        Vérifie la configuration pour déterminer si l'optimisation des hyperparamètres
+        est nécessaire. Si oui, instancie l'optimiseur approprié et lance
+        le processus d'optimisation. Met ensuite à jour la configuration du modèle
+        avec les meilleurs paramètres trouvés et reconstruit les composants.
+        """
+        import logging
+        logger = logging.getLogger(__name__)
+
+        # Vérifier si l'optimisation est configurée
+        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()
+        else:
+            logger.info("Aucune optimisation des hyperparamètres configurée.")
+
+    def log_parameters_to_mlflow(self) -> None:
+        """
+        Appelle une fonction singledispatch (get_relevant_params_for_logging(trainer)) pour récupérer
+        les paramètres pertinents et les logguer, par exemple via MLflow.
+        Implementé ici en tant que méthode non-abstraite, mais la logique de logging
+        devrait être assurée dans l'environnement MLflow approprié.
+        """
+        pass
+
+    def _prepare_input_for_fit(
+            self, X: Union[cp.ndarray,
+                           csr_matrix]) -> Union[cp.ndarray, csr_matrix]:
+        """
+        Méthode utilitaire pour préparer les données d'entraînement avant
+        l'ajustement du modèle.
+
+        :param X: Matrice (cupy.ndarray ou scipy.sparse.csr_matrix) représentant les données.
+        :return: Matrice transformée ou identique, prête pour l'entraînement.
+        """
+        return X
+
+    def _prepare_input_for_predict(
+            self, X: Union[cp.ndarray,
+                           csr_matrix]) -> Union[cp.ndarray, csr_matrix]:
+        """
+        Méthode utilitaire pour préparer les données de prédiction avant
+        l'appel à la méthode `predict` du modèle.
+
+        :param X: Matrice (cupy.ndarray ou scipy.sparse.csr_matrix) représentant les données.
+        :return: Matrice transformée ou identique, prête pour la prédiction.
+        """
+        return X
+
+    def _get_binary_predictions(self, X: cp.ndarray) -> cp.ndarray:
+        """
+        Retourne un vecteur de prédictions binaires (0/1).
+
+        :param X: Matrice de données de dimension (n_samples, n_features),
+                  déjà sous forme cupy.ndarray.
+        :return: Vecteur de prédictions binaires (cupy.ndarray).
+        """
+        # Ici, la logique de conversion en 0/1 n'est pas spécifiée dans l'UML,
+        # donc on la laisse minimale (raise NotImplementedError si nécessaire).
+        raise NotImplementedError(
+            "La méthode '_get_binary_predictions' doit être implémentée dans une sous-classe."
+        )
+
+    def _get_positive_probabilities(self,
+                                    X: cp.ndarray) -> Optional[cp.ndarray]:
+        """
+        Retourne la probabilité d'appartenir à la classe positive pour chaque échantillon,
+        si le modèle le permet. Sinon, retourne None.
+
+        :param X: Matrice de données en cupy.ndarray.
+        :return: Vecteur de probabilités (cupy.ndarray) ou None si non applicable.
+        """
+        return None
+
+    def _get_label_dtype(self) -> cp.dtype:
+        """
+        Retourne le type cupy.dtype approprié pour les labels.
+
+        :return: Par exemple, cp.int32.
+        """
+        return cp.int32

src/conf/config.yaml

@@ -0,0 +1,32 @@
+# conf/config.yaml
+
+defaults:
+  - models: models  
+  - _self_
+
+model:
+  type: "svm"
+
+data:
+  path: "dataset/dataset.csv"
+  target_column: "label"
+
+vectorization:
+  method: "tfidf"
+
+mlflow:
+  experiment_name: "experiment-${model.type}" 
+  tracking_uri: "file:///data/mlruns"
+
+hyperparameters:
+  optimizer: "optuna"
+  param_grid:
+    C: [0.1, 1, 10, 100]
+    kernel:
+      - "linear"
+      - "rbf"
+    gamma:
+      low: 0.001
+      high: 0.1
+      log: true
+  n_trials: 50

src/conf/model.yaml

@@ -0,0 +1,56 @@
+# conf/models.yaml
+
+###############################################################################
+# Ce fichier rassemble TOUTES les config de modèles dans un seul YAML.
+#
+# L'idée : on centralise ici les paramètres, et dans le "main" ou dans
+# un autre fichier config.yaml, on choisit un "type" => "svm", "random_forest",
+# "huggingface_transformer"..., puis on récupère le bloc correspondant.
+###############################################################################
+
+models:
+  huggingface_transformer:
+    # Paramètres pour HuggingFaceTransformerTrainer
+    model_name: "bert-base-uncased"
+    num_labels: 2
+    learning_rate: 5e-5
+    epochs: 3
+    batch_size: 8
+    warmup_steps: 0
+    weight_decay: 0.0
+    adam_epsilon: 1e-8
+
+  svm:
+    # Paramètres pour SvmTrainer
+    kernel: "rbf"
+    C: 1.0
+    gamma: "scale"
+    degree: 3
+    tol: 1e-3
+    max_iter: 1000
+    probability: True
+    decision_function_shape: "ovr"
+
+  random_forest:
+    # Paramètres pour RandomForestTrainer
+    n_estimators: 100
+    max_depth: null
+    max_features: "auto"
+    min_samples_split: 2
+    min_samples_leaf: 1
+    bootstrap: true
+    criterion: "gini"
+
+  logistic_regression:
+    # Paramètres pour LogisticRegressionTrainer
+    penalty: "l2"
+    C: 1.0
+    solver: "qn"
+    max_iter: 100
+    fit_intercept: true
+    linesearch_max_iter: 50
+
+  linear_regression:
+    # Paramètres pour LinearRegressionTrainer
+    fit_intercept: true
+    algorithm: "eig"

src/conf/vectorization.yaml

@@ -0,0 +1,26 @@
+# conf/vectorization.yaml
+vectorization :
+  tfidf:
+    lowercase: false           # Géré par cuML
+    stop_words: null          # Géré par cuML (None, 'english', ou une liste)
+    ngram_range: [1, 1]       # Géré par cuML
+    max_df: 1.0               # Géré par cuML
+    min_df: 1                 # Géré par cuML
+    max_features: 5000       # Géré par cuML
+    norm: l2                  # Spécifique TF-IDF
+    use_idf: true             # Spécifique TF-IDF
+    smooth_idf: true          # Spécifique TF-IDF
+    sublinear_tf: false         # Spécifique TF-IDF
+    # vocabulary: null        # Optionnel, gardé si besoin
+    # binary: false           # Optionnel, gardé si besoin
+
+  bow:
+    lowercase: false           # Géré par cuML
+    stop_words: null          # Géré par cuML
+    token_pattern: "(?u)\\b\\w\\w+\\b" # Géré par CountVectorizer cuML
+    ngram_range: [1, 1]       # Géré par cuML
+    max_df: 1.0               # Géré par cuML
+    min_df: 1                 # Géré par cuML
+    max_features: null       # Géré par cuML
+    # vocabulary: null        # Optionnel, gardé si besoin
+    # binary: false           # Optionnel, gardé si besoin

src/config.py

@@ -0,0 +1,79 @@
+# ======================
+# Fichier: config.py
+# ======================
+
+from pydantic import BaseModel, Field
+from typing import Dict, Any
+
+
+class ModelConfig(BaseModel):
+    """
+    Représente la configuration du modèle, incluant le type de modèle
+    et les paramètres associés.
+    """
+    type: str = Field(
+        ...,
+        description=
+        "Le type de modèle à entraîner (ex. 'svm', 'random_forest', 'logistic_regression', etc.)."
+    )
+    params: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Dictionnaire des paramètres propres au modèle choisi.")
+
+
+class VectorizationConfig(BaseModel):
+    """
+    Représente la configuration de la vectorisation, incluant la méthode
+    et les paramètres éventuels.
+    """
+    method: str = Field(
+        ...,
+        description="Le type de vectorisation à utiliser (ex. 'tfidf', 'bow')."
+    )
+    tfidf: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Paramètres spécifiques à une vectorisation TF-IDF.")
+    bow: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Paramètres spécifiques à une vectorisation bag-of-words.")
+
+
+class DataConfig(BaseModel):
+    """
+    Représente la configuration liée aux données, incluant
+    le chemin vers les données et le nom de la colonne cible.
+    """
+    path: str = Field(...,
+                      description="Chemin d'accès vers la source de données.")
+    target_column: str = Field(
+        ..., description="Nom de la colonne contenant la variable cible.")
+
+
+class HyperparameterConfig(BaseModel):
+    """
+    Représente la configuration pour l'optimisation des hyperparamètres,
+    incluant le nom de l'optimiseur, la grille de paramètres et
+    le nombre d'itérations d'entraînement.
+    """
+    optimizer: str = Field(
+        ...,
+        description=
+        "Nom de l'optimiseur d'hyperparamètres (ex. 'optuna', 'raytune').")
+    param_grid: Dict[str, Any] = Field(
+        default_factory=dict,
+        description=
+        "Grille définissant l'espace de recherche pour chaque hyperparamètre.")
+    n_trials: int = Field(
+        default=1,
+        description="Nombre d'essais pour la recherche d'hyperparamètres.")
+
+
+class Config(BaseModel):
+    """
+    Objet de configuration global combinant la section modèle, vectorisation,
+    données et hyperparamètres.
+    """
+    model: ModelConfig
+    vectorization: VectorizationConfig
+    data: DataConfig
+    hyperparameters: HyperparameterConfig

src/cuml_trainer.py

@@ -0,0 +1,120 @@
+# ===========================
+# Fichier: cuml_trainer.py
+# ===========================
+
+from abc import ABC, abstractmethod
+from typing import Union
+import cupy as cp
+from scipy.sparse import csr_matrix
+
+from config import Config
+from base_trainer import BaseTrainer
+from interfaces.vectorizer import Vectorizer
+
+
+class CuMLTrainer(BaseTrainer, ABC):
+    """
+    Classe abstraite, héritée de BaseTrainer, représentant un entraîneur
+    basé sur la librairie cuML. Elle ajoute notamment le concept de vectoriseur
+    et force le passage de la matrice d'entrée en cupy.ndarray pour la plupart
+    des opérations.
+
+    Attributs:
+        vectorizer (Vectorizer): Objet responsable de la vectorisation du texte.
+    """
+
+    def __init__(self, config: Config, data_path: str,
+                 target_column: str) -> None:
+        """
+        Initialise un CuMLTrainer avec la configuration.
+        Appelle également le constructeur de BaseTrainer.
+
+        :param config: Configuration globale du système.
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible dans les données.
+        """
+        super().__init__(config, data_path, target_column)
+        self.vectorizer: Vectorizer = None
+        # self.classifier est déjà défini dans BaseTrainer.
+        # On suppose que 'classifier' sera un modèle cuML (cuml.Base).
+
+    @abstractmethod
+    def build_components(self) -> None:
+        """
+        Méthode abstraite. Instancie concrètement le vectorizer et le classifieur,
+        selon la configuration (ex. 'svm', 'random_forest', etc.).
+        """
+        pass
+
+    def train(self) -> None:
+        """
+        Entraîne le classifieur sur les données vectorisées.
+        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)
+
+    def evaluate(self) -> None:
+        """
+        Évalue le classifieur et calcule les métriques.
+        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(
+            y_true=y_true,
+            y_pred=y_pred,
+            prefix=prefix
+        )
+        
+        # Afficher les résultats
+        print(f"Métriques d'évaluation {prefix}: {metrics}")
+
+    def _prepare_input_for_fit(self, X: Union[cp.ndarray,
+                                              csr_matrix]) -> cp.ndarray:
+        """
+        Convertit, si nécessaire, la matrice en cupy.ndarray pour l'entraînement.
+
+        :param X: Données d'entraînement (cupy.ndarray ou scipy.sparse.csr_matrix).
+        :return: Données converties en cupy.ndarray, pour compatibilité cuML.
+        """
+        if isinstance(X, csr_matrix):
+            return cp.asarray(X.toarray())
+        return X  # c'est déjà cupy.ndarray
+
+    def _prepare_input_for_predict(
+            self, X: Union[cp.ndarray, csr_matrix]) -> cp.ndarray:
+        """
+        Convertit, si nécessaire, la matrice en cupy.ndarray pour la prédiction.
+
+        :param X: Données de prédiction (cupy.ndarray ou scipy.sparse.csr_matrix).
+        :return: Données converties en cupy.ndarray, pour compatibilité cuML.
+        """
+        if isinstance(X, csr_matrix):
+            return cp.asarray(X.toarray())
+        return X

src/dataset/dataset.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4c582a26c9391ad2e190298ad0a0d0951f2ee3c71e8183b461a4d765856d4ee
+size 421000

src/interfaces/cuml_tfidf_vectorizer.py

@@ -0,0 +1,37 @@
+# ====
+# Fichier: interfaces/cuml_tfidf_vectorizer.py
+# ====
+
+from typing import Union
+import cupy as cp
+import cudf
+from scipy.sparse import csr_matrix
+from cuml.feature_extraction.text import TfidfVectorizer as CuMLTfidf
+from interfaces.vectorizer import Vectorizer
+
+
+class CuMLTfidfVectorizer(Vectorizer):
+    """
+    Implémentation concrète d'une vectorisation TF-IDF avec cuML.
+    Les paramètres se basent sur un dict (e.g. venant de config.vectorization.tfidf).
+    """
+    def __init__(self, **kwargs):
+        self._vectorizer = CuMLTfidf(**kwargs)
+        self._fitted = False
+
+    def fit_transform(self, texts: cudf.Series) -> Union[cp.ndarray, csr_matrix]:
+        """
+        Ajuste la TF-IDF sur les textes et retourne la matrice resultante.
+        """
+        X = self._vectorizer.fit_transform(texts)
+        self._fitted = True
+        return X
+
+    def transform(self, texts: cudf.Series) -> Union[cp.ndarray, csr_matrix]:
+        """
+        Applique la TF-IDF déjà apprise et retourne la matrice resultante.
+        """
+        if not self._fitted:
+            raise ValueError("Vectorizer not yet fitted. Call fit_transform first.")
+        X = self._vectorizer.transform(texts)
+        return X

src/interfaces/hyperparameter_optimizer.py

@@ -0,0 +1,28 @@
+# ============================================
+# Fichier: interfaces/hyperparameter_optimizer.py
+# ============================================
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+from base_trainer import BaseTrainer
+
+
+class HyperparameterOptimizer(ABC):
+    """
+    Interface pour la classe responsable de l'optimisation
+    des hyperparamètres.
+    """
+
+    @abstractmethod
+    def optimize(self, trainer: BaseTrainer,
+                 param_grid: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recherche les meilleurs hyperparamètres pour un 'trainer' donné,
+        selon la grille 'param_grid'.
+
+        :param trainer: Instance d'une classe implémentant BaseTrainer.
+        :param param_grid: Dictionnaire définissant l'espace de recherche
+                           pour chaque hyperparamètre.
+        :return: Un dictionnaire contenant les hyperparamètres optimaux trouvés.
+        """
+        pass

src/interfaces/metrics_calculator.py

@@ -0,0 +1,84 @@
+import cupy as cp
+import numpy as np
+from typing import Dict
+import logging
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
+from interfaces.metrics_calculator import MetricsCalculator
+
+logger = logging.getLogger(__name__)
+
+class DefaultMetricsCalculator(MetricsCalculator):
+    """
+    Implémentation concrète de MetricsCalculator qui calcule
+    accuracy, f1, precision, recall, et auc-roc.
+    Fonctionne pour binaire ou multiclasses (avec 'ovr' ou 'macro').
+    """
+
+    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
+        en supposant y_pred est dans {0,1} ou {True,False}.
+        """
+        y_true_np = cp.asnumpy(y_true)
+        y_pred_np = cp.asnumpy(y_pred)
+
+        acc = accuracy_score(y_true_np, y_pred_np)
+        prec = precision_score(y_true_np, y_pred_np, zero_division=0)
+        rec = recall_score(y_true_np, y_pred_np, zero_division=0)
+        f1 = f1_score(y_true_np, y_pred_np, zero_division=0)
+        
+        # Calcul AUC pour un problème binaire (si y_pred est 0/1)
+        # On treat y_pred_np as our "probabilities" only if truly 0/1. 
+        # In a real pipeline you might store probabilities separately.
+        try:
+            auc = roc_auc_score(y_true_np, y_pred_np)
+        except ValueError:
+            auc = 0.0
+
+        metrics = {
+            f"{prefix}_accuracy"  : acc,
+            f"{prefix}_precision" : prec,
+            f"{prefix}_recall"    : rec,
+            f"{prefix}_f1"        : f1,
+            f"{prefix}_auc_roc"   : auc
+        }
+        logger.info(f"[{prefix}] Metrics: {metrics}")
+        return metrics
+
+    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.
+        AUC-ROC en mode 'macro' si possible.
+        """
+        y_true_np = cp.asnumpy(y_true)
+        y_pred_np = cp.asnumpy(y_pred)
+
+        acc = accuracy_score(y_true_np, y_pred_np)
+        prec = precision_score(y_true_np, y_pred_np, average="macro", zero_division=0)
+        rec = recall_score(y_true_np, y_pred_np, average="macro", zero_division=0)
+        f1 = f1_score(y_true_np, y_pred_np, average="macro", zero_division=0)
+
+        # Pour le multiclasses, la roc_auc_score nécessite des scores proba
+        # ou "decision_function" => vous ajusterez selon votre cas.
+        # Ici, on met 0.0 en fallback.
+        auc = 0.0  
+
+        metrics = {
+            f"{prefix}_accuracy"  : acc,
+            f"{prefix}_precision" : prec,
+            f"{prefix}_recall"    : rec,
+            f"{prefix}_f1"        : f1,
+            f"{prefix}_auc_roc"   : auc
+        }
+        logger.info(f"[{prefix}] Multiclass metrics: {metrics}")
+        return metrics

src/interfaces/vectorizer.py

@@ -0,0 +1,40 @@
+# =================================
+# Fichier: interfaces/vectorizer.py
+# =================================
+
+from abc import ABC, abstractmethod
+from typing import Union
+import cupy as cp
+import cudf
+from scipy.sparse import csr_matrix
+
+
+class Vectorizer(ABC):
+    """
+    Interface pour la classe responsable de la vectorisation du texte.
+    Permet de convertir une série de textes en représentations
+    numériques (matrice sparse ou dense).
+    """
+
+    @abstractmethod
+    def fit_transform(self,
+                      texts: cudf.Series) -> Union[cp.ndarray, csr_matrix]:
+        """
+        Ajuste la vectorisation sur les textes de la série 'texts'
+        puis renvoie la matrice vectorisée associée.
+
+        :param texts: Série cudf contenant des chaînes de caractères.
+        :return: Matrice vectorisée (cupy.ndarray ou scipy.sparse.csr_matrix).
+        """
+        pass
+
+    @abstractmethod
+    def transform(self, texts: cudf.Series) -> Union[cp.ndarray, csr_matrix]:
+        """
+        Applique la vectorisation déjà apprise à une nouvelle série de textes
+        pour produire la matrice vectorisée.
+
+        :param texts: Série cudf contenant des chaînes de caractères.
+        :return: Matrice vectorisée (cupy.ndarray ou scipy.sparse.csr_matrix).
+        """
+        pass

src/main.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# =========================
+# Fichier: main.py
+# =========================
+
+import os
+import logging
+import hydra
+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
+
+# 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
+
+# Configuration du logging
+logger = logging.getLogger(__name__)
+
+
+def get_trainer(config: Config):
+    """
+    Crée et retourne l'instance du trainer approprié en fonction de la configuration.
+    
+    Args:
+        config: Objet de configuration
+        
+    Returns:
+        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,
+        "random_forest": RandomForestTrainer,
+        "logistic_regression": LogisticRegressionTrainer,
+        "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(
+        config=config,
+        data_path=config.data.path,
+        target_column=config.data.target_column
+    )
+
+
+def get_optimizer(config: Config):
+    """
+    Crée et retourne l'instance d'optimizer appropriée en fonction de la configuration.
+    
+    Args:
+        config: Objet de configuration
+        
+    Returns:
+        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()
+
+
+@hydra.main(config_path="conf", config_name="config")
+def main(cfg: DictConfig) -> None:
+    """
+    Point d'entrée principal de l'application.
+    
+    Args:
+        cfg: Configuration Hydra sous forme de DictConfig
+    """
+    # 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
+    )
+    # Appliquer le décorateur aux méthodes clés
+    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
+    
+    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.")
+
+
+if __name__ == "__main__":
+    main()

src/mlflow_integration/mlflow_decorator.py

@@ -0,0 +1,82 @@
+# =======================================
+# Fichier: mlflow_integration/mlflow_decorator.py
+# =======================================
+
+from typing import Callable, Dict, Any
+import mlflow
+
+
+class MLflowDecorator:
+    """
+    Décorateur dédié à l'intégration MLflow. Permet d'initialiser un 'experiment_name',
+    un 'tracking_uri', et de gérer la logique de logging de paramètres, métriques,
+    et artefacts pour MLflow.
+    """
+
+    def __init__(self, experiment_name: str, tracking_uri: str) -> None:
+        """
+        Initialise le décorateur MLflow avec le nom d'expérience et l'URI du serveur de tracking.
+
+        :param experiment_name: Nom de l'expérience MLflow à utiliser.
+        :param tracking_uri: URI du serveur MLflow (peut être un chemin local,
+                             ou une URL vers un serveur distant).
+        """
+        self.experiment_name: str = experiment_name
+        self.tracking_uri: str = tracking_uri
+
+    def __call__(self, func: Callable) -> Callable:
+        """
+        Rend la classe MLflowDecorator utilisable comme décorateur.
+        Lance la session MLflow avant d'appeler 'func', et la termine ensuite.
+
+        :param func: La fonction ou méthode à décorer.
+        :return: Une fonction enveloppée qui gère le cycle de vie d'une run MLflow.
+        """
+
+        def wrapper(*args, **kwargs):
+            mlflow.set_tracking_uri(self.tracking_uri)
+            mlflow.set_experiment(self.experiment_name)
+            with mlflow.start_run():
+                result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+    def _start_run(self) -> None:
+        """
+        Démarre explicitement un run MLflow.
+        """
+        mlflow.start_run()
+
+    def _log_params(self, params: Dict[str, Any]) -> None:
+        """
+        Logue dans MLflow les paramètres passés en dictionnaire.
+
+        :param params: Dictionnaire de paramètres (clef : valeur).
+        """
+        mlflow.log_params(params)
+
+    def _log_metrics(self, metrics: Dict[str, float]) -> None:
+        """
+        Logue dans MLflow les métriques passées en dictionnaire.
+
+        :param metrics: Dictionnaire de métriques (clef : valeur).
+        """
+        mlflow.log_metrics(metrics)
+
+    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.
+
+        :param artifacts: Dictionnaire décrivant les artefacts à logguer.
+        """
+        pass
+
+    def _end_run(self, status: str) -> None:
+        """
+        Termine un run MLflow en spécifiant un statut (ex: 'FINISHED', 'FAILED').
+
+        :param status: Statut final à associer au run MLflow.
+        """
+        mlflow.end_run(status=status)

src/optimizers/optuna_optimizer.py

@@ -0,0 +1,69 @@
+# =====================================
+# Fichier: optimizers/optuna_optimizer.py
+# =====================================
+
+from typing import Dict, Any
+from interfaces.hyperparameter_optimizer import HyperparameterOptimizer
+from base_trainer import BaseTrainer
+
+
+class OptunaOptimizer(HyperparameterOptimizer):
+    """
+    Optimiseur d'hyperparamètres basé sur la librairie Optuna.
+    Implémente l'interface HyperparameterOptimizer.
+    """
+
+    def optimize(self, trainer: BaseTrainer,
+                 param_grid: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recherche les meilleurs hyperparamètres pour un 'trainer' donné,
+        selon la grille 'param_grid', en utilisant Optuna.
+
+        :param trainer: Instance d'une classe implémentant BaseTrainer.
+        :param param_grid: Dictionnaire définissant l'espace de recherche
+                           pour chaque hyperparamètre.
+        :return: Un dictionnaire contenant les hyperparamètres optimaux trouvés.
+        """
+        # L'implémentation réelle d'Optuna ne figure pas dans l'UML,
+        # donc nous restons minimalistes et précises,
+        # sans ajouter d'hypothèses externes.
+        # L'UML mentionne juste + optimize(trainer: BaseTrainer, param_grid: dict): dict
+import optuna
+from functools import partial
+
+class OptunaOptimizer(HyperparameterOptimizer):
+    """
+    Optimiseur d'hyperparamètres basé sur la librairie Optuna.
+    Implémente l'interface HyperparameterOptimizer.
+    """
+
+    def optimize(self, trainer: BaseTrainer, param_grid: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recherche les meilleurs hyperparamètres pour un 'trainer' donné,
+        selon la grille 'param_grid', en utilisant Optuna.
+
+        :param trainer: Instance d'une classe implémentant BaseTrainer.
+        :param param_grid: Dictionnaire définissant l'espace de recherche
+                           pour chaque hyperparamètre.
+        :return: Un dictionnaire contenant les hyperparamètres optimaux trouvés.
+        """
+        def suggest_param(trial, param, values):
+            return (
+                trial.suggest_categorical(param, values) if isinstance(values, list) else
+                trial.suggest_float(param, values['low'], values['high'], log=values.get('log', False)) if isinstance(values, dict) and 'low' in values and 'high' in values else
+                trial.suggest_int(param, values['low'], values.get('high', 10)) if isinstance(values, dict) else
+                trial.suggest_float(param, 0.0, 1.0)
+            )
+
+        def objective(trial):
+            params = {param: suggest_param(trial, param, vals) for param, vals in param_grid.items()}
+            trainer.config.hyperparameters = params
+            trainer.train()
+            results = trainer.evaluate()
+            return results.get('validation_loss', float('inf'))  # Supposant que le loss est à minimiser
+
+        study = optuna.create_study(direction='minimize')
+        n_trials = trainer.config.hyperparameters.get('n_trials', 100)
+        study.optimize(objective, n_trials=n_trials)
+
+        return study.best_params

src/optimizers/ray_tune_optimizer.py

@@ -0,0 +1,138 @@
+# =======================================
+# Fichier: optimizers/ray_tune_optimizer.py
+# =======================================
+
+from typing import Dict, Any
+from interfaces.hyperparameter_optimizer import HyperparameterOptimizer
+from base_trainer import BaseTrainer
+import ray
+from ray import tune
+from ray.tune import CLIReporter
+from ray.tune.schedulers import ASHAScheduler
+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
+
+
+class RayTuneOptimizer(HyperparameterOptimizer):
+    """
+    Optimiseur d'hyperparamètres basé sur Ray Tune.
+    Implémente l'interface HyperparameterOptimizer.
+    """
+
+    def optimize(self, trainer: BaseTrainer, param_grid: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recherche les meilleurs hyperparamètres pour un 'trainer' donné,
+        selon la grille 'param_grid', en utilisant Ray Tune.
+
+        :param trainer: Instance d'une classe implémentant BaseTrainer.
+        :param param_grid: Dictionnaire définissant l'espace de recherche
+                           pour chaque hyperparamètre.
+        :return: Un dictionnaire contenant les hyperparamètres optimaux trouvés.
+        """
+        full_config = trainer.config.dict() if hasattr(trainer.config, 'dict') else trainer.config
+        config = self._create_config(param_grid)
+        scheduler = self._create_scheduler()
+        reporter = self._create_reporter()
+
+        analysis = tune.run(
+            self._train_model,
+            config={"hyperparameters": config, **full_config},
+            num_samples=full_config['hyperparameters'].get('n_trials', 100),
+            scheduler=scheduler,
+            progress_reporter=reporter,
+            resources_per_trial={"cpu": 1, "gpu": 0}
+        )
+
+        return analysis.best_config
+
+    def _create_config(self, param_grid: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Crée la configuration pour Ray Tune à partir du param_grid.
+
+        :param param_grid: Dictionnaire définissant l'espace de recherche
+                           pour chaque hyperparamètre.
+        :return: Dictionnaire de configuration pour Ray Tune.
+        """
+        return {param: self._define_search_space(param, vals) for param, vals in param_grid.items()}
+
+    def _define_search_space(self, param: str, vals: Any) -> Any:
+        """
+        Définit l'espace de recherche pour un hyperparamètre donné.
+
+        :param param: Nom de l'hyperparamètre.
+        :param vals: Valeurs possibles ou dictionnaire définissant l'espace.
+        :return: Espace de recherche Ray Tune.
+        """
+        if isinstance(vals, list):
+            return tune.choice(vals)
+        elif isinstance(vals, dict):
+            low = vals.get('low', 0)
+            high = vals.get('high', 10)
+            log = vals.get('log', False)
+            if 'low' in vals and 'high' in vals:
+                return tune.uniform(param, low, high) if log else tune.randint(param, low, high)
+        return tune.uniform(param, 0.0, 1.0)
+
+    def _create_scheduler(self) -> ASHAScheduler:
+        """
+        Crée un scheduler ASHAScheduler pour Ray Tune.
+
+        :return: Instance d'ASHAScheduler.
+        """
+        return ASHAScheduler(
+            max_t=100,
+            grace_period=10,
+            reduction_factor=2
+        )
+
+    def _create_reporter(self) -> CLIReporter:
+        """
+        Crée un reporter CLIReporter pour Ray Tune.
+
+        :return: Instance de CLIReporter.
+        """
+        return CLIReporter(
+            metric_columns=["validation_loss", "training_iteration"]
+        )
+
+    def _train_model(self, config: Dict[str, Any]):
+        """
+        Fonction d'entraînement pour Ray Tune.
+
+        :param config: Configuration des hyperparamètres.
+        """
+        merged_config = config.copy()
+        hyperparams = merged_config.pop('hyperparameters', {})
+        trainer_instance = self._get_trainer_instance(merged_config)
+        trainer_instance.config.hyperparameters = hyperparams
+        trainer_instance.train()
+        results = trainer_instance.evaluate()
+        tune.report(validation_loss=results.get('validation_loss', float('inf')))
+
+    def _get_trainer_instance(self, config: Dict[str, Any]) -> BaseTrainer:
+        """
+        Obtient une instance de BaseTrainer basée sur la configuration.
+
+        :param config: Configuration globale incluant hyperparamètres.
+        :return: Instance de BaseTrainer.
+        """
+        model_type = config['model']['type'].lower()
+        trainer_mapping = {
+            'svm': SvmTrainer,
+            'random_forest': RandomForestTrainer,
+            'logistic_regression': LogisticRegressionTrainer,
+            'linear_regression': LinearRegressionTrainer,
+            # Ajouter d'autres mappings ici si nécessaire
+        }
+
+        trainer_class = trainer_mapping.get(model_type)
+        if not trainer_class:
+            raise ValueError(f"Type de modèle non supporté : {model_type}")
+
+        return trainer_class(
+            config=config,
+            data_path=config['data']['path'],
+            target_column=config['data']['target_column']
+        )

src/parameter_logging.py

@@ -0,0 +1,67 @@
+# ==================================
+# Fichier: parameter_logging.py
+# ==================================
+
+from functools import singledispatch
+from typing import Dict, Any
+from base_trainer import BaseTrainer
+from trainers.huggingface.huggingface_transformer_trainer import HuggingFaceTransformerTrainer
+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
+
+
+@singledispatch
+def get_relevant_params_for_logging(trainer: BaseTrainer) -> Dict[str, Any]:
+    """
+    Méthode générique, par défaut, pour récupérer les paramètres
+    à logger dans MLflow ou ailleurs.
+
+    :param trainer: Trainer dont on veut extraire les paramètres.
+    :return: Un dictionnaire de paramètres pertinents.
+    """
+    # Par défaut, on récupère la section 'params' du config.model,
+    # mais l'UML ne précise pas la logique interne.
+    return trainer.config.model.params
+
+
+@get_relevant_params_for_logging.register
+def _(trainer: HuggingFaceTransformerTrainer) -> Dict[str, Any]:
+    """
+    Cas particulier pour un HuggingFaceTransformerTrainer.
+    """
+    # Extrait les paramètres spécifiques HuggingFace indiqués dans trainer.config.model.params.
+    return trainer.config.model.params
+
+
+@get_relevant_params_for_logging.register
+def _(trainer: SvmTrainer) -> Dict[str, Any]:
+    """
+    Cas particulier pour un SvmTrainer.
+    """
+    return trainer.config.model.params
+
+
+@get_relevant_params_for_logging.register
+def _(trainer: RandomForestTrainer) -> Dict[str, Any]:
+    """
+    Cas particulier pour un RandomForestTrainer.
+    """
+    return trainer.config.model.params
+
+
+@get_relevant_params_for_logging.register
+def _(trainer: LogisticRegressionTrainer) -> Dict[str, Any]:
+    """
+    Cas particulier pour un LogisticRegressionTrainer.
+    """
+    return trainer.config.model.params
+
+
+@get_relevant_params_for_logging.register
+def _(trainer: LinearRegressionTrainer) -> Dict[str, Any]:
+    """
+    Cas particulier pour un LinearRegressionTrainer.
+    """
+    return trainer.config.model.params

src/trainers/cuml/linear_regression_trainer.py

@@ -0,0 +1,80 @@
+# ============================================
+# Fichier: trainers/cuml/linear_regression_trainer.py
+# ============================================
+
+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
+
+class LinearRegressionTrainer(CuMLTrainer):
+    """
+    Entraîneur spécifique utilisant un classifieur LinearRegression de la librairie cuML.
+    Hérite de CuMLTrainer, qui hérite lui-même de BaseTrainer.
+    
+    Cette classe implémente les méthodes spécifiques à l'utilisation d'un modèle 
+    de régression linéaire pour la prédiction de valeurs continues.
+    """
+
+    def __init__(self, config: Config, data_path: str, target_column: str) -> None:
+        """
+        Initialise un LinearRegressionTrainer avec la configuration et les paramètres
+        du parent CuMLTrainer.
+
+        :param config: Configuration globale du système.
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible.
+        """
+        super().__init__(config, data_path, target_column)
+
+    def _build_classifier(self) -> None:
+        """
+        Crée et configure un classifieur LinearRegression selon les paramètres 
+        spécifiés dans la configuration.
+        
+        Utilise directement les paramètres de la configuration pour initialiser
+        le modèle avec les hyperparamètres appropriés.
+        """
+        params = self.config.model.params or {}
+        self.classifier = LinearRegression(**params)
+
+    def build_components(self) -> None:
+        """
+        Instancie le vectorizer, le classifieur LinearRegression et le calculateur de métriques.
+        
+        Cette méthode configure tous les composants nécessaires au fonctionnement
+        du trainer, en se basant sur les paramètres spécifiés dans la configuration.
+        """
+        # Récupération de la méthode et des paramètres de vectorisation
+        vector_method = self.config.vectorization.method
+        vector_params = self.config.vectorization.dict().get(vector_method, {})
+        self.vectorizer = CuMLTfidfVectorizer(**vector_params)
+
+        # Construction du classifieur
+        self._build_classifier()
+        
+        # Initialisation du calculateur de métriques
+        self.metrics_calculator = DefaultMetricsCalculator()
+
+    def train(self) -> None:
+        """
+        Entraîne le classifieur LinearRegression sur les données vectorisées.
+        
+        Utilise l'implémentation fournie par la classe parente CuMLTrainer,
+        qui s'occupe du chargement des données, de la vectorisation et de l'entraînement.
+        """
+        # Inheriting from CuMLTrainer => loads data, vectorizes, fits
+        super().train()
+
+    def evaluate(self) -> None:
+        """
+        É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.
+        """
+        # Inheriting from CuMLTrainer => loads data, vectorizes, calls the metrics calculator
+        super().evaluate()

src/trainers/cuml/logistic_regression_trainer.py

@@ -0,0 +1,78 @@
+# ============================================
+# Fichier: trainers/cuml/logistic_regression_trainer.py
+# ============================================
+
+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
+
+class LogisticRegressionTrainer(CuMLTrainer):
+    """
+    Entraîneur spécifique utilisant un classifieur LogisticRegression de la librairie cuML.
+    Hérite de CuMLTrainer, qui hérite lui-même de BaseTrainer.
+    
+    Cette classe implémente les méthodes spécifiques à l'utilisation d'un modèle 
+    de régression logistique pour la classification binaire ou multi-classes.
+    """
+
+    def __init__(self, config: Config, data_path: str, target_column: str) -> None:
+        """
+        Initialise un LogisticRegressionTrainer avec la configuration et les paramètres
+        du parent CuMLTrainer.
+
+        :param config: Configuration globale du système.
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible.
+        """
+        super().__init__(config, data_path, target_column)
+
+    def _build_classifier(self) -> None:
+        """
+        Crée et configure un classifieur LogisticRegression selon les paramètres 
+        spécifiés dans la configuration.
+        
+        Utilise directement les paramètres de la configuration pour initialiser
+        le modèle avec les hyperparamètres appropriés.
+        """
+        params = self.config.model.params or {}
+        self.classifier = LogisticRegression(**params)
+
+    def build_components(self) -> None:
+        """
+        Instancie le vectorizer, le classifieur LogisticRegression et le calculateur de métriques.
+        
+        Cette méthode configure tous les composants nécessaires au fonctionnement
+        du trainer, en se basant sur les paramètres spécifiés dans la configuration.
+        """
+        # Récupération de la méthode et des paramètres de vectorisation
+        vector_method = self.config.vectorization.method
+        vector_params = self.config.vectorization.dict().get(vector_method, {})
+        self.vectorizer = CuMLTfidfVectorizer(**vector_params)
+
+        # Construction du classifieur
+        self._build_classifier()
+        
+        # Initialisation du calculateur de métriques
+        self.metrics_calculator = DefaultMetricsCalculator()
+
+    def train(self) -> None:
+        """
+        Entraîne le classifieur LogisticRegression sur les données vectorisées.
+        
+        Utilise l'implémentation fournie par la classe parente CuMLTrainer,
+        qui s'occupe du chargement des données, de la vectorisation et de l'entraînement.
+        """
+        super().train()
+
+    def evaluate(self) -> None:
+        """
+        É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.
+        """
+        super().evaluate()

src/trainers/cuml/random_forest_trainer.py

@@ -0,0 +1,103 @@
+# ============================================
+# Fichier: trainers/cuml/random_forest_trainer.py
+# ============================================
+
+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
+
+class RandomForestTrainer(CuMLTrainer):
+    """
+    Entraîneur spécifique utilisant un classifieur RandomForestClassifier de la librairie cuML.
+    Hérite de CuMLTrainer, qui hérite lui-même de BaseTrainer.
+    
+    Cette classe implémente les méthodes spécifiques à l'utilisation d'un modèle
+    de forêt aléatoire pour la classification, en exploitant les capacités GPU
+    offertes par la librairie cuML.
+    """
+
+    def __init__(self, config: Config, data_path: str, target_column: str) -> None:
+        """
+        Initialise un RandomForestTrainer avec la configuration et les paramètres
+        du parent CuMLTrainer.
+
+        :param config: Configuration globale du système.
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible.
+        """
+        super().__init__(config, data_path, target_column)
+
+    def _build_classifier(self) -> None:
+        """
+        Crée et configure un classifieur RandomForestClassifier selon les paramètres 
+        spécifiés dans la configuration.
+        
+        Utilise directement les paramètres de la configuration pour initialiser
+        le modèle avec les hyperparamètres appropriés (ex: n_estimators, max_depth, etc.).
+        """
+        params = self.config.model.params or {}
+        self.classifier = RandomForestClassifier(**params)
+
+    def build_components(self) -> None:
+        """
+        Instancie le vectorizer, le classifieur RandomForest et le calculateur de métriques.
+        
+        Cette méthode configure tous les composants nécessaires au fonctionnement
+        du trainer, en se basant sur les paramètres spécifiés dans la configuration.
+        """
+        # Récupération de la méthode et des paramètres de vectorisation
+        vector_method = self.config.vectorization.method  # e.g. "tfidf"
+        vector_params = self.config.vectorization.dict().get(vector_method, {})
+        self.vectorizer = CuMLTfidfVectorizer(**vector_params)
+
+        # Construction du classifieur
+        self._build_classifier()
+        
+        # Initialisation du calculateur de métriques
+        self.metrics_calculator = DefaultMetricsCalculator()
+
+    def train(self) -> None:
+        """
+        Entraîne le classifieur RandomForest sur les données vectorisées.
+        
+        Utilise l'implémentation fournie par la classe parente CuMLTrainer,
+        qui s'occupe du chargement des données, de la vectorisation et de l'entraînement.
+        """
+        super().train()
+
+    def evaluate(self) -> None:
+        """
+        É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.
+        """
+        super().evaluate()
+        
+    def _get_binary_predictions(self, X: cp.ndarray) -> cp.ndarray:
+        """
+        Retourne les prédictions binaires du modèle RandomForest.
+        
+        :param X: Matrice de caractéristiques au format cupy.ndarray.
+        :return: Vecteur de prédictions binaires.
+        """
+        X_prepared = self._prepare_input_for_predict(X)
+        return self.classifier.predict(X_prepared)
+    
+    def _get_positive_probabilities(self, X: cp.ndarray) -> Optional[cp.ndarray]:
+        """
+        Retourne les probabilités de la classe positive.
+        Les forêts aléatoires peuvent toujours fournir des probabilités,
+        ce qui est l'un de leurs avantages.
+        
+        :param X: Matrice de caractéristiques au format cupy.ndarray.
+        :return: Vecteur de probabilités pour la classe positive.
+        """
+        X_prepared = self._prepare_input_for_predict(X)
+        return self.classifier.predict_proba(X_prepared)[:, 1]

src/trainers/cuml/svm_trainer.py

@@ -0,0 +1,110 @@
+# ============================================
+# Fichier: trainers/cuml/svm_trainer.py
+# ============================================
+
+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
+
+class SvmTrainer(CuMLTrainer):
+    """
+    Entraîneur spécifique utilisant un classifieur SVC (Support Vector Classifier) de la librairie cuML.
+    Hérite de CuMLTrainer, qui hérite lui-même de BaseTrainer.
+    
+    Cette classe implémente les méthodes spécifiques à l'utilisation d'un modèle SVM
+    pour la classification binaire ou multi-classes, en exploitant les capacités GPU
+    offertes par la librairie cuML.
+    """
+
+    def __init__(self, config: Config, data_path: str, target_column: str) -> None:
+        """
+        Initialise un SvmTrainer avec la configuration et les paramètres
+        du parent CuMLTrainer.
+
+        :param config: Configuration globale du système.
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible.
+        """
+        super().__init__(config, data_path, target_column)
+
+    def _build_classifier(self) -> None:
+        """
+        Crée et configure un classifieur SVC selon les paramètres 
+        spécifiés dans la configuration.
+        
+        Utilise directement les paramètres de la configuration pour initialiser
+        le modèle avec les hyperparamètres appropriés (ex: kernel, C, gamma, etc.).
+        """
+        params = self.config.model.params or {}
+        self.classifier = SVC(**params)
+
+    def build_components(self) -> None:
+        """
+        Instancie le vectorizer, le classifieur SVC et le calculateur de métriques.
+        
+        Cette méthode configure tous les composants nécessaires au fonctionnement
+        du trainer, en se basant sur les paramètres spécifiés dans la configuration.
+        """
+        # Récupération de la méthode et des paramètres de vectorisation
+        vector_method = self.config.vectorization.method
+        vector_params = self.config.vectorization.dict().get(vector_method, {})
+        self.vectorizer = CuMLTfidfVectorizer(**vector_params)
+
+        # Construction du classifieur
+        self._build_classifier()
+        
+        # Initialisation du calculateur de métriques
+        self.metrics_calculator = DefaultMetricsCalculator()
+
+    def train(self) -> None:
+        """
+        Entraîne le classifieur SVC sur les données vectorisées.
+        
+        Utilise l'implémentation fournie par la classe parente CuMLTrainer,
+        qui s'occupe du chargement des données, de la vectorisation et de l'entraînement.
+        """
+        super().train()
+
+    def evaluate(self) -> None:
+        """
+        É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.
+        """
+        super().evaluate()
+
+    def _get_binary_predictions(self, X: cp.ndarray) -> cp.ndarray:
+        """
+        Retourne les prédictions binaires du modèle SVC.
+        
+        Cette méthode est spécifiquement utilisée pour obtenir des prédictions
+        binaires (0/1) à partir du modèle entraîné.
+        
+        :param X: Matrice de caractéristiques au format cupy.ndarray.
+        :return: Vecteur de prédictions binaires.
+        """
+        X_prepared = self._prepare_input_for_predict(X)
+        return self.classifier.predict(X_prepared)
+    
+    def _get_positive_probabilities(self, X: cp.ndarray) -> Optional[cp.ndarray]:
+        """
+        Retourne les probabilités de la classe positive si disponible.
+        
+        Cette méthode est utilisée pour obtenir les probabilités d'appartenance
+        à la classe positive, utile notamment pour calculer l'AUC-ROC ou 
+        pour des seuils de décision personnalisés.
+        
+        :param X: Matrice de caractéristiques au format cupy.ndarray.
+        :return: Vecteur de probabilités ou None si non disponible.
+        """
+        if hasattr(self.classifier, 'predict_proba'):
+            X_prepared = self._prepare_input_for_predict(X)
+            return self.classifier.predict_proba(X_prepared)[:, 1]
+        return None

src/trainers/huggingface/huggingface_transformer_trainer.py

@@ -0,0 +1,97 @@
+# ============================================================
+# Fichier: trainers/huggingface/huggingface_transformer_trainer.py
+# ============================================================
+
+from typing import Optional
+import cupy as cp
+import cudf
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+
+from base_trainer import BaseTrainer
+from config import Config
+
+
+class HuggingFaceTransformerTrainer(BaseTrainer):
+    """
+    Entraîneur spécifique Hugging Face, utilisant un tokenizer,
+    un modèle AutoModelForSequenceClassification et un HF Trainer.
+    Ne dépend pas d'un vectorizer cuML d'après l'UML.
+    """
+
+    def __init__(self, config: Config, data_path: str,
+                 target_column: str) -> None:
+        """
+        Initialise un HuggingFaceTransformerTrainer avec la configuration
+        et les paramètres du parent BaseTrainer.
+
+        :param config: Configuration globale du système.
+                       (La config.vectorizer n'est pas utilisée ici.)
+        :param data_path: Chemin vers le fichier de données.
+        :param target_column: Nom de la colonne cible dans vos données.
+        """
+        super().__init__(config, data_path, target_column)
+        self.tokenizer: Optional[AutoTokenizer] = None
+        self.model: Optional[AutoModelForSequenceClassification] = None
+        self.hf_trainer: Optional[Trainer] = None
+
+    def build_components(self) -> None:
+        """
+        Instancie le tokenizer et le modèle Hugging Face
+        AutoModelForSequenceClassification, puis crée un Trainer
+        avec des TrainingArguments par défaut.
+        """
+        model_name = self.config.model.params.get("pretrained_model_name",
+                                                  "bert-base-uncased")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            model_name)
+        training_args = self._prepare_training_args()
+
+        # Le HF Trainer a besoin de datasets, qui sont construits
+        # dans le code de train/evaluate ou un data loader.
+        self.hf_trainer = Trainer(model=self.model,
+                                  args=training_args,
+                                  train_dataset=None,
+                                  eval_dataset=None)
+
+    def train(self) -> None:
+        """
+        Entraîne le modèle Hugging Face sur le jeu de données
+        (les datasets sont assignés au HF Trainer).
+        """
+        pass
+
+    def evaluate(self) -> None:
+        """
+        Évalue le modèle Hugging Face; la logique de calcul
+        des métriques est en partie assurée par le HF Trainer.
+        """
+        pass
+
+    def _create_torch_dataset(self, texts: cudf.Series,
+                              labels: cp.ndarray) -> torch.utils.data.Dataset:
+        """
+        Convertit un cudf.Series de textes et un tableau cupy de labels
+        en un Dataset PyTorch.
+
+        :param texts: Série cudf contenant les textes.
+        :param labels: Vecteur cupy des labels (ex. classification binaire ou multiclasses).
+        :return: Un Dataset PyTorch utilisable par Trainer.
+        """
+        # Implémentation possible : tokenization + construction d'un dataset custom.
+        raise NotImplementedError(
+            "La méthode _create_torch_dataset est à implémenter selon vos besoins."
+        )
+
+    def _prepare_training_args(self) -> TrainingArguments:
+        """
+        Construit un objet TrainingArguments Hugging Face,
+        par exemple pour définir l'output_dir, le batch_size, etc.
+
+        :return: Instance de TrainingArguments configurée.
+        """
+        return TrainingArguments(output_dir="./results",
+                                 num_train_epochs=1,
+                                 per_device_train_batch_size=8,
+                                 per_device_eval_batch_size=8)

src/utilities/cuml_pyfunc_wrapper.py

@@ -0,0 +1,56 @@
+# ===========================================
+# Fichier: utilities/cuml_pyfunc_wrapper.py
+# ===========================================
+
+from typing import Any, Dict, Optional
+import pandas as pd
+import numpy as np
+
+from interfaces.vectorizer import Vectorizer
+
+
+class CuMLPyFuncWrapper:
+    """
+    Classe wrapper pour intégration de modèles cuML dans MLflow PyFunc,
+    permettant le chargement et l'inférence.
+    """
+
+    def __init__(self, vectorizer: Vectorizer, classifier: object) -> None:
+        """
+        Initialise le wrapper avec un vectorizer cuDF/cupy et le classifieur cuML.
+
+        :param vectorizer: Instance implémentant l'interface Vectorizer.
+        :param classifier: Modèle cuML déjà entraîné (ex. SVC, RandomForest, etc.).
+        """
+        self.vectorizer: Vectorizer = vectorizer
+        self.classifier: object = classifier
+
+    def load_context(self, context: Dict[str, Any]) -> None:
+        """
+        Chargé par MLflow PyFunc lors du rechargement du modèle,
+        par exemple pour initialiser l'environnement.
+
+        :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
+
+    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.
+
+        :param context: Contexte d'exécution éventuel (non défini par l'UML).
+        :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."
+        )

uml.plantuml

@@ -0,0 +1,333 @@
+@startuml
+!theme plain
+
+skinparam classAttributeIconSize 0
+skinparam defaultFontName Arial
+skinparam class {
+    BackgroundColor PaleTurquoise
+    BorderColor DarkSlateGray
+}
+skinparam abstractClass {
+    BackgroundColor LightYellow
+    BorderColor DarkSlateGray
+}
+skinparam interface {
+    BackgroundColor White
+    BorderColor Black
+}
+
+' ----------- Type ParamGrid -----------
+class ParamGrid {
+  note as N1
+    Exemples de clés et valeurs :
+      - "C": [0.1, 1, 10, 100]
+      - "kernel": ["linear", "rbf"]
+      - "gamma":
+          low: 0.001
+          high: 0.1
+          log: true
+
+    Ce type sert à décrire la structure attendue pour le param_grid
+    dans les Optimizers.
+  end note
+}
+
+' ----------- Interfaces -----------
+package "Interfaces" {
+  interface MetricsCalculator {
+    + calculate_and_log(y_true: cp.ndarray, y_pred: cp.ndarray, prefix: str): dict
+    + calculate_and_log_multiclass(y_true: cp.ndarray, y_pred: cp.ndarray, prefix: str): dict
+    --
+    note bottom
+      Génère toujours : accuracy, f1, precision, recall, auc-roc
+    end note
+  }
+
+  interface Vectorizer {
+    + fit_transform(texts: cudf.Series): cp.ndarray | csr_matrix
+    + transform(texts: cudf.Series): cp.ndarray | csr_matrix
+  }
+
+  interface HyperparameterOptimizer {
+    + optimize(trainer: BaseTrainer, param_grid: ParamGrid): dict
+    --
+    note bottom
+      Renvoie un dict correspondant \nà la best config trouvée
+      ex: {"C": 1, "kernel": "linear", "gamma": 0.01}
+    end note
+  }
+}
+
+
+' ----------- Base Classes -----------
+package "Base Classes" {
+  abstract class BaseTrainer {
+    - config: Config
+    - classifier: object
+    - metrics_calculator: MetricsCalculator
+    --
+    + __init__(config: Config, data_path: str, target_column: str)
+    + build_components(): void
+    + train(): void
+    + evaluate(): void
+    + log_parameters_to_mlflow(): void
+    + optimize_if_needed(): void
+    -
+    _prepare_input_for_fit(X: cp.ndarray | csr_matrix): cp.ndarray | csr_matrix
+    -
+    _prepare_input_for_predict(X: cp.ndarray | csr_matrix): cp.ndarray | csr_matrix
+    -
+    _get_binary_predictions(X: cp.ndarray): cp.ndarray
+    -
+    _get_positive_probabilities(X: cp.ndarray): cp.ndarray | None
+    -
+    _get_label_dtype(): cp.dtype
+
+    note right
+      log_parameters_to_mlflow():
+      appelle la fonction singledispatch
+      get_relevant_params_for_logging(self).
+
+      optimize_if_needed():
+      Vérifie dans self.config \nsi un optimizer est défini, \npuis appelle optimize() \nsur ce dernier si besoin.
+    end note
+  }
+
+  abstract class CuMLTrainer extends BaseTrainer {
+    - vectorizer: Vectorizer
+    - classifier: cuML.Base
+    --
+    + build_components(): void
+    + train(): void
+    + evaluate(): void
+    -
+    _prepare_input_for_fit(X: cp.ndarray | csr_matrix): cp.ndarray
+    -
+    _prepare_input_for_predict(X: cp.ndarray | csr_matrix): cp.ndarray
+  }
+}
+
+' ----------- Concrete Trainers (cuML) -----------
+package "Concrete Trainers (cuML)" {
+  class SvmTrainer extends CuMLTrainer {
+    - classifier: SVC
+    --
+    + _build_classifier(): void
+    note bottom
+      SvmTrainer est affecté \npar les paramètres C, kernel, \net gamma (pour RBF).
+    end note
+  }
+
+  class RandomForestTrainer extends CuMLTrainer {
+    - classifier: RandomForestClassifier
+    --
+    + _build_classifier(): void
+  }
+
+  class LogisticRegressionTrainer extends CuMLTrainer {
+    - classifier: LogisticRegression
+    --
+    + _build_classifier(): void
+  }
+
+  class LinearRegressionTrainer extends CuMLTrainer {
+    - classifier: LinearRegression
+    --
+    + _build_classifier(): void
+  }
+}
+
+' ----------- Concrete Trainers (Hugging Face) -----------
+package "Concrete Trainers (Hugging Face)" {
+  class HuggingFaceTransformerTrainer extends BaseTrainer {
+    - tokenizer: AutoTokenizer
+    - model: AutoModelForSequenceClassification
+    - hf_trainer: Trainer
+    --
+    + build_components(): void
+    + train(): void
+    + evaluate(): void
+    -
+    _create_torch_dataset(texts: cudf.Series, labels: cp.ndarray): torch.utils.data.Dataset
+    -
+    _prepare_training_args(): TrainingArguments
+
+    note right
+      Ce trainer n'utilise pas 
+      la config vectorizer
+    end note
+  }
+}
+
+' ----------- Hyperparameter Optimizers -----------
+package "Hyperparameter Optimizers" {
+  class OptunaOptimizer {
+    - study: optuna.study.Study
+    - objective: function
+    --
+    + optimize(trainer: BaseTrainer, param_grid: ParamGrid): dict
+    --
+    note bottom
+      Implementation:
+        1) Crée/récupère un study Optuna.
+        2) Définit l'objective (fonction de coût).
+           Ex: Utilise param_grid["C"] \npour suggérer \ntrial.suggest_float("C",...)
+        3) Applique les hyperparams au trainer \n(e.g. trainer.classifier = SVC(**params)).
+        4) study.optimize(..., n_trials=...)
+        5) Retourne la meilleure config sous forme d'un dict
+    end note
+  }
+
+  class RayTuneOptimizer {
+    - param_space: dict
+    - search_alg: object
+    - scheduler: object
+    --
+    + optimize(trainer: BaseTrainer, param_grid: ParamGrid): dict
+    --
+    note bottom
+      Implementation:
+        1) Convertit param_grid \nen param_space pour Ray Tune.
+           (ex: "C": tune.grid_search([...]))
+        2) Lance tune.run(...).
+        3) Utilise search_alg/scheduler.
+        4) Retourne la meilleure config \nsous forme d'un dict
+    end note
+  }
+
+  OptunaOptimizer ..> HyperparameterOptimizer : «implements»
+  RayTuneOptimizer ..> HyperparameterOptimizer : «implements»
+}
+
+' ----------- MLflow Integration -----------
+package "MLflow Integration" {
+  class MLflowDecorator {
+    - experiment_name: str
+    - tracking_uri: str
+    --
+    + __init__(experiment_name: str, tracking_uri: str): void
+    + __call__(func: function): function
+    + _start_run(): void
+    + _log_params(params: dict): void
+    + _log_metrics(metrics: dict): void
+    + _log_artifacts(artifacts: dict): void
+    + _end_run(status: str): void
+  }
+}
+
+' ----------- Utilities -----------
+package "Utilities" {
+  class CuMLPyFuncWrapper {
+    - vectorizer: Vectorizer
+    - classifier: object
+    --
+    + load_context(context): void
+    + predict(context, model_input: pd.DataFrame): np.ndarray
+  }
+}
+
+' ----------- Configuration -----------
+package "Configuration" {
+  class Config <<PydanticModel>> {
+    + model: ModelConfig
+    + vectorization: VectorizationConfig
+    + data: DataConfig
+    + hyperparameters: HyperparameterConfig
+  }
+
+  class ModelConfig <<PydanticModel>> {
+    + type: str
+    + params: dict
+  }
+
+  class VectorizationConfig <<PydanticModel>> {
+    + method: str
+    + tfidf: dict
+    + bow: dict
+  }
+
+  class DataConfig <<PydanticModel>> {
+    + path: str
+    + target_column: str
+  }
+
+  class HyperparameterConfig <<PydanticModel>> {
+  + optimizer: str
+  + param_grid: dict
+  + n_trials: int
+  --
+  note bottom
+    Exemple de param_grid pour SVM:
+    \{
+      "C": [0.1, 1, 10, 100],
+      "kernel": ["linear", "rbf"],
+      "gamma": \{
+        "low": 0.001,
+        "high": 0.1,
+        "log": true
+      \}
+    \}
+    n_trials: 50
+  end note
+}
+  Config <|-- ModelConfig
+  Config <|-- VectorizationConfig
+  Config <|-- DataConfig
+  Config <|-- HyperparameterConfig
+
+  note left of Config
+    Extrait YAML:
+    hyperparameters:
+      optimizer: "optuna"
+      param_grid:
+        C: [0.1, 1, 10, 100]
+        kernel:
+          - "linear"
+          - "rbf"
+        gamma:
+          low: 0.001
+          high: 0.1
+          log: true
+      n_trials: 50
+    =
+    Hydra -> DictConfig -> Config(Pydantic)
+  end note
+}
+
+' ----------- singledispatch function -----------
+package "Parameter Logging (singledispatch)" {
+  object get_relevant_params_for_logging <<Function>>
+  note bottom
+    @singledispatch
+    def get_relevant_params_for_logging(trainer: BaseTrainer) -> dict:
+        ...
+
+    @get_relevant_params_for_logging.register
+    def _(trainer: HuggingFaceTransformerTrainer) -> dict:
+        ...
+
+    @get_relevant_params_for_logging.register
+    def _(trainer: SvmTrainer) -> dict:
+        ...
+
+    etc.
+  end note
+}
+
+' ----------- Relations -----------
+BaseTrainer ..> MetricsCalculator : «uses»
+BaseTrainer ..> HyperparameterOptimizer : «may use»
+BaseTrainer ..> MLflowDecorator : «may be decorated by»
+BaseTrainer ..> get_relevant_params_for_logging : «calls singledispatch function»
+
+CuMLTrainer ..> cuML.Base : «uses»
+CuMLTrainer ..> CuMLPyFuncWrapper : «for saving model»
+
+HuggingFaceTransformerTrainer ..> AutoTokenizer : «uses»
+HuggingFaceTransformerTrainer ..> AutoModelForSequenceClassification : «uses»
+HuggingFaceTransformerTrainer ..> Trainer : «uses»
+HuggingFaceTransformerTrainer ..> TrainingArguments : «uses»
+
+MLflowDecorator ..> mlflow : «uses»
+
+@enduml