plus de bug metrics bonnes

src/conf/config.yaml

@@ -5,7 +5,7 @@ defaults:
   - _self_ # Applique les valeurs définies dans ce fichier
 
 model:
-  type: "svm" # Définit quel modèle choisir
+  type: "bert" # Définit quel modèle choisir
   # Interpolation directe : Récupère les paramètres depuis la structure 'models'
   # (chargée via 'defaults: - model') en utilisant le 'type' défini ci-dessus.
   params: ${models.${model.type}}

src/cuml_trainer.py

@@ -5,6 +5,7 @@
 from abc import ABC, abstractmethod
 from typing import Optional, Union, Tuple
 import cupy as cp
+import numpy as np
 from scipy.sparse import csr_matrix
 import cudf
 from cuml.model_selection import train_test_split
@@ -69,6 +70,7 @@ class CuMLTrainer(BaseTrainer, ABC):
         if self.X_train_text is not None: # Évite de recharger/resplitter
             return
 
+        # Charger les données
         data = cudf.read_csv(self.data_path)
 
         # Identification des features
@@ -83,20 +85,33 @@ class CuMLTrainer(BaseTrainer, ABC):
         # Ajouter les autres colonnes avec un espace comme séparateur
         for col in feature_columns[1:]:
             texts_concatenated = texts_concatenated.str.cat(data[col].astype(str), sep=' ')
-            
+        
+        # Convertir les labels en format compatible avec cuML
         labels = data[self.target_column].astype(self._get_label_dtype()).values
-
+        
+        # Créer une copie des textes pour le stockage
+        texts_for_storage = texts_concatenated.copy()
+        
+        # Convertir les textes en indices numériques pour le split
+        # Cette étape est nécessaire car cuML ne peut pas gérer directement les objets string
+        # Nous utilisons une représentation numérique simple pour le split uniquement
+        # Les textes originaux seront stockés pour la vectorisation ultérieure
+        indices = cp.arange(len(texts_concatenated))
+        
         # Premier split: 80% train, 20% temp (pour val+test)
-        X_train, X_temp, y_train, y_temp = train_test_split(
-            texts_concatenated, labels, test_size=test_size, random_state=random_state, stratify=labels
+        train_indices, temp_indices, y_train, y_temp = train_test_split(
+            indices, labels, test_size=test_size, random_state=random_state, stratify=labels
         )
-
+        
         # Deuxième split: 50% validation, 50% test sur l'ensemble temp
-        # (val_size=0.5 sur 20% donne 10% du total pour val et 10% pour test)
-        # Utilisation de stratify=y_temp pour maintenir la distribution des classes
-        X_val, X_test, y_val, y_test = train_test_split(
-            X_temp, y_temp, test_size=val_size, random_state=random_state, stratify=y_temp
+        val_indices, test_indices, y_val, y_test = train_test_split(
+            temp_indices, y_temp, test_size=val_size, random_state=random_state, stratify=y_temp
         )
+        
+        # Récupérer les textes correspondant aux indices
+        X_train = texts_for_storage.iloc[train_indices.get()]
+        X_val = texts_for_storage.iloc[val_indices.get()]
+        X_test = texts_for_storage.iloc[test_indices.get()]
 
         # Stockage des résultats
         self.X_train_text = X_train

src/trainers/huggingface/huggingface_transformer_trainer.py

@@ -159,16 +159,28 @@ class HuggingFaceTransformerTrainer(BaseTrainer):
         texts = features_df[features_df.columns[0]]
         for col in features_df.columns[1:]:
             texts = texts.str.cat(features_df[col], sep=' ')
-        # texts est une cudf.Series, labels est un cp.ndarray
-        # Utiliser cuml.model_selection.train_test_split directement
-        # Premier split: 80% train, 20% temp
-        X_train_text, X_temp_text, y_train, y_temp = train_test_split(
-            texts, labels, test_size=0.2, random_state=42, stratify=labels
+            
+        # Créer une copie des textes pour le stockage
+        texts_for_storage = texts.copy()
+        
+        # Utiliser des indices numériques pour le split au lieu des textes directement
+        # Cette approche évite les problèmes de conversion des objets string en tableaux CUDA
+        indices = cp.arange(len(texts))
+        
+        # Premier split: 80% train, 20% temp en utilisant les indices
+        train_indices, temp_indices, y_train, y_temp = train_test_split(
+            indices, labels, test_size=0.2, random_state=42, stratify=labels
         )
-        # Deuxième split: 50% validation, 50% test sur temp (donne 10% val, 10% test du total)
-        X_val_text, X_test_text, y_val, y_test = train_test_split(
-            X_temp_text, y_temp, test_size=0.5, random_state=42, stratify=y_temp
+        
+        # Deuxième split: 50% validation, 50% test sur temp
+        val_indices, test_indices, y_val, y_test = train_test_split(
+            temp_indices, y_temp, test_size=0.5, random_state=42, stratify=y_temp
         )
+        
+        # Récupérer les textes correspondant aux indices
+        X_train_text = texts_for_storage.iloc[train_indices.get()]
+        X_val_text = texts_for_storage.iloc[val_indices.get()]
+        X_test_text = texts_for_storage.iloc[test_indices.get()]
 
         # Fonction pour créer un dataset Hugging Face à partir de cudf.Series et cp.ndarray
         def create_hf_dataset(text_series: cudf.Series, label_array: cp.ndarray) -> HFDataset:
@@ -246,18 +258,15 @@ class HuggingFaceTransformerTrainer(BaseTrainer):
         params = self.config.model.params
         return TrainingArguments(
             output_dir=params.get("output_dir", "./results"),
-            num_train_epochs=params.get("epochs"),
-            per_device_train_batch_size=params.get("batch_size"),
-            per_device_eval_batch_size=params.get("batch_size"),
-            learning_rate=params.get("learning_rate"),
-            warmup_steps=params.get("warmup_steps"),
-            weight_decay=params.get("weight_decay"),
-            adam_epsilon=params.get("adam_epsilon"),
-            # Ajout de paramètres importants pour l'évaluation
-            evaluation_strategy="epoch", # Évaluer à chaque époque
-            save_strategy="epoch",       # Sauvegarder le modèle à chaque époque
-            load_best_model_at_end=True, # Charger le meilleur modèle à la fin
-            metric_for_best_model="f1",  # Utiliser F1 pour déterminer le meilleur modèle (ou 'accuracy')
-            logging_dir=params.get("logging_dir", "./logs"), # Pour les logs TensorBoard
-            logging_steps=params.get("logging_steps", 10), # Fréquence des logs
+            num_train_epochs=float(params.get("epochs", 3)),
+            per_device_train_batch_size=int(params.get("batch_size", 8)),
+            per_device_eval_batch_size=int(params.get("batch_size", 8)),
+            learning_rate=float(params.get("learning_rate", 5e-5)),
+            warmup_steps=int(params.get("warmup_steps", 0)),
+            weight_decay=float(params.get("weight_decay", 0.0)),
+            # Paramètres d'évaluation simplifiés pour compatibilité
+            eval_steps=100,  # Évaluer tous les 100 pas
+            save_steps=100,  # Sauvegarder tous les 100 pas
+            logging_dir=params.get("logging_dir", "./logs"),
+            logging_steps=int(params.get("logging_steps", 10))
         )