🎙️ fongbe-asr-v1.1.0 — Reconnaissance Automatique de la Parole en Fon

Modèle Whisper fine-tuné pour la reconnaissance automatique de la parole (ASR) en langue Fon (Fongbe), parlée principalement au Bénin et au Togo.

---

🚀 Demo interactive

Testez le modèle directement sans aucune installation :

👉 Ouvrir la démo sur HuggingFace Spaces

---

🗂️ Informations du modèle

Attribut	Valeur
Architecture de base	Whisper Large
Tâche	Automatic Speech Recognition
Langue	Fon (fon)
Version	v1.1.0
Token de langue	<|fon|>
Format des poids	SafeTensors (model-001.safetensors)
Demo	asrDIL/fongbe-asr

---

🚀 Utilisation via l'API Inference

import requests

API_URL = "https://api-inference.huggingface.co/models/asrDIL/fongbe-asr-v1.1.0"
headers = {"Authorization": "Bearer hf_YOUR_TOKEN"}

with open("audio.mp3", "rb") as f:
    data = f.read()

response = requests.post(API_URL, headers=headers, data=data)
print(response.json())
# {"text": "...transcription en fon..."}

---

💻 Utilisation locale

Installation

pip install transformers torch librosa soundfile huggingface_hub safetensors

Code

import os
import torch
from transformers import WhisperProcessor, WhisperForConditionalGeneration, WhisperConfig, pipeline
from huggingface_hub import snapshot_download
from safetensors.torch import load_file

# 1. Téléchargement du repo complet
local_dir = snapshot_download(repo_id="asrDIL/fongbe-asr-v1.1.0")

# 2. Chargement du processeur
processor = WhisperProcessor.from_pretrained(local_dir)

# 3. Chargement du modèle
# Le fichier s'appelle 'model-001.safetensors', on charge les poids manuellement
config = WhisperConfig.from_pretrained(local_dir)
model = WhisperForConditionalGeneration(config)

state_dict = load_file(os.path.join(local_dir, "model-001.safetensors"))
model.load_state_dict(state_dict, strict=False)  # strict=False car proj_out.weight est partagé

device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)
model.eval()
torch_dtype = torch.bfloat16 if device == "cuda" and torch.cuda.is_bf16_supported() else torch.float32

# 4. Injection des tokens Fon dans generation_config
# Note : 'fon' est un token custom ajouté au fine-tuning, absent du Whisper de base
fon_token_id          = processor.tokenizer.convert_tokens_to_ids("<|fon|>")
transcribe_token_id   = processor.tokenizer.convert_tokens_to_ids("<|transcribe|>")
notimestamps_token_id = processor.tokenizer.convert_tokens_to_ids("<|notimestamps|>")

model.generation_config.forced_decoder_ids = [
    [1, fon_token_id],
    [2, transcribe_token_id],
    [3, notimestamps_token_id],
]
model.generation_config.suppress_tokens      = []
model.generation_config.no_repeat_ngram_size = 3

# 5. Pipeline ASR
asr_pipeline = pipeline(
    "automatic-speech-recognition",
    model=model,
    tokenizer=processor.tokenizer,
    feature_extractor=processor.feature_extractor,
    device=device,
    torch_dtype=torch_dtype
)

# 6. Transcription
result = asr_pipeline(
    "audio.mp3",
    chunk_length_s=30,
    stride_length_s=5,
    return_timestamps=False,
    generate_kwargs={"num_beams": 1},
)

print(result["text"])

Pourquoi ce chargement particulier ?
Le fichier de poids est nommé model-001.safetensors (et non model.safetensors), ce qui empêche le chargement automatique via from_pretrained. Les poids sont donc chargés manuellement avec safetensors.
De plus, fon n'étant pas une langue native de Whisper, les tokens de langue sont injectés directement dans model.generation_config plutôt que via generate_kwargs (déprécié en transformers >= 4.36).

📊 Benchmark — whisper-large-v3 vs fongbe-asr-v1.1.0

Comparaison des performances sur le jeu de données de test Fon :

Métrique	Whisper large-v3 (original)	fongbe-asr-v1.1.0 (fine-tuné)	Évolution
WER ↓	1.1160	1.2098	-8.4% ❌
CER ↓	0.7041	0.6769	+3.9% ✅
Score combiné ↓	0.9101	0.9433	-3.6% ❌

Score combiné = 0.5 × WER + 0.5 × CER

Analyse

CER (Character Error Rate) — Le fine-tuning apporte une amélioration de +3.9% au niveau des caractères. Pour une langue tonale comme le Fon, où les diacritiques et petites variations de caractères changent la signification des mots, c'est un résultat fondamental et encourageant.

WER (Word Error Rate) — Le modèle fine-tuné présente un WER légèrement plus élevé (-8.4%). Malgré une meilleure reconnaissance des caractères, le modèle a encore des difficultés à assembler ces caractères en mots corrects ou à délimiter les mots de manière appropriée.

Score combiné — La légère dégradation globale (-3.6%) s'explique par l'augmentation du WER qui compense les gains sur le CER.

Vers la v1.2.0

L'amélioration du CER est un premier pas important. Les pistes d'amélioration prioritaires pour la prochaine version :

• Ajuster les hyperparamètres : taux d'apprentissage, warmup steps et weight decay pour mieux équilibrer la reconnaissance des caractères et des mots.
• Objectif : améliorer le WER sans sacrifier les gains obtenus sur le CER.

---

⚙️ Paramètres d'inférence recommandés

Paramètre	Valeur	Description
chunk_length_s	30	Durée des segments traités (secondes)
stride_length_s	5	Chevauchement entre segments
num_beams	1	Recherche gloutonne (rapide)
no_repeat_ngram_size	3	Évite les répétitions
return_timestamps	False	Sans horodatages

---

📌 Notes importantes

• Le fichier de poids est nommé model-001.safetensors — charger manuellement avec safetensors (voir code ci-dessus).
• fon est un token de langue custom ajouté au fine-tuning, absent du Whisper de base.
• Les tokens de langue sont injectés via model.generation_config pour compatibilité avec transformers >= 4.36.
• Pour de meilleures performances, utiliser un GPU avec support bfloat16.

---

📜 Licence

Ce modèle est distribué sous licence Apache 2.0.

---

🙏 Citation

@misc{fongbe-asr-v1.1.0,
  author    = {asrDIL},
  title     = {fongbe-asr-v1.1.0: Whisper fine-tuné pour la langue Fon},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/asrDIL/fongbe-asr-v1.1.0}
}