correction bug metrics bien implémentés

src/cuml_trainer.py

@@ -8,7 +8,6 @@ import cupy as cp
 from scipy.sparse import csr_matrix
 import cudf
 from cuml.model_selection import train_test_split
-import logging
 
 from config import Config
 from base_trainer import BaseTrainer
@@ -39,7 +38,6 @@ class CuMLTrainer(BaseTrainer, ABC):
         super().__init__(config, data_path, target_column)
         self.vectorizer: Vectorizer = None
         self.classifier: object = None # Déjà dans BaseTrainer, mais redéfini pour clarté
-        self.logger = logging.getLogger(__name__)
 
         # Attributs pour stocker les données splittées (texte brut)
         self.X_train_text: Optional[cudf.Series] = None
@@ -69,10 +67,8 @@ class CuMLTrainer(BaseTrainer, ABC):
         Stocke les résultats dans les attributs de l'instance.
         """
         if self.X_train_text is not None: # Évite de recharger/resplitter
-            self.logger.info("Données déjà chargées et splittées.")
             return
 
-        self.logger.info(f"Chargement des données depuis {self.data_path}...")
         data = cudf.read_csv(self.data_path)
 
         # Identification et concaténation des features
@@ -82,7 +78,6 @@ class CuMLTrainer(BaseTrainer, ABC):
         texts_concatenated = data[feature_columns].astype(str).agg(' '.join, axis=1)
         labels = data[self.target_column].astype(self._get_label_dtype()).values
 
-        self.logger.info("Séparation des données en train/validation/test (80/10/10)...")
         # 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
@@ -103,8 +98,6 @@ class CuMLTrainer(BaseTrainer, ABC):
         self.y_val = y_val
         self.y_test = y_test
 
-        self.logger.info(f"Taille Train: {len(self.X_train_text)}, Val: {len(self.X_val_text)}, Test: {len(self.X_test_text)}")
-
 
     def train(self) -> None:
         """
@@ -116,7 +109,6 @@ class CuMLTrainer(BaseTrainer, ABC):
         if self.vectorizer is None or self.classifier is None:
              raise RuntimeError("Les composants (vectorizer, classifier) doivent être construits avant l'entraînement. Appelez build_components().")
 
-        self.logger.info("Vectorisation des données textuelles...")
         # fit_transform sur l'entraînement
         self.X_train_vec = self.vectorizer.fit_transform(self.X_train_text)
         # transform sur validation et test
@@ -126,9 +118,7 @@ class CuMLTrainer(BaseTrainer, ABC):
         # Préparation pour cuML (conversion en dense si nécessaire)
         X_train_prepared = self._prepare_input_for_fit(self.X_train_vec)
 
-        self.logger.info("Entraînement du modèle...")
         self.classifier.fit(X_train_prepared, self.y_train)
-        self.logger.info("Entraînement terminé.")
 
 
     def evaluate(self, use_validation_set=False) -> dict:
@@ -145,12 +135,10 @@ class CuMLTrainer(BaseTrainer, ABC):
              raise RuntimeError("Le classifieur doit être entraîné avant l'évaluation. Appelez train().")
 
         if use_validation_set:
-            self.logger.info("Évaluation sur l'ensemble de validation...")
             X_eval_vec = self.X_val_vec
             y_true = self.y_val
             dataset_name = "validation"
         else:
-            self.logger.info("Évaluation sur l'ensemble de test...")
             X_eval_vec = self.X_test_vec
             y_true = self.y_test
             dataset_name = "test"
@@ -159,46 +147,23 @@ class CuMLTrainer(BaseTrainer, ABC):
         X_eval_prepared = self._prepare_input_for_predict(X_eval_vec)
         y_pred = self.classifier.predict(X_eval_prepared)
 
-        # Essayer de récupérer les probabilités
-        y_proba = None
-        try:
-            # Utilise la méthode _get_positive_probabilities définie dans BaseTrainer
-            # et potentiellement surchargée dans les sous-classes (comme SvmTrainer)
-            y_proba = self._get_positive_probabilities(X_eval_prepared)
-        except NotImplementedError:
-            self.logger.warning("La méthode _get_positive_probabilities n'est pas implémentée pour ce modèle, AUC pourrait être moins précis ou indisponible.")
-        except Exception as e:
-            self.logger.warning(f"Erreur lors de la récupération des probabilités : {e}")
-
+        # Récupérer les probabilités pour la classe positive
+        y_proba = self._get_positive_probabilities(X_eval_prepared)
 
