Whisper et Piper auto-hébergés sur un VPS

Synthèse vocale et conversion parole-texte auto-hébergées, en bref

La conversion parole-texte et la synthèse vocale auto-hébergées (TTS, text to speech) sont les formes d’IA les moins coûteuses que vous pouvez exécuter sur un serveur qui vous appartient. La transcription utilise Whisper via le runtime faster-whisper. La synthèse utilise Piper. Les deux fonctionnent sur un VPS avec un CPU standard, sans GPU. Le petit modèle Whisper nécessite environ 484 Mo d’espace disque, et une voix Piper tient dans un seul fichier de moins de 150 Mo.

C’est pourquoi l’audio est le meilleur point de départ. Un générateur d’images auto-hébergé et la génération vidéo auto-hébergée nécessitent tous deux un GPU avant d’être réellement utilisables. L’audio n’en nécessite pas.

Ce guide couvre les deux directions ainsi que la couche qui les relie. Whisper convertit l’audio en texte. Piper convertit le texte en audio. Un serveur HTTP compatible avec l’API OpenAI placé devant les deux permet à un client existant de pointer vers votre serveur. Seule l’URL de base doit être modifiée.

Toutes les versions mentionnées ici étaient à jour en août 2026.

Pourquoi faster-whisper plutôt que le package Whisper de référence

Le package whisper d’OpenAI exécute le modèle avec PyTorch. faster-whisper exécute les mêmes poids de modèle avec CTranslate2, un moteur d’inférence conçu spécifiquement pour les modèles de type transformer. Les poids sont identiques, donc la transcription est identique. La différence vient entièrement du runtime.

CTranslate2 quantifie les poids lors de leur chargement. C’est pourquoi compute_type="int8" est un seul argument et non une étape de conversion distincte. CTranslate2 n’a pas non plus de dépendance à PyTorch. pip install faster-whisper installe CTranslate2, un tokenizer et PyAV pour le décodage audio. L’environnement virtuel occupe donc quelques centaines de mégaoctets au lieu de plusieurs gigaoctets. Sur un VPS avec un disque de 40 GB, cette différence sépare une installation confortable d’une installation à l’étroit.

Voici les chiffres publiés par le projet pour le modèle small sur CPU. Le benchmark transcrit 13 minutes d’audio avec 8 threads sur un Intel Core i7-12700K. La colonne x_realtime correspond à ces 13 minutes divisées par le temps mesuré : 7.6 signifie qu’un enregistrement de 13 minutes est terminé en un peu plus de 1 minute 40.

[
  {
    "label": "openai/whisper, fp32",
    "x_realtime": 1.9,
    "seconds": 418,
    "memory_mb": "2,335"
  },
  {
    "label": "whisper.cpp, fp32",
    "x_realtime": 6.2,
    "seconds": 125,
    "memory_mb": "1,049"
  },
  {
    "label": "faster-whisper, fp32",
    "x_realtime": 5.0,
    "seconds": 157,
    "memory_mb": "2,257"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 7.6,
    "seconds": 102,
    "memory_mb": "1,477"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 15.3,
    "seconds": 51,
    "memory_mb": "3,608"
  }
]

Lisez honnêtement la deuxième ligne. En fp32, whisper.cpp est plus rapide que faster-whisper sur ce CPU : 6.2x contre 5.0x, et il utilise moins de la moitié de la mémoire. Il s’agit de la même famille ggml que celle utilisée par la partie llama.cpp de la stack LLM locale. faster-whisper prend l’avantage avec int8 et le batching activés, et atteint 15.3x. Il utilise alors 3,608 MB de RAM. En pratique, choisissez faster-whisper pour l’API Python et le batching. Choisissez whisper.cpp lorsque la RAM est la contrainte que vous ne pouvez pas augmenter.

La première ligne est le point essentiel de cette section. Le package de référence atteint 1.9x du temps réel sur la même machine. Une heure d’audio nécessite donc une demi-heure de calcul CPU.

Quelle est la place disque nécessaire pour les poids du modèle Whisper ?

