File size: 5,323 Bytes
eb72d30 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | 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()
|