← Blog
Un enregistreur vocal lavande avec une grille crème et un bouton d’enregistrement orange.
Publié le
2026-11-17

Faster-whisper : transcrire sur CPU, puis évaluer un GPU

Faster-whisper exécute la reconnaissance vocale Whisper avec CTranslate2 et permet de transcrire un enregistrement sur un CPU ou un GPU compatible. Pour un nouveau traitement, commencez par vérifier la qualité du texte et le délai nécessaire pour terminer le travail. Le nom de la bibliothèque ne permet pas de choisir la machine adaptée à vos enregistrements.

Ce guide construit un petit traitement sur CPU qui enregistre le texte et les horodatages des segments dans un fichier JSON. Nous l'avons testé avec un enregistrement synthétique original en anglais, du silence, des fichiers invalides et des erreurs de sortie simulées. Cet exemple sert de point de départ pour évaluer vos propres fichiers, avec des limites précises sur ce que ses résultats démontrent.

Ce que fait faster-whisper

Faster-whisper est une autre implémentation de l'inférence Whisper, qui utilise CTranslate2. Le paquet fournit une API Python de transcription avec des options pour sélectionner la langue, utiliser la recherche en faisceau, obtenir des horodatages par mot et détecter l'activité vocale. Le décodage audio passe par PyAV, dont les paquets binaires incluent les bibliothèques FFmpeg. Notre exemple n'a pas nécessité l'installation séparée de l'outil FFmpeg en ligne de commande.

Les traitements regroupés sous le terme « transcription » n'ont pas tous les mêmes sorties. La recherche dans un enregistrement demande un texte lisible. Les sous-titres nécessitent des temps vérifiés et des sauts de ligne adaptés. Un compte rendu peut aussi demander l'identification des personnes qui parlent. Cet exemple produit du texte et des horodatages par segment, sans diarisation, alignement mot à mot, mise en forme des sous-titres ni traitement en direct.

Avant de choisir l'infrastructure, constituez un petit jeu d'évaluation : des enregistrements courts et longs, les langues utilisées, des passages calmes et bruyants, ainsi que des noms ou termes techniques représentatifs. Fixez un délai de traitement et identifiez les erreurs à corriger. Une phrase synthétique sans bruit ne remplace pas ce corpus.

Installer un environnement CPU testé

Notre test local utilisait Windows 11, Python 3.12.14, faster-whisper 1.2.1, CTranslate2 4.9.0, PyAV 18.1.0 et huggingface-hub 2.4.0. Il s'est exécuté sur un AMD Ryzen 7 7840HS avec quatre threads d'inférence et un seul worker de modèle. Aucun GPU n'a été utilisé. Le guide d'installation de CTranslate2 précise les plateformes prises en charge et la nécessité du runtime Visual C++ sous Windows.

Créez un environnement distinct. Ces commandes appellent directement son interpréteur Python, sans activation dans le terminal. Exécutez-les dans un nouveau dossier de travail :

python -m venv .venv
.venv/Scripts/python.exe -m pip install faster-whisper==1.2.1 ctranslate2==4.9.0 av==18.1.0 huggingface-hub==2.4.0

Sous Linux, remplacez .venv/Scripts/python.exe par .venv/bin/python dans les commandes ci-dessous. La validation présentée concerne l'environnement CPU Windows, pas un déploiement Linux ou cloud testé séparément.

La version de PyAV est importante dans cette combinaison. L'installation initiale avait sélectionné PyAV 19.0.2, et la transcription échouait avec open() got an unexpected keyword argument 'metadata_errors'. PyAV 19 a supprimé cet argument, que faster-whisper 1.2.1 transmet encore lors du décodage d'un fichier. Fixer PyAV à la version 18.1.0 a résolu l'erreur observée. Testez de nouveau l'ensemble lors des mises à jour : ces versions décrivent un exemple fonctionnel, pas une politique permanente.

Télécharger une révision précise du modèle

Nous utilisons la conversion CTranslate2 de Whisper tiny.en proposée par Systran. Ce modèle est réservé à l'anglais et permet de limiter la taille de ce premier test. Pour transcrire du français ou une autre langue, choisissez un modèle multilingue et validez cette langue séparément. Modifier uniquement language="en" ne rend pas un modèle anglais multilingue.

Enregistrez ce code dans get_model.py. Il télécharge les fichiers depuis un commit fixe plutôt que depuis une branche susceptible de changer. Hugging Face documente les téléchargements d'une révision précise. Cet exemple demande une connexion internet pour récupérer le modèle public, sans jeton de compte.

