BAKOUAN/t5-small-finetuned-summary

T5 Small Fine-tuned for Summarization

Ce modèle est une version fine-tunée de T5 Small pour la génération automatique de résumés de texte, optimisée pour le français. Il a été entraîné sur des données personnalisées et exporté en format ONNX pour une inférence rapide sur CPU.

Description du modèle

• Modèle de base : T5 Small (t5-small)
• Tâche : Résumé automatique (summarization)
• Format : ONNX quantifié INT8 (logits-only pour compatibilité)
• Langue : Français
• Taille : ~59 MB
• Latence : ~60 ms par forward pass sur CPU

Métriques d'évaluation

• Loss d'évaluation : 0.547
• Temps d'évaluation : 161 secondes
• Échantillons/seconde : 0.671

(Ajoutez ici des métriques BLEU/ROUGE si vous les avez calculées)

Utilisation

Avec Hugging Face Transformers (pour tests rapides)

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

# Charger le tokenizer et le modèle depuis Hugging Face
tokenizer = AutoTokenizer.from_pretrained("votre-username/t5-small-finetuned-summary")
model = AutoModelForSeq2SeqLM.from_pretrained("votre-username/t5-small-finetuned-summary")

# Préparer l'entrée
input_text = "Votre article à résumer ici..."
inputs = tokenizer(input_text, return_tensors="pt", max_length=512, truncation=True)

# Générer le résumé
outputs = model.generate(
    **inputs,
    max_length=150,
    num_beams=4,
    early_stopping=True,
    do_sample=False
)
summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(summary)

API REST (pour intégration mobile/web)

Une API REST Flask est disponible pour intégrer le modèle dans des applications mobiles ou web.

Lancement de l'API

python app.py

L'API sera disponible sur http://localhost:5000 et l'interface Gradio sur http://localhost:7860.

Endpoint de résumé

POST /summarize

Corps de la requête (JSON) :

{
  "text": "Votre texte à résumer ici...",
  "max_length": 150
}

Réponse (JSON) :

{
  "summary": "Résumé généré..."
}

Exemple d'utilisation avec curl :

curl -X POST http://localhost:5000/summarize \
  -H "Content-Type: application/json" \
  -d '{"text": "Le texte à résumer", "max_length": 100}'

Exemple en Python :

import requests

response = requests.post('http://localhost:5000/summarize', json={
    'text': 'Votre article complet...',
    'max_length': 150
})
summary = response.json()['summary']
print(summary)

Test de l'API

Utilisez le script test_api.py pour tester l'API :

python test_api.py

Avec ONNX Runtime (pour production/déploiement local)

import onnxruntime as ort
from transformers import AutoTokenizer
import numpy as np

# Charger le tokenizer
tokenizer = AutoTokenizer.from_pretrained("votre-username/t5-small-finetuned-summary")

# Charger le modèle ONNX
session = ort.InferenceSession("model.onnx")

# Fonction de génération autoregressive
def generate_summary(input_text, max_length=150):
    # Tokeniser l'entrée
    inputs = tokenizer(input_text, return_tensors="np", max_length=512, truncation=True)
    
    # Initialiser le decoder avec le token de padding
    decoder_input_ids = np.array([[tokenizer.pad_token_id]])
    
    for _ in range(max_length):
        # Forward pass ONNX
        outputs = session.run(None, {
            "input_ids": inputs["input_ids"],
            "attention_mask": inputs["attention_mask"],
            "decoder_input_ids": decoder_input_ids
        })
        logits = outputs[0]
        
        # Sélectionner le token suivant (greedy decoding)
        next_token = np.argmax(logits[:, -1, :], axis=-1)
        
        # Ajouter au decoder
        decoder_input_ids = np.append(decoder_input_ids, next_token.reshape(1, -1), axis=1)
        
        # Arrêter si EOS
        if next_token == tokenizer.eos_token_id:
            break
    
    # Décoder le résumé
    summary = tokenizer.decode(decoder_input_ids[0], skip_special_tokens=True)
    return summary

# Exemple d'utilisation
article = "Votre article complet ici..."
summary = generate_summary(article)
print(summary)

Installation des dépendances

pip install -r requirements.txt

Dépendances principales :

• onnxruntime
• transformers
• torch (pour tests avec Transformers)

Structure des fichiers

• model.onnx : Modèle ONNX quantifié INT8
• tokenizer/ : Fichiers du tokenizer T5
  • tokenizer.json
  • tokenizer_config.json
  • special_tokens_map.json
  • spiece.model
• config.json : Configuration du modèle
• generation_config.json : Configuration de génération
• requirements.txt : Dépendances Python
• docs/README.md : Cette documentation
• tests/ : Scripts de test

Méthodes utilisées

1. Téléchargement : Modèle et tokenizer récupérés depuis Hugging Face
2. Fine-tuning : Entraînement supervisé avec Seq2SeqTrainer
3. Export ONNX : Export logits-only via wrapper PyTorch
4. Quantification : INT8 avec ONNX Runtime pour optimisation CPU

Limitations

• Le modèle ONNX exporté est "logits-only", nécessitant une boucle de génération côté application
• Optimisé pour CPU ; pour GPU, utilisez la version PyTorch originale
• Testé principalement sur du français

Contribution

Pour des améliorations ou modifications (LoRA, export autoregressive complet, etc.), contactez l'auteur.

Modèle déployé sur Hugging Face pour faciliter l'accès et l'utilisation communautaire.