[
  {
    "label": "tiny",
    "weights_mb": 75.5
  },
  {
    "label": "base",
    "weights_mb": 145
  },
  {
    "label": "small",
    "weights_mb": 484
  },
  {
    "label": "medium",
    "weights_mb": "1,530"
  },
  {
    "label": "large-v3",
    "weights_mb": "3,090"
  }
]

Voici les conversions CTranslate2 publiées, en float16. Notez ce que compute_type="int8" ne fait pas : il ne réduit pas la taille du téléchargement. Les poids sont téléchargés en float16, puis CTranslate2 les quantifie en mémoire au chargement. Le modèle large-v3 occupe donc 3,090 Mo sur le disque, que vous l’exécutiez en float16 ou en int8. int8 réduit l’utilisation de la RAM et accélère l’exécution, mais ne réduit pas l’espace disque nécessaire.

Les modèles sont téléchargés lors de leur première utilisation dans ~/.cache/huggingface/hub. Sur un VPS disposant d’un petit volume racine, indiquez plutôt un emplacement ayant suffisamment d’espace avec l’argument download_root ou la variable d’environnement HF_HOME. Sinon, la première exécution peut remplir le disque et le processus s’arrêter au milieu du téléchargement.

Installer faster-whisper sans casser le Python système

Ubuntu 24.04 et Debian 13 considèrent le Python système comme géré par la distribution. L’exécution de pip install faster-whisper en dehors d’un environnement virtuel s’arrête immédiatement avec le message suivant :

error: externally-managed-environment

Le système de paquets protège ainsi les fichiers appartenant à apt. Utilisez un environnement virtuel.

sudo apt update
sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/stt
~/stt/bin/pip install --upgrade pip
~/stt/bin/pip install faster-whisper==1.2.1

La version 1.2.1 est la version actuelle, publiée en octobre 2025. faster-whisper décode les fichiers audio avec PyAV, qui intègre ses propres bibliothèques ffmpeg. Il peut donc lire un fichier mp3 ou m4a sans binaire ffmpeg séparé. Le paquet ffmpeg ci-dessus servira pour le traitement vidéo plus loin dans ce guide.

Vérifiez l’installation avant de télécharger trois gigaoctets de modèles :

~/stt/bin/python -c "from faster_whisper import WhisperModel; print('ok')"

Une ligne contenant ok indique que les wheels ont bien été installées. Un ImportError contenant ctranslate2 indique que la wheel correspondant à votre architecture n’a pas été installée. Cela se produit avec les images ARM 32 bits.

Transcrire un enregistrement de réunion ou une note vocale

Enregistrez ceci dans transcribe.py :

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("meeting.m4a", beam_size=5, vad_filter=True)

print("language: %s (%.2f)" % (info.language, info.language_probability))
for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

Exécutez-le avec ~/stt/bin/python transcribe.py. La première exécution télécharge les poids du modèle, donc rien ne s’affiche pendant un moment. Ensuite, le modèle est chargé depuis le cache en quelques secondes.

segments est un générateur : la transcription ne démarre donc qu’au moment où vous l’itérez. Certains mesurent la durée de l’appel à transcribe(), le voient se terminer instantanément et pensent qu’un problème s’est produit. Ce n’est pas le cas. Le traitement s’effectue dans la boucle.

vad_filter=True exécute d’abord Silero VAD (voice activity detection), puis supprime les passages silencieux avant leur traitement par Whisper. Sur un enregistrement de réunion comportant de longues pauses, c’est le gain de vitesse le plus important, car Whisper ne consacre aucun temps aux segments audio qui ne contiennent pas de parole. Cela évite également les boucles de répétition de phrases que Whisper produit lorsqu’il reçoit du silence et tente d’y trouver des mots.

Définissez cpu_threads sur le nombre de cœurs réellement disponibles. Une valeur supérieure au nombre de vCPU ralentit la transcription, car les threads supplémentaires se disputent le même cœur et le scheduler doit gérer chaque changement de contexte.

Sous-titres pour une bibliothèque Jellyfin

Jellyfin lit les fichiers de sous-titres externes placés à côté de la vidéo et portant le même nom. Ainsi, Movie (2019).en.srt placé à côté de Movie (2019).mkv apparaît comme une piste en anglais, sans transcodage ni reconstruction de la bibliothèque.