-        # Calcul et logging des métriques
+        # Calcul des métriques
         prefix = f"{self.config.model.type.lower()}_{dataset_name}"
         if self.metrics_calculator is None:
              # Initialisation par défaut si non fait ailleurs
-             from interfaces.metrics_calculator import DefaultMetricsCalculator # Utiliser l'implémentation par défaut
+             from interfaces.metrics_calculator import DefaultMetricsCalculator
              self.metrics_calculator = DefaultMetricsCalculator()
 
-        # Déterminer si binaire ou multiclasse
-        num_classes = len(cp.unique(y_true))
-        self.logger.info(f"Nombre de classes détectées dans y_true ({dataset_name}): {num_classes}")
-
-        if num_classes <= 2:
-             metrics = self.metrics_calculator.calculate_and_log(
-                 y_true=y_true,
-                 y_pred=y_pred,
-                 y_proba=y_proba, # Passer les probas
-                 prefix=prefix
-             )
-        else:
-             metrics = self.metrics_calculator.calculate_and_log_multiclass(
-                 y_true=y_true,
-                 y_pred=y_pred,
-                 y_proba=y_proba, # Passer les probas
-                 prefix=prefix
-             )
-
-        # Afficher les résultats
-        self.logger.info(f"Métriques d'évaluation ({dataset_name}): {metrics}")
+        # Utiliser la méthode calculate_and_log pour la classification binaire
+        metrics = self.metrics_calculator.calculate_and_log(
+            y_true=y_true,
+            y_pred=y_pred,
+            y_proba=y_proba,
+            prefix=prefix
+        )
 
         return metrics
 

src/interfaces/metrics_calculator.py

@@ -1,157 +1,134 @@
 import cupy as cp
-from typing import Dict, Protocol, Optional
+from typing import Dict, Protocol, Tuple
 import warnings
-# Utiliser cuml.metrics
-from cuml.metrics import accuracy_score, precision_recall_fscore_support, roc_auc_score
+# Utiliser cuml.metrics pour les calculs accélérés par GPU
+from cuml.metrics import accuracy_score, precision_recall_curve, roc_auc_score
 
-# Ignorer les avertissements (peut nécessiter ajustement si cuML utilise d'autres types)
-# Attention: Masquer tous les warnings peut cacher des problèmes potentiels.
+# Filtrer les avertissements
 warnings.filterwarnings("ignore", category=Warning)
 
 
 class MetricsCalculator(Protocol):
     """
-    Interface pour les calculateurs de métriques.
+    Interface pour les calculateurs de métriques pour la classification binaire.
     """
     def calculate_and_log(
         self,
         y_true: cp.ndarray,
         y_pred: cp.ndarray,
-        y_proba: Optional[cp.ndarray], # Probabilités pour AUC
+        y_proba: cp.ndarray, # Probabilités classe positive (1D) - Supposées toujours fournies
         prefix: str
     ) -> Dict[str, float]:
         """
         Calcule les métriques pour un problème binaire.
-        """
-        pass
-
-    def calculate_and_log_multiclass(
-        self,
-        y_true: cp.ndarray,
-        y_pred: cp.ndarray,
-        y_proba: Optional[cp.ndarray], # Probabilités (potentiellement pour futures métriques)
-        prefix: str
-    ) -> Dict[str, float]:
-        """
-        Calcule les métriques pour un problème multiclasses.
+        Assume que y_proba est toujours fourni et est un tableau 1D
+        contenant les probabilités de la classe positive.
+        Retourne Accuracy, AUC ROC, Precision, Recall et F1 Score.
         """
         pass
 
 
 class DefaultMetricsCalculator(MetricsCalculator):
     """
-    Implémentation concrète de MetricsCalculator utilisant cuML.
-    Calcule accuracy, et F1/precision/recall pondérés.
-    Calcule AUC-ROC pour les problèmes binaires *uniquement* si les probabilités sont fournies.
-    Ne calcule pas l'AUC-ROC pour les problèmes multiclasses (non supporté par cuml.metrics.roc_auc_score).
-    Retourne NaN pour les métriques non calculables.
+    Implémentation concrète de MetricsCalculator utilisant cuML pour la classification binaire.
+    Calcule l'accuracy, l'AUC-ROC, la précision, le rappel et le F1 score en utilisant les fonctions cuML.
+    Utilise precision_recall_curve pour calculer les métriques de précision, rappel et F1 score optimales.
+    Assume que les données d'entrée sont valides et que y_proba est toujours fourni
+    en tant que tableau 1D des probabilités de la classe positive.
     """
 
     def calculate_and_log(
         self,
         y_true: cp.ndarray,
         y_pred: cp.ndarray,
-        y_proba: Optional[cp.ndarray], # Probabilités requises pour AUC
+        y_proba: cp.ndarray, # Probabilités classe positive (1D) - Supposées toujours fournies
         prefix: str
     ) -> Dict[str, float]:
         """
-        Calcule les métriques pour un problème binaire.
-        Utilise y_proba pour AUC si disponible.
-        Utilise average='weighted' pour precision/recall/f1.
+        Calcule l'accuracy, l'AUC ROC, la précision, le rappel et le F1 score pour un problème binaire en utilisant cuML.
+        Utilise precision_recall_curve pour calculer les métriques optimales.
+        Assume des entrées valides et que y_proba est un tableau 1D fourni.
         """
