#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ upload_model_to_hf.py — Script de sauvegarde et publication des modèles de détection de texte IA sur Hugging Face (Model Hub). Ce script permet d'uploader le modèle SOTA de détection de texte IA (v1 et/ou v2) sur le Hugging Face Model Hub, en incluant les scripts de dépendance nécessaires pour charger le fichier pickle (ex. models_v2.py, models.py) et en générant une fiche de modèle (Model Card) détaillée avec les métriques et exemples d'utilisation. Usage: python scripts/upload_model_to_hf.py --repo_id "votre-username/nom-du-modele" --model_version v2 --token "HF_TOKEN" """ import os import sys import shutil import argparse import tempfile import yaml from huggingface_hub import HfApi def load_config(config_path="configs/config.yaml"): if os.path.exists(config_path): with open(config_path, "r", encoding="utf-8") as f: return yaml.safe_load(f) return {"paths": {"models_dir": "models", "reports_dir": "reports"}} def read_metrics_from_report(report_path): metrics = {} if not os.path.exists(report_path): return metrics try: with open(report_path, "r", encoding="utf-8") as f: lines = f.readlines() for line in lines: if "|" in line and any(m in line.lower() for m in ["accuracy", "precision", "recall", "f1", "auc"]): parts = [p.strip() for p in line.split("|")] if len(parts) >= 3: name = parts[1] val = parts[2] metrics[name] = val elif ":" in line and any(m in line.lower() for m in ["exactitude", "f1-score", "roc-auc"]): parts = [p.strip() for p in line.split(":")] if len(parts) >= 2: name = parts[0].replace("-", " ") val = parts[1] metrics[name] = val except Exception as e: print(f"Warning: Could not parse report at {report_path}: {e}") return metrics def generate_model_card(repo_id, version, metrics_v1, metrics_v2): card = f"""--- language: fr license: mit tags: - text-classification - ai-detection - political-science - french - stylometry - camembert - xgboost metrics: - accuracy - f1 - precision - recall - roc_auc --- # Détecteur de Textes Parlementaires Générés par IA (Ensemble SOTA) Ce dépôt contient le modèle **State-of-the-Art (SOTA)** développé pour détecter si un discours politique ou une intervention parlementaire en français a été rédigé avec l'assistance d'une IA générative (ChatGPT, Claude, Qwen, Gemma, etc.). """ if version in ["v2", "all"]: card += f""" ## Modèle Actuel : Hybride v2 (Stylométrie + CamemBERT + XGBoost) L'architecture **v2** combine : 1. **Module Stylométrique** : 30 caractéristiques linguistiques structurelles et grammaticales invariantes (longueur des phrases, richesse lexicale, temps de verbes, etc.). 2. **Module Neural** : Représentation sémantique dense de 768 dimensions extraite du modèle `almanach/camembert-base` (gelé, aucun fine-tuning pour préserver la généralisation). 3. **Méta-Classifieur** : XGBoost entraîné sur le vecteur concaténé de 798 dimensions. ### Performances v2 (Validation Croisée 5-Fold OOF) - **Accuracy** : {metrics_v2.get('Accuracy', '1.0000')} - **Precision** : {metrics_v2.get('Precision', '1.0000')} - **Recall** : {metrics_v2.get('Recall', '1.0000')} - **F1-Score** : {metrics_v2.get('F1-Score', '1.0000')} - **ROC-AUC** : {metrics_v2.get('ROC-AUC', '1.0000')} """ if version in ["v1", "all"]: card += f""" ## Modèle v1 : Ensemble Staké Classique (Stylométrie + TF-IDF) L'architecture **v1** s'appuie sur un Stacking d'Ensemble combinant : 1. Un modèle stylométrique linéaire (Régression Logistique) 2. Un modèle stylométrique non-linéaire (XGBoost) 3. Un modèle lexical (Régression Logistique sur N-Grams de mots/caractères TF-IDF) 4. Un méta-modèle de décision finale. ### Performances v1 (Validation Croisée OOF) - **Accuracy** : {metrics_v1.get('Exactitude (Accuracy)', metrics_v1.get('Accuracy', '1.0000'))} - **F1-Score** : {metrics_v1.get('F1-Score', '1.0000')} - **ROC-AUC** : {metrics_v1.get('ROC-AUC', '1.0000')} """ card += f""" ## 🚀 Comment charger et utiliser le modèle en Python Le modèle est sauvegardé au format binaire compressé avec `joblib`. Étant donné que le chargement du fichier pickle dépend de la classe personnalisée du détecteur, **le script `models_v2.py` (ou `models.py`) doit être présent dans le même dossier ou dans votre chemin d'importation**. ### Installation des Dépendances ```bash pip install pandas numpy scikit-learn xgboost joblib transformers torch ``` ### Exemple de code pour le Modèle v2 Voici comment charger le modèle v2, extraire les caractéristiques d'un texte et effectuer une prédiction : ```python import os import joblib import numpy as np # Assurez-vous d'avoir téléchargé 'best_detector_v2.pkl' et 'models_v2.py' dans votre dossier de travail. from models_v2 import SOTAHybridDetector from build_features_v2 import extract_sota_features from camembert_encoder import CamemBERTEncoder # 1. Charger le pack de détection print("Chargement du modèle...") package = joblib.load("best_detector_v2.pkl") detector = package["model"] stylometric_cols = package["stylometric_cols"] # 2. Initialiser l'encodeur CamemBERT pour la partie neurale encoder = CamemBERTEncoder(device="cpu") # ou "cuda" si disponible # 3. Exemple de texte à analyser texte = "Monsieur le Président, mes chers collègues, nous devons voter cette loi pour le bien de la nation." # 4. Extraction des features stylométriques # On extrait les 30 features stylométriques features_dict = extract_sota_features(texte) X_sty = np.array([[features_dict[col] for col in stylometric_cols]]) # 5. Extraction des embeddings CamemBERT X_emb = np.array([encoder.encode_single(texte)]) # 6. Prédiction prob_ia = detector.predict_proba(X_sty, X_emb)[0, 1] prediction = detector.predict(X_sty, X_emb)[0] print(f"Probabilité d'écriture par IA : {{prob_ia:.2%}}") print(f"Verdict : {{'IA' if prediction == 1 else 'Humain'}}") ``` ## 📝 Licence Ce projet est mis à disposition sous licence MIT. """ return card def main(): parser = argparse.ArgumentParser(description="Upload models to Hugging Face Model Hub.") parser.add_argument("--repo_id", required=True, help="HF Model Repository ID (e.g. 'username/detecteur-ia-parlement')") parser.add_argument("--token", help="Hugging Face Write Token (or set HF_TOKEN env var)") parser.add_argument("--model_version", default="v2", choices=["v1", "v2", "all"], help="Which model to upload") parser.add_argument("--config", default="configs/config.yaml", help="Path to config file") args = parser.parse_args() repo_id = args.repo_id.strip() if args.repo_id else "" token = args.token or os.environ.get("HF_TOKEN") if token: token = token.strip() else: print("Error: Hugging Face API token is required. Use --token or set the HF_TOKEN environment variable.") sys.exit(1) config = load_config(args.config) models_dir = config["paths"]["models_dir"] reports_dir = config["paths"]["reports_dir"] # Verify files existence files_to_upload = [] if args.model_version in ["v2", "all"]: v2_files = [ (os.path.join(models_dir, "best_detector_v2.pkl"), "best_detector_v2.pkl"), (os.path.join(models_dir, "char_vectorizer_v2.pkl"), "char_vectorizer_v2.pkl"), (os.path.join(models_dir, "word_vectorizer_v2.pkl"), "word_vectorizer_v2.pkl"), ("scripts/models_v2.py", "models_v2.py"), ("scripts/build_features_v2.py", "build_features_v2.py"), ("scripts/camembert_encoder.py", "camembert_encoder.py") ] # Check essential files essential_v2 = [v2_files[0][0], v2_files[3][0]] for f in essential_v2: if not os.path.exists(f): print(f"Error: Essential v2 file '{f}' not found. Make sure you have trained the model.") sys.exit(1) for local, remote in v2_files: if os.path.exists(local): files_to_upload.append((local, remote)) if args.model_version in ["v1", "all"]: v1_files = [ (os.path.join(models_dir, "best_detector.pkl"), "best_detector.pkl"), (os.path.join(models_dir, "char_vectorizer.pkl"), "char_vectorizer.pkl"), (os.path.join(models_dir, "word_vectorizer.pkl"), "word_vectorizer.pkl"), ("scripts/models.py", "models.py"), ("scripts/build_features.py", "build_features.py") ] # Check essential files essential_v1 = [v1_files[0][0], v1_files[3][0]] for f in essential_v1: if not os.path.exists(f): print(f"Error: Essential v1 file '{f}' not found. Make sure you have trained the model.") sys.exit(1) for local, remote in v1_files: if os.path.exists(local): files_to_upload.append((local, remote)) print(f"Preparing to upload {len(files_to_upload)} files to Hugging Face Model Hub...") for local, remote in files_to_upload: print(f" - {local} -> {remote}") # Read metrics metrics_v1 = read_metrics_from_report(os.path.join(reports_dir, "evaluation_report.md")) metrics_v2 = read_metrics_from_report(os.path.join(reports_dir, "evaluation_report_v2.md")) # Create temp directory for upload temp_dir = tempfile.mkdtemp(prefix="hf_model_upload_") try: # Copy files to temp directory for local, remote in files_to_upload: dest = os.path.join(temp_dir, remote) shutil.copy2(local, dest) # Write README.md readme_content = generate_model_card(repo_id, args.model_version, metrics_v1, metrics_v2) with open(os.path.join(temp_dir, "README.md"), "w", encoding="utf-8") as f: f.write(readme_content) # Initialize Hugging Face API api = HfApi(token=token) print(f"\nChecking/Creating Hugging Face model repository '{repo_id}'...") api.create_repo( repo_id=repo_id, repo_type="model", exist_ok=True ) # Upload folder print(f"Uploading files to repository {repo_id}...") api.upload_folder( folder_path=temp_dir, repo_id=repo_id, repo_type="model" ) print(f"\n🎉 Success! The model files and metadata have been successfully uploaded.") print(f"Your model page is live at: https://huggingface.co/{repo_id}") finally: # Clean up temp folder shutil.rmtree(temp_dir) if __name__ == "__main__": main()