Extrayez d’abord l’audio. Whisper rééchantillonne tout en interne à 16 kHz mono. Lui fournir directement du 16 kHz mono évite donc du travail aux deux extrémités :

ffmpeg -i "Movie (2019).mkv" -vn -ac 1 -ar 16000 -c:a pcm_s16le "Movie (2019).wav"

faster-whisper ne possède pas de générateur SRT. Formatez donc vous-même les segments. Enregistrez ce script sous srt.py :

import sys
from faster_whisper import WhisperModel

def ts(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3600000)
    minutes, ms = divmod(ms, 60000)
    secs, ms = divmod(ms, 1000)
    return "%02d:%02d:%02d,%03d" % (hours, minutes, secs, ms)

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], vad_filter=True)

with open(sys.argv[2], "w", encoding="utf-8") as out:
    for index, segment in enumerate(segments, start=1):
        out.write("%d\n" % index)
        out.write("%s --> %s\n" % (ts(segment.start), ts(segment.end)))
        out.write("%s\n\n" % segment.text.strip())

Parcourez ensuite la bibliothèque :

for f in /srv/media/films/*.mkv; do
  ffmpeg -nostdin -y -i "$f" -vn -ac 1 -ar 16000 -c:a pcm_s16le "${f%.mkv}.wav"
  nice -n 15 ~/stt/bin/python srt.py "${f%.mkv}.wav" "${f%.mkv}.en.srt"
  rm -f "${f%.mkv}.wav"
done

-nostdin n’est pas décoratif. Sans cette option, ffmpeg lit l’entrée standard de la boucle, consomme le reste de la liste de fichiers et la boucle s’arrête après un seul film, sans afficher de message d’erreur.

Évaluez la durée nécessaire avant de commencer. Avec le facteur de 7.6x indiqué plus haut, un film de 100 minutes nécessite environ 13 minutes de calcul CPU. Une bibliothèque de cinquante films demande donc une exécution pendant la nuit. Sur une offre avec vCPU partagé, le traitement est encore plus lent. C’est précisément le rôle de nice : la génération des sous-titres cède alors la priorité aux autres tâches réellement exécutées par le serveur.

Synthèse vocale avec Piper

Piper est un moteur de synthèse vocale neuronale qui exécute un modèle vocal ONNX sur le CPU. Il intègre espeak-ng pour convertir le texte en phonèmes. Aucun phonémiseur distinct n’est donc nécessaire. La version actuelle est 1.6.0, publiée en juillet 2026.

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.6.0
~/tts/bin/python -m piper.download_voices en_US-lessac-medium
~/tts/bin/python -m piper -m en_US-lessac-medium -f test.wav -- 'This is a test.'

download_voices écrit deux fichiers dans le répertoire de travail : les poids .onnx et une configuration .onnx.json contenant la fréquence d’échantillonnage et la liste des locuteurs. Ces fichiers doivent rester ensemble. Si vous conservez les voix dans un emplacement fixe, transmettez --data-dir aux deux commandes. Sinon, le lecteur recherche la voix dans le répertoire de travail et ne peut pas trouver une voix qui ne s’y trouve pas.

Le -- placé avant le texte est également important. Sans lui, toute phrase commençant par un trait d’union est interprétée comme une option de ligne de commande.

Les voix sont disponibles avec plusieurs niveaux de qualité. Une voix anglaise de qualité moyenne occupe environ 60 MB. Une voix de haute qualité occupe environ le double. Une meilleure qualité implique un modèle plus volumineux et une consommation CPU plus élevée par seconde de parole, mais pas un locuteur différent.

N’appelez pas la CLI dans une boucle. Le modèle est chargé à chaque invocation, et ce chargement représente l’essentiel du coût pour une phrase courte. Exécutez plutôt le serveur HTTP :

~/tts/bin/pip install 'piper-tts[http]==1.6.0'
~/tts/bin/python -m piper.http_server -m en_US-lessac-medium --host 127.0.0.1 --port 5000

curl -X POST -H 'Content-Type: application/json' \
  -d '{ "text": "This is a test." }' \
  -o test.wav localhost:5000/synthesize

Si vous pouvez lire un test.wav, cela confirme que le service fonctionne. Cet endpoint utilise le format propre à Piper, et non celui d’OpenAI. Un client qui attend /v1/audio/speech ne pourra donc pas communiquer avec lui. La section suivante corrige ce point.

Maintenez le service actif avec un unit file plutôt qu’avec un terminal que vous allez fermer :

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper le démarre et le relance après un redémarrage. Si la commande curl ci-dessus ne renvoie rien, journalctl -u piper -n 50 contient la cause. L’absence du fichier de voix est la cause la plus fréquente.

La structure d’un serveur compatible avec l’API OpenAI

La plupart des logiciels qui traitent l’audio utilisent déjà l’API audio d’OpenAI : une requête POST multipart vers /v1/audio/transcriptions pour un fichier, une requête POST JSON vers /v1/audio/speech pour une phrase. Servez vous-même ces deux chemins. Le client ne nécessite alors qu’une seule modification : son URL de base.

Speaches est un serveur qui gère les deux directions. Il utilise faster-whisper pour la transcription et Piper ou Kokoro pour la synthèse vocale, derrière les chemins OpenAI. La version actuelle est v0.9.0-rc.3, publiée en décembre 2025. Le projet n’a pas encore atteint la version 1.0. Épinglez donc le tag de votre image et lisez les notes de version avant toute mise à niveau.

curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.yaml
curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.cpu.yaml
export COMPOSE_FILE=compose.cpu.yaml
docker compose up --detach

Voici la forme avec un conteneur unique, si vous préférez ne pas conserver de fichiers compose :

docker run --rm --detach --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

Le volume nommé est l’élément que l’on oublie le plus souvent. Sans lui, le cache des modèles reste dans le conteneur. Chaque redémarrage retélécharge donc plusieurs gigaoctets de poids avant que la première requête obtienne une réponse.

La synthèse vocale nécessite de télécharger une voix avant que /v1/audio/speech réponde :

uvx speaches-cli model download speaches-ai/Kokoro-82M-v1.0-ONNX

Ensuite, n’importe quel client OpenAI fonctionne en modifiant l’URL de base :

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

L’espace réservé api_key est obligatoire, car la bibliothèque cliente OpenAI refuse d’envoyer une requête sans cette valeur. Le serveur ignore sa valeur tant que vous n’avez pas configuré une véritable clé.

vox-box est l’autre projet qui mérite d’être cité ici. Il s’agit d’un paquet Python et non d’un conteneur. Il expose les mêmes chemins avec Whisper, FunASR, Bark, Dia ou CosyVoice. La version actuelle est 0.0.21, publiée en décembre 2025. Elle nécessite Python 3.10 ou une version ultérieure.

python3 -m venv ~/voice
~/voice/bin/pip install vox-box==0.0.21
~/voice/bin/vox-box start --huggingface-repo-id Systran/faster-whisper-small \
  --data-dir ~/voice/data --host 127.0.0.1 --port 8010

L’exemple fourni par le projet utilise le port 80, ce qui nécessite root. Sur un serveur qui exécute d’autres services, il vaut mieux utiliser un port élevé derrière un reverse proxy. vox-box start ne prend qu’un seul modèle. Pour gérer les deux directions, il faut donc une seconde instance sur un autre port, avec un repo id de modèle vocal.

Demandez au serveur quels modèles il a chargés, puis utilisez cet id dans le champ model :

curl http://127.0.0.1:8010/v1/models

curl http://127.0.0.1:8010/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@voice-note.m4a" \
  -F model="faster-whisper-small"

Un corps JSON de la forme {"text": "..."} indique que tout le chemin fonctionne. Une erreur 404 sur le nom du modèle signifie que vous l’avez deviné au lieu de lire la sortie de /v1/models.

Aucun de ces serveurs n’active l’authentification par défaut. Liez-les à 127.0.0.1 et utilisez-les via un VPN ou un reverse proxy qui demande des identifiants. Un /v1/audio/transcriptions ouvert sur une IP publique fournit du CPU gratuitement à quiconque le découvre, et il sera découvert.

Une interface vocale pour un assistant auto-hébergé

Une fois que les deux directions répondent via des chemins OpenAI, une interface de chat peut les piloter. Open WebUI et ses alternatives acceptent une URL de base compatible avec OpenAI pour l’audio dans leurs paramètres. Un seul serveur peut donc exécuter un LLM local avec Ollama et fermer la boucle vocale aux deux extrémités.

Évaluez honnêtement la latence, car ces trois étapes s’exécutent l’une après l’autre sur les mêmes cœurs. Une question de 10 secondes demande environ 1.3 seconde pour être transcrite avec le facteur de 7.6x indiqué plus haut. Le modèle n’a alors pas encore lu un seul token. Ajoutez la génération des tokens par le CPU, et l’aller-retour devient suffisamment lent pour que les testeurs pensent que le service a planté. La transcription par lots reste confortable sur CPU. Une conversation ne l’est pas. C’est à ce stade qu’un VPS avec un GPU commence à justifier son prix.

Quand le GPU est-il réellement utile ?

[
  {
    "label": "openai/whisper, fp16",
    "x_realtime": 5.5,
    "seconds": 143,
    "memory_mb": "4,708"
  },
  {
    "label": "faster-whisper, fp16",
    "x_realtime": 12.4,
    "seconds": 63,
    "memory_mb": "4,525"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 13.2,
    "seconds": 59,
    "memory_mb": "2,926"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 48.8,
    "seconds": 16,
    "memory_mb": "4,500"
  }
]

Sur le GPU, le grand modèle en int8 s’exécute à 13.2x du temps réel dans 2,926 Mo de VRAM, et le traitement par lots atteint 48.8x. Notez bien ce que les deux graphiques ne disent pas. Ils utilisent des modèles différents : les lignes GPU correspondent à large-v2, tandis que les lignes CPU correspondent à small. Un GPU ne rend pas le modèle small six fois plus rapide. Il rend le modèle précis utilisable.

Un plan vCPU partagé n’atteindra pas les performances indiquées pour le CPU. Ce benchmark disposait à lui seul de 8 threads d’un processeur de bureau rapide. Considérez 7.6x comme une limite supérieure, puis mesurez votre propre machine avec time sur un enregistrement réel avant de baser votre projet dessus.

Quatre règles générales se vérifient en pratique :

• Transcription occasionnelle de vos propres enregistrements : CPU, small, int8. Deux vCPU dédiés suffisent.
• Traitement par lots pendant la nuit, par exemple pour générer des sous-titres : CPU, small ou medium, int8, exécuté avec nice.
• Utilisation interactive ou traitement de toute une bibliothèque en une soirée : GPU.
• Piper : CPU, toujours. Un modèle vocal de cette taille tire presque aucun bénéfice d’un GPU.

Si vous évaluez les autres charges que le même matériel pourrait prendre en charge, la question plus générale des modèles d’IA que vous pouvez auto-héberger présente les tailles qui tiennent ou non sur la machine.

Modes d’échec et messages affichés

error: externally-managed-environment lors de l’installation. Python système est protégé par la distribution. Créez un environnement virtuel comme indiqué plus haut.

Incompatibilité cuDNN sur une machine équipée d’un GPU. L’échec se présente ainsi :

Unable to load any of {libcudnn_ops.so.9.1.0, libcudnn_ops.so.9.1, libcudnn_ops.so.9, libcudnn_ops.so}
Invalid handle. Cannot load symbol cudnnCreateTensorDescriptor

CTranslate2 4.5.0 et les versions ultérieures nécessitent cuDNN 9 avec CUDA 12, mais l’hôte utilise cuDNN 8. Installez cuDNN 9 ou verrouillez l’ancienne version du runtime avec pip install --force-reinstall ctranslate2==4.4.0. Faites l’un ou l’autre. Faire les deux vous ramène au point de départ.

This CTranslate2 package was not compiled with CUDA support correspond à un autre problème, aux symptômes similaires. Le wheel installé est la version uniquement CPU. Recréez l’environnement virtuel sur l’hôte GPU et laissez pip sélectionner à nouveau le wheel.

Phrases répétées dans la transcription. Une phrase répétée dix fois provient presque toujours d’un silence ou d’une musique interprétés comme de la parole. Activez d’abord vad_filter=True. Si le problème persiste, écoutez le segment : un signal audio presque silencieux ne fournit aucun point d’ancrage à Whisper, qui répète alors sa dernière hypothèse fiable.

Langue incorrectement détectée. Whisper effectue sa détection uniquement sur les 30 premières secondes. Un info.language_probability nettement inférieur à 1.0 indique qu’il n’était pas sûr de lui. Cela arrive lorsqu’un enregistrement commence par de la musique ou des voix superposées. Utilisez language="en" lorsque vous connaissez déjà la réponse.

Le processus affiche Killed et s’arrête. Il s’agit du tueur de processus out-of-memory du kernel. dmesg affiche la ligne oom-kill correspondante. large-v3 nécessite plus de 3 GB uniquement pour ses poids, avant même de réserver la mémoire de travail. Sur un VPS de 2 GB, small en int8 est le plus grand modèle compatible.

Piper ne trouve pas la voix. Le lecteur recherche dans le répertoire de travail, sauf si vous indiquez --data-dir. Exécutez ls sur le répertoire attendu et vérifiez que .onnx et .onnx.json sont tous les deux présents. La présence d’un seul des deux ne suffit pas.

FAQ

Puis-je exécuter la conversion de la parole en texte sur un VPS sans GPU ?

Oui. Pour le traitement par lots, c’est le choix le plus raisonnable. Avec faster-whisper et le modèle small en int8, le benchmark publié par le projet transcrit 13 minutes d’audio en 102 secondes sur 8 threads d’un i7 de bureau, soit environ 7.6x le temps réel, avec 1,477 MB de RAM. Une offre avec vCPU partagé est plus lente, vous devez donc mesurer les performances sur votre propre serveur. La synthèse vocale avec Piper est encore plus simple et ne nécessite jamais de GPU.

Quelle taille de modèle Whisper dois-je utiliser ?

Commencez avec small en int8. Il occupe 484 MB sur le disque et traite correctement les enregistrements vocaux clairs. Passez à medium lorsque les accents ou le bruit de fond provoquent des erreurs inacceptables. Utilisez large-v3 uniquement lorsque la précision est plus importante que tout le reste, car il nécessite 3,090 MB d’espace disque et plus de 3 GB de mémoire. À l’inverse, tiny, avec ses 75.5 MB, convient à la détection de la langue et aux tests d’un pipeline, mais pas aux transcriptions destinées à être lues par une personne.

Pourquoi faster-whisper est-il plus rapide que le package Whisper d’origine ?

Le modèle est identique. Le runtime ne l’est pas. Le package de référence exécute Whisper dans PyTorch, tandis que faster-whisper utilise les mêmes poids avec CTranslate2, un moteur conçu pour l’inférence de transformers. Ce moteur quantifie les poids lors du chargement et ne nécessite aucune installation de PyTorch. Dans le benchmark CPU publié, le package de référence atteint 1.9x le temps réel, contre 7.6x pour faster-whisper en int8, avec une consommation mémoire inférieure.

Pourquoi ma transcription répète-t-elle la même phrase en boucle ?

Whisper interprète le silence ou la musique comme de la parole et reprend sa dernière hypothèse fiable. Définissez vad_filter=True dans l’appel transcribe(). Celui-ci exécute d’abord la détection d’activité vocale de Silero et supprime les passages silencieux avant leur traitement par le modèle. Si les répétitions persistent, vérifiez le niveau audio. Un enregistrement presque entièrement silencieux ne fournit pas suffisamment d’informations au modèle.

Comment obtenir un endpoint audio compatible avec OpenAI sur mon propre serveur ?

Exécutez un serveur qui implémente POST /v1/audio/transcriptions et POST /v1/audio/speech, puis configurez le client pour l’utiliser avec une nouvelle URL de base. Speaches est une possibilité. Il est publié sous forme d’image de conteneur avec un build CPU, et utilise faster-whisper pour la transcription ainsi que Piper ou Kokoro pour la synthèse vocale. vox-box en est une autre. Installez-le avec pip install vox-box, puis démarrez-le avec vox-box start --huggingface-repo-id. Il sert un modèle par processus. Aucun des deux n’active l’authentification par défaut. Faites-les donc écouter sur localhost et placez un proxy ou un VPN devant le service.