-        metrics: Dict[str, float] = {}
-
-        try:
-            # Accuracy
-            acc = accuracy_score(y_true, y_pred)
-            metrics[f"{prefix}_accuracy"] = float(acc)
-
-            # Precision, Recall, F1 (Weighted)
-            prec, rec, f1, _ = precision_recall_fscore_support(
-                y_true, y_pred, average='weighted'
-            )
-            metrics[f"{prefix}_precision_weighted"] = float(prec)
-            metrics[f"{prefix}_recall_weighted"] = float(rec)
-            metrics[f"{prefix}_f1_weighted"] = float(f1)
-
-        except Exception:
-            # En cas d'erreur sur les métriques de base, remplir avec NaN
-            metrics.setdefault(f"{prefix}_accuracy", float('nan'))
-            metrics.setdefault(f"{prefix}_precision_weighted", float('nan'))
-            metrics.setdefault(f"{prefix}_recall_weighted", float('nan'))
-            metrics.setdefault(f"{prefix}_f1_weighted", float('nan'))
-
-        # AUC-ROC (Binary only, requires probabilities)
-        auc: float = float('nan') # Default to NaN
-        if y_proba is not None:
-            try:
-                # Ensure y_true and y_proba have compatible shapes and types
-                if y_true.dtype != cp.int32 and y_true.dtype != cp.int64:
-                     y_true = y_true.astype(cp.int32)
-
-                # roc_auc_score expects probabilities of the positive class
-                if y_proba.ndim == 2 and y_proba.shape[1] == 2:
-                    proba_pos_class = y_proba[:, 1]
-                elif y_proba.ndim == 1:
-                    proba_pos_class = y_proba # Assume already positive class proba
-                else:
-                    # Forme inattendue, ne peut pas calculer l'AUC
-                     raise ValueError("y_proba a une forme inattendue pour le calcul AUC binaire.")
-
-                if proba_pos_class.dtype != cp.float32 and proba_pos_class.dtype != cp.float64:
-                     proba_pos_class = proba_pos_class.astype(cp.float32)
-
-                # Check if y_true contains more than one class before calculating AUC
-                unique_labels = cp.unique(y_true)
-                if len(unique_labels) >= 2:
-                    auc_score = roc_auc_score(y_true, proba_pos_class)
-                    auc = float(auc_score) # Cast to float
-
-            except (ValueError, TypeError, Exception):
-                 # Si une erreur se produit (ex: une seule classe, type incorrect, autre), AUC reste NaN
-                 pass # auc est déjà float('nan')
-
-        metrics[f"{prefix}_auc_roc"] = auc
-        # Ensure all values in the returned dict are standard floats
-        return {k: float(v) for k, v in metrics.items()}
-
-
-    def calculate_and_log_multiclass(
-        self,
-        y_true: cp.ndarray,
-        y_pred: cp.ndarray,
-        y_proba: Optional[cp.ndarray], # Gardé pour cohérence d'interface
-        prefix: str
-    ) -> Dict[str, float]:
+        # 1. Calculer l'accuracy (comme dans l'exemple accuracy_score)
+        acc = accuracy_score(y_true, y_pred)
+
+        # 2. Calculer l'AUC binaire (comme dans l'exemple roc_auc_score)
+        auc = roc_auc_score(y_true.astype(cp.int32), y_proba.astype(cp.float32))
+
+        # 3. Utiliser precision_recall_curve pour obtenir les courbes
+        precision, recall, thresholds = precision_recall_curve(
+            y_true.astype(cp.int32), y_proba.astype(cp.float32)
+        )
+        
+        # 4. Calculer la précision, le rappel et le F1 score optimaux
+        optimal_precision, optimal_recall, optimal_f1, optimal_threshold = self._calculate_optimal_f1(
+            precision, recall, thresholds
+        )
+
+        # Construire le dictionnaire des métriques scalaires disponibles
+        metrics = {
+            f"{prefix}_accuracy"           : acc,
+            f"{prefix}_precision"          : optimal_precision,
+            f"{prefix}_recall"             : optimal_recall,
+            f"{prefix}_f1"                 : optimal_f1,
+            f"{prefix}_optimal_threshold"  : optimal_threshold,
+            f"{prefix}_auc_roc"            : auc
+        }
+        # Retourner les métriques scalaires calculées
+        return metrics
+        
+    def _calculate_optimal_f1(
+        self, 
+        precision: cp.ndarray, 
+        recall: cp.ndarray, 
+        thresholds: cp.ndarray
+    ) -> Tuple[float, float, float, float]:
         """
-        Calcule les métriques pour un problème multiclasses.
-        AUC-ROC n'est pas calculé (retourne NaN) car non supporté par cuml.metrics.roc_auc_score.
-        Utilise average='weighted' pour precision/recall/f1.
+        Calcule le F1 score optimal à partir des courbes de précision et de rappel.
+        
+        Args:
+            precision: Tableau de précisions pour différents seuils
+            recall: Tableau de rappels pour différents seuils
+            thresholds: Tableau de seuils correspondants
+            
+        Returns:
+            Tuple contenant (précision optimale, rappel optimal, F1 score optimal, seuil optimal)
         """