import os
from pathlib import Path

root = Path(__file__).resolve().parent
os.environ.setdefault("HF_HOME", str(root / ".hf-cache"))
os.environ["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = "1"

from huggingface_hub import snapshot_download

snapshot_download(
    "Systran/faster-whisper-tiny.en",
    revision="0d3d19a32d3338f10357c0889762bd8d64bbdeba",
    local_dir=root / "model",
    allow_patterns=["config.json", "model.bin", "tokenizer.json", "vocabulary.txt"],
    token=False,
)

Lancez le téléchargement une fois :

.venv/Scripts/python.exe get_model.py

Le script de transcription charge ensuite le dossier local. Conservez la révision et les versions des paquets avec les résultats. Le paramètre CPU int8 indique le type de calcul demandé ; il ne signifie pas que chaque opération utilise une arithmétique sur huit bits. CTranslate2 explique les types pris en charge et leurs conversions.

Transcrire le fichier et enregistrer un résultat complet

Enregistrez le code suivant dans transcribe.py. Placez dans le même dossier un court enregistrement en anglais que vous êtes autorisé à traiter, sous le nom sample.wav. Le dossier de sortie doit déjà exister. Utilisez un chemin de sortie distinct pour chaque traitement, sans désigner l'enregistrement ou un autre fichier à conserver comme destination.

import json
import os
import sys
import tempfile
from pathlib import Path
from time import perf_counter

from faster_whisper import WhisperModel


def transcribe_file(model, audio, output):
    start = perf_counter()
    segments, info = model.transcribe(
        str(audio), language="en", task="transcribe",
        beam_size=5, temperature=0, vad_filter=True,
        condition_on_previous_text=False,
    )
    # Iterating runs the transcription; do not stop the timer earlier.
    rows = [
        {"start": s.start, "end": s.end, "text": s.text.strip()}
        for s in segments
    ]
    result = {
        "language": info.language,
        "audio_seconds": info.duration,
        "transcription_seconds": perf_counter() - start,
        "text": " ".join(row["text"] for row in rows),
        "segments": rows,
        "timestamp_warnings": [
            i for i, row in enumerate(rows)
            if row["start"] < 0 or row["end"] > info.duration
        ],
    }
    output = Path(output)
    temp = None
    try:
        with tempfile.NamedTemporaryFile(
            mode="w", encoding="utf-8", dir=output.parent,
            prefix=output.name + ".", suffix=".tmp", delete=False,
        ) as f:
            temp = Path(f.name)
            json.dump(result, f, ensure_ascii=False, indent=2)
            f.flush()
            os.fsync(f.fileno())
        os.replace(temp, output)
    finally:
        if temp is not None:
            temp.unlink(missing_ok=True)
    return result


if __name__ == "__main__":
    model_dir, audio, output = sys.argv[1:]
    model = WhisperModel(
        model_dir, device="cpu", compute_type="int8",
        cpu_threads=4, num_workers=1, local_files_only=True,
    )
    result = transcribe_file(model, audio, output)
    print(result["text"])
.venv/Scripts/python.exe transcribe.py model sample.wav transcript.json

La mesure du temps dépend d'un point précis : il faut parcourir segments. Le retour de ce générateur ne signifie pas que la transcription est terminée. Le script le parcourt entièrement avant d'arrêter le chronomètre et d'enregistrer le résultat. Cette durée comprend le décodage audio et la détection d'activité vocale, mais exclut le chargement du modèle et l'écriture du JSON.

Le fichier contient le texte assemblé, les débuts et fins estimés des segments en secondes, ainsi que les indices, à partir de zéro, des segments dont les temps dépassent les limites de l'enregistrement. Le script écrit un fichier temporaire dans le dossier de destination, puis remplace le fichier de sortie après une sérialisation réussie. Un résultat antérieur reste intact si le décodage ou la génération des segments échoue auparavant.

Cet exemple traite un seul fichier à la fois. Il garde les segments en mémoire et ne coordonne pas plusieurs écritures simultanées. Pour un service plus complet, utilisez des identifiants de tâche uniques et un état de fin distinct. Un arrêt forcé peut laisser un fichier temporaire à supprimer. L'exemple ne démontre pas la récupération après une coupure de courant ni une transaction entre plusieurs machines.

Ce que le test CPU a montré

Nous avons généré localement un WAV mono à 16 kHz de 14,59 secondes, avec la voix synthétique Microsoft Zira Desktop et un texte original de 37 mots. Le script a retrouvé tous les mots après passage en minuscules et suppression de la ponctuation. Cette observation concerne uniquement cet extrait synthétique sans bruit, pas la précision sur des conversations réelles.

VérificationRésultat observé
Enregistrement vocalQuatre segments ; les 37 mots de référence correspondent après normalisation
Horodatage des segmentsLe dernier segment se termine à 15,00 secondes, soit 0,41 seconde après la fin du fichier ; le script le signale
Cinq secondes de silence avec détection vocaleAucun texte ni segment
Fichier invalide ou absentUne erreur, sans nouveau résultat complet ; le résultat antérieur reste intact
Interruption injectée après un segmentLe résultat complet antérieur reste intact
Échec injecté lors du remplacement de la destinationLe résultat antérieur reste intact et le fichier temporaire est supprimé

Lors de l'exécution enregistrée, le chargement du modèle a pris environ 0,25 seconde et la transcription 0,94 seconde. Du début du chargement à la sauvegarde du résultat, la durée était de 1,19 seconde. Le pic de mémoire résidente du processus atteignait environ 229 Mio, en incluant les imports, le chargement et la première transcription. Les chronomètres excluaient les imports des paquets et le téléchargement du modèle, dont les fichiers étaient déjà locaux. Ces valeurs décrivent une seule exécution sur la machine indiquée, sans comparaison de débit ni validation du dimensionnement d'une instance cloud.

Écoutez des passages représentatifs et vérifiez les noms, nombres, négations, omissions et répétitions. La fiche du modèle Whisper décrit notamment le risque de texte inventé et les différences de performance selon les langues et les locuteurs. La détection d'activité vocale aide à sélectionner les passages parlés, mais notre test de silence ne garantit pas que tous les fichiers silencieux ou bruyants produiront une sortie vide. Vérifiez aussi les temps estimés avant de créer des sous-titres.

Décider quand tester un GPU

Mesurez vos propres enregistrements avec le même modèle, la même langue, les mêmes paramètres de décodage et la même procédure de relecture avant de comparer le matériel. Relevez la durée audio, le temps entre le début du traitement et la sauvegarde, le pic de mémoire, les erreurs et le temps de correction du texte. Mesurez séparément le téléchargement, le premier chargement et les inférences répétées.

Pour un traitement différé, divisez le temps de traitement par la durée audio afin d'obtenir un facteur temps réel. Une valeur inférieure à un signifie que cette exécution a traité l'audio plus vite que sa lecture. Elle ne prouve pas qu'une file de longs enregistrements respectera son échéance. Incluez les transferts, le démarrage des workers, les nouvelles tentatives et les autres tâches dans l'estimation d'un lot.

Conservez le traitement CPU s'il répond aux exigences de qualité et de délai à un coût acceptable. Testez un GPU si la charge demande un modèle plus grand, davantage de tâches simultanées ou un délai plus court. Notre comparaison des CPU, GPU et NPU présente leurs rôles. Cet article ne fournit ni benchmark GPU ni procédure CUDA validée. Vérifiez la compatibilité des versions exactes de faster-whisper, CTranslate2, des pilotes et des bibliothèques choisies.

Exécuter le traitement avec Hivenet

Une fois les besoins en mémoire, le temps de traitement et le délai connus grâce à des fichiers représentatifs, évaluez Compute with Hivenet pour le worker CPU ou pour un essai GPU distinct. Vérifiez les ressources disponibles et le tarif actuel de l'instance, puis rejouez le même traitement sur celle-ci. Le résultat de notre ordinateur local ne démontre pas les performances d'une VM Hivenet.

Vous gérez le logiciel de transcription, les modèles, les mises à jour, les tâches et les contrôles d'accès. Ce traitement utilise des ressources de calcul louées ; il ne dépend ni de Hivenet Router ni d'un service Hivenet de transcription gérée.

Hivenet Object Storage peut être évalué pour conserver les fichiers audio et les transcriptions terminées. Téléchargez les entrées sur le stockage local du worker, terminez le traitement, puis envoyez le résultat complet. Définissez séparément les accès et la conservation des enregistrements et des textes. Exécuter un modèle localement détermine le lieu de l'inférence ; cela ne suffit pas à établir la confidentialité, la licéité du traitement ou la conformité réglementaire.

Commencez par un enregistrement représentatif et un délai cible. Conservez la configuration si le texte est utilisable, les échecs visibles et le coût du traitement complet acceptable. Augmentez ensuite la charge et mesurez de nouveau.

Votre prochaine charge de travail sur Hivenet.

Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.