scripts/camembert_encoder.py

import os
import sys
import torch
import numpy as np
import pandas as pd
from transformers import CamembertTokenizer, CamembertModel
from tqdm import tqdm
import yaml
import argparse

# Constants
MODEL_NAME = "almanach/camembert-base"
EMBEDDING_DIM = 768
MAX_LENGTH = 512
BATCH_SIZE = 32

def load_config(config_path="configs/config.yaml"):
    with open(config_path, "r", encoding="utf-8") as f:
        return yaml.safe_load(f)

class CamemBERTEncoder:
    """Extracteur d'embeddings CamemBERT gelé pour le français.
    Utilise le token [CLS] comme représentation dense du document."""
    
    def __init__(self, model_name=MODEL_NAME, device=None):
        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
        print(f"Chargement de CamemBERT ({model_name}) sur {self.device}...")
        self.tokenizer = CamembertTokenizer.from_pretrained(model_name)
        self.model = CamembertModel.from_pretrained(model_name).to(self.device)
        self.model.eval()  # Mode inférence (poids gelés)
        # Freeze all parameters
        for param in self.model.parameters():
            param.requires_grad = False
        print(f"CamemBERT chargé avec succès ({sum(p.numel() for p in self.model.parameters())/1e6:.1f}M paramètres gelés).")
    
    def encode_single(self, text: str) -> np.ndarray:
        """Encode un seul texte et retourne le vecteur [CLS] de dimension 768."""
        inputs = self.tokenizer(
            text, 
            return_tensors="pt", 
            max_length=MAX_LENGTH, 
            truncation=True, 
            padding=True
        ).to(self.device)
        with torch.no_grad():
            outputs = self.model(**inputs)
        # [CLS] token is the first token
        cls_embedding = outputs.last_hidden_state[:, 0, :].cpu().numpy().flatten()
        return cls_embedding
    
    def encode_batch(self, texts: list, batch_size=BATCH_SIZE) -> np.ndarray:
        """Encode un lot de textes et retourne une matrice (N, 768)."""
        # Sort indices by text length to group similar lengths and minimize padding overhead
        sorted_indices = sorted(range(len(texts)), key=lambda idx: len(str(texts[idx])))
        sorted_texts = [texts[idx] for idx in sorted_indices]
        
        all_embeddings = [None] * len(texts)
        
        for i in tqdm(range(0, len(sorted_texts), batch_size), desc="Extraction CamemBERT"):
            batch_texts = sorted_texts[i:i+batch_size]
            batch_texts = [str(t) if pd.notna(t) else "" for t in batch_texts]
            inputs = self.tokenizer(
                batch_texts,
                return_tensors="pt",
                max_length=MAX_LENGTH,
                truncation=True,
                padding=True
            ).to(self.device)
            with torch.no_grad():
                outputs = self.model(**inputs)
            cls_embeddings = outputs.last_hidden_state[:, 0, :].cpu().numpy()
            
            for j, emb in enumerate(cls_embeddings):
                orig_idx = sorted_indices[i + j]
                all_embeddings[orig_idx] = emb
                
        return np.array(all_embeddings)

def main():
    parser = argparse.ArgumentParser(description="Extraction d'embeddings CamemBERT pour le détecteur SOTA.")
    parser.add_argument("--config", default="configs/config.yaml", help="Chemin vers le fichier de config")
    parser.add_argument("--batch_size", type=int, default=32, help="Taille du batch pour l'encodage")
    args = parser.parse_args()
    
    config = load_config(args.config)
    raw_dir = config["paths"]["raw_dir"]
    processed_dir = config["paths"]["processed_dir"]
    os.makedirs(processed_dir, exist_ok=True)
    
    encoder = CamemBERTEncoder()
    
    # 1. Process Training Data
    print("\n=== Encodage des données d'entraînement ===")
    human_path = os.path.join(raw_dir, "human_corpus.csv")
    ai_path = os.path.join(raw_dir, "ai_corpus.csv")
    
    df_human = pd.read_csv(human_path)
    df_ai = pd.read_csv(ai_path)
    df_train = pd.concat([df_human, df_ai], ignore_index=True)
    print(f"Corpus d'entraînement: {len(df_train)} textes")
    
    train_embeddings = encoder.encode_batch(df_train["text"].tolist(), batch_size=args.batch_size)
    emb_cols = [f"camembert_{i}" for i in range(EMBEDDING_DIM)]
    df_train_emb = pd.DataFrame(train_embeddings, columns=emb_cols)
    df_train_emb.to_csv(os.path.join(processed_dir, "train_embeddings_camembert.csv"), index=False)
    print(f"Embeddings d'entraînement sauvegardés: {train_embeddings.shape}")
    
    # 2. Process Recent Debates
    print("\n=== Encodage des débats récents ===")
    recent_path = os.path.join(raw_dir, "recent_debates.csv")
    if os.path.exists(recent_path):
        df_recent = pd.read_csv(recent_path)
        print(f"Débats récents: {len(df_recent)} textes")
        recent_embeddings = encoder.encode_batch(df_recent["text"].tolist(), batch_size=args.batch_size)
        df_recent_emb = pd.DataFrame(recent_embeddings, columns=emb_cols)
        df_recent_emb.to_csv(os.path.join(processed_dir, "recent_embeddings_camembert.csv"), index=False)
        print(f"Embeddings récents sauvegardés: {recent_embeddings.shape}")
    
    print("\n✅ Extraction CamemBERT terminée avec succès.")

if __name__ == "__main__":
    main()