-        metrics: Dict[str, float] = {}
-
-        try:
-            # Accuracy
-            acc = accuracy_score(y_true, y_pred)
-            metrics[f"{prefix}_accuracy"] = float(acc)
-
-            # Precision, Recall, F1 (Weighted)
-            prec, rec, f1, _ = precision_recall_fscore_support(
-                y_true, y_pred, average="weighted"
-            )
-            metrics[f"{prefix}_precision_weighted"] = float(prec)
-            metrics[f"{prefix}_recall_weighted"] = float(rec)
-            metrics[f"{prefix}_f1_weighted"] = float(f1)
-
-        except Exception:
-             # En cas d'erreur sur les métriques de base, remplir avec NaN
-            metrics.setdefault(f"{prefix}_accuracy", float('nan'))
-            metrics.setdefault(f"{prefix}_precision_weighted", float('nan'))
-            metrics.setdefault(f"{prefix}_recall_weighted", float('nan'))
-            metrics.setdefault(f"{prefix}_f1_weighted", float('nan'))
-
-        # AUC Multiclasse non supporté, retourner NaN
-        metrics[f"{prefix}_auc_roc"] = float('nan')
-
-        # Ensure all values in the returned dict are standard floats
-        return {k: float(v) for k, v in metrics.items()}
+        # Ajouter le seuil 1.0 à thresholds (qui n'est pas inclus par défaut dans precision_recall_curve)
+        if len(thresholds) > 0:
+            thresholds_with_one = cp.append(thresholds, cp.array([1.0]))
+        else:
+            thresholds_with_one = cp.array([1.0])
+            
+        # Calculer le F1 score pour chaque point de la courbe
+        # F1 = 2 * (precision * recall) / (precision + recall)
+        # Éviter la division par zéro
+        denominator = precision + recall
+        # Créer un masque pour éviter la division par zéro
+        mask = denominator > 0
+        
+        # Initialiser le F1 score avec des zéros
+        f1_scores = cp.zeros_like(precision)
+        # Calculer le F1 score uniquement où le dénominateur n'est pas zéro
+        f1_scores[mask] = 2 * (precision[mask] * recall[mask]) / denominator[mask]
+        
+        # Trouver l'indice du F1 score maximal
+        if len(f1_scores) > 0:
+            best_idx = cp.argmax(f1_scores)
+            best_precision = float(precision[best_idx])
+            best_recall = float(recall[best_idx])
+            best_f1 = float(f1_scores[best_idx])
+            
+            # Obtenir le seuil optimal
+            if best_idx < len(thresholds_with_one):
+                best_threshold = float(thresholds_with_one[best_idx])
+            else:
+                best_threshold = 0.5  # Valeur par défaut si l'indice est hors limites
+        else:
+            # Valeurs par défaut si les tableaux sont vides
+            best_precision = 0.0
+            best_recall = 0.0
+            best_f1 = 0.0
+            best_threshold = 0.5
+            
+        return best_precision, best_recall, best_f1, best_threshold

src/trainers/huggingface/huggingface_transformer_trainer.py

@@ -13,7 +13,7 @@ from cuml.model_selection import train_test_split
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, EvalPrediction
 from datasets import Dataset as HFDataset # Utiliser le type Dataset de Hugging Face pour plus de clarté
 # Utiliser cuml.metrics
-from cuml.metrics import accuracy_score, precision_recall_fscore_support, roc_auc_score
+from cuml.metrics import accuracy_score, precision_recall_curve, roc_auc_score
 # Importer cupy pour la conversion et argmax
 import cupy as cp
 # numpy n'est plus nécessaire ici
@@ -29,66 +29,93 @@ def compute_metrics(p: EvalPrediction) -> Dict[str, float]:
     # Convertir les labels numpy en cupy
     labels_cp = cp.asarray(p.label_ids)
     # Obtenir les prédictions en appliquant argmax aux logits avec cupy
-    preds_cp = cp.argmax(cp.asarray(logits), axis=1) # Utilisation de cp.argmax
-
-    metrics: Dict[str, float] = {}
-
-    try:
-        # Accuracy avec cuML
-        acc = accuracy_score(labels_cp, preds_cp)
-        metrics["accuracy"] = float(acc)
-
-        # Precision, Recall, F1 (Weighted) avec cuML
-        prec, rec, f1, _ = precision_recall_fscore_support(
-            labels_cp, preds_cp, average='weighted'
-        )
-        metrics["precision_weighted"] = float(prec)
-        metrics["recall_weighted"] = float(rec)
-        metrics["f1_weighted"] = float(f1)
-
-    except Exception:
-        # Remplir avec NaN si erreur
-        metrics.setdefault("accuracy", float('nan'))
-        metrics.setdefault("precision_weighted", float('nan'))
-        metrics.setdefault("recall_weighted", float('nan'))
-        metrics.setdefault("f1_weighted", float('nan'))
-
-    # Calcul AUC (binaire seulement avec cuML)
-    auc: float = float('nan') # Default NaN
-    num_classes = logits.shape[1]
-
-    if num_classes == 2:
-        try:
-            # Obtenir les probabilités (softmax) et convertir en cupy
-            probas_torch = F.softmax(torch.tensor(logits), dim=-1)
-            probas_cp = cp.asarray(probas_torch)
-
-            # Utiliser les probas de la classe positive
-            proba_pos_class = probas_cp[:, 1]
-
-            # S'assurer que les types sont corrects pour cuML roc_auc_score
-            if labels_cp.dtype != cp.int32 and labels_cp.dtype != cp.int64:
-                labels_cp = labels_cp.astype(cp.int32)
-            if proba_pos_class.dtype != cp.float32 and proba_pos_class.dtype != cp.float64:
-                proba_pos_class = proba_pos_class.astype(cp.float32)
-
-            # Vérifier qu'il y a plus d'une classe dans les labels réels
-            unique_labels = cp.unique(labels_cp)
-            if len(unique_labels) >= 2:
-                 auc_score = roc_auc_score(labels_cp, proba_pos_class)
-                 auc = float(auc_score) # Cast to float
-            # else: # Pas de log
-
-        except (ValueError, TypeError, Exception):
-            # auc reste NaN en cas d'erreur, pas de log
-            pass
-    # else: # Pas de log pour le cas multiclasse
-        # auc reste NaN
-
-    metrics["auc_roc"] = auc
-
-    # Retourner les métriques avec les noms de base
-    return {k: float(v) for k, v in metrics.items()} # Assurer float standard
+    preds_cp = cp.argmax(cp.asarray(logits), axis=1)
+
+    # Obtenir les probabilités (softmax) et convertir en cupy
+    probas_torch = F.softmax(torch.tensor(logits), dim=-1)
+    probas_cp = cp.asarray(probas_torch)
+    
+    # Utiliser les probas de la classe positive
+    proba_pos_class = probas_cp[:, 1]
+
+    # 1. Calculer l'accuracy
+    acc = accuracy_score(labels_cp, preds_cp)
+    
+    # 2. Calculer l'AUC ROC
+    auc = roc_auc_score(labels_cp.astype(cp.int32), proba_pos_class.astype(cp.float32))
+    
+    # 3. Utiliser precision_recall_curve pour obtenir les courbes
+    precision, recall, thresholds = precision_recall_curve(
+        labels_cp.astype(cp.int32), proba_pos_class.astype(cp.float32)
+    )
+    
+    # 4. Calculer la précision, le rappel et le F1 score optimaux
+    optimal_precision, optimal_recall, optimal_f1, optimal_threshold = calculate_optimal_f1(
+        precision, recall, thresholds
+    )
+
+    # Construire le dictionnaire des métriques
+    metrics = {
+        "accuracy": float(acc),
+        "precision": float(optimal_precision),
+        "recall": float(optimal_recall),
+        "f1": float(optimal_f1),
+        "optimal_threshold": float(optimal_threshold),
+        "auc_roc": float(auc)
+    }
+    
+    return metrics
+
+def calculate_optimal_f1(precision: cp.ndarray, recall: cp.ndarray, thresholds: cp.ndarray):
+    """
+    Calcule le F1 score optimal à partir des courbes de précision et de rappel.
+    
+    Args:
+        precision: Tableau de précisions pour différents seuils
+        recall: Tableau de rappels pour différents seuils
+        thresholds: Tableau de seuils correspondants
+        
+    Returns:
+        Tuple contenant (précision optimale, rappel optimal, F1 score optimal, seuil optimal)
+    """
+    # Ajouter le seuil 1.0 à thresholds (qui n'est pas inclus par défaut dans precision_recall_curve)
+    if len(thresholds) > 0:
+        thresholds_with_one = cp.append(thresholds, cp.array([1.0]))
+    else:
+        thresholds_with_one = cp.array([1.0])
+        
+    # Calculer le F1 score pour chaque point de la courbe
+    # F1 = 2 * (precision * recall) / (precision + recall)
+    # Éviter la division par zéro
+    denominator = precision + recall
+    # Créer un masque pour éviter la division par zéro
+    mask = denominator > 0
+    
+    # Initialiser le F1 score avec des zéros
+    f1_scores = cp.zeros_like(precision)
+    # Calculer le F1 score uniquement où le dénominateur n'est pas zéro
+    f1_scores[mask] = 2 * (precision[mask] * recall[mask]) / denominator[mask]
+    
+    # Trouver l'indice du F1 score maximal
+    if len(f1_scores) > 0:
+        best_idx = cp.argmax(f1_scores)
+        best_precision = float(precision[best_idx])
+        best_recall = float(recall[best_idx])
+        best_f1 = float(f1_scores[best_idx])
+        
+        # Obtenir le seuil optimal
+        if best_idx < len(thresholds_with_one):
+            best_threshold = float(thresholds_with_one[best_idx])
+        else:
+            best_threshold = 0.5  # Valeur par défaut si l'indice est hors limites
+    else:
+        # Valeurs par défaut si les tableaux sont vides
+        best_precision = 0.0
+        best_recall = 0.0
+        best_f1 = 0.0
+        best_threshold = 0.5
+        
+    return best_precision, best_recall, best_f1, best_threshold
 
 class HuggingFaceTransformerTrainer(BaseTrainer):
     """
@@ -153,7 +180,6 @@ 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_list = texts.to_arrow().to_pylist()
         # texts est une cudf.Series, labels est un cp.ndarray
         # Utiliser cuml.model_selection.train_test_split directement
         # Premier split: 80% train, 20% temp