Whisper Transcription

Transcrivez l'audio et la vidéo avec OpenAI Whisper sur les GPU Clore.ai

Transcrivez des fichiers audio et vidéo à l'aide de Whisper d'OpenAI sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Exigences du serveur

Paramètre	Minimum	Recommandé
RAM	8 Go	16 Go+
VRAM	4 Go (petit)	10 Go+ (large-v3)
Réseau	200 Mbps	500 Mbps+
Temps de démarrage	~1-2 minutes	-

Qu'est-ce que Whisper ?

OpenAI Whisper est un modèle de reconnaissance vocale capable de :

• Transcrire l'audio dans 99 langues

• Traduire en anglais

• Générer des horodatages

• Gérer l'audio bruité

Tailles des modèles

Modèle	VRAM	Vitesse	Qualité	Remarques
tiny	1 Go	~32x en temps réel	Basique	Le plus rapide, précision la plus faible
base	1 Go	~16x en temps réel	Bon	Bon équilibre pour les tâches rapides
small	2 Go	~6x en temps réel	Meilleur	Recommandé pour la plupart des cas d'utilisation
medium	5 Go	~2x en temps réel	Excellent	Haute précision, vitesse modérée
large-v3	10GB	~1x en temps réel	Meilleur	Précision la plus élevée
large-v3-turbo	6 Go	~8x en temps réel	Meilleur	8x plus rapide que large-v3, qualité similaire

💡 Recommandation : Utilisez large-v3-turbo pour le meilleur compromis vitesse/qualité. Il offre une précision comparable à large-v3 à 8x la vitesse avec des besoins en VRAM plus faibles.

Utilisation de large-v3-turbo

import whisper

# Charger large-v3-turbo (8x plus rapide que large-v3, qualité similaire)
model = whisper.load_model("large-v3-turbo", device="cuda")

result = model.transcribe("audio.mp3")
print(result["text"])

Avec Faster-Whisper :

from faster_whisper import WhisperModel

# large-v3-turbo via faster-whisper
model = WhisperModel("deepdml/faster-whisper-large-v3-turbo-ct2", device="cuda", compute_type="float16")
segments, info = model.transcribe("audio.mp3")

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

---

WhisperX : alternative améliorée

Pour des horodatages au niveau des mots, la diarisation des locuteurs, et jusqu'à 70x plus rapide pour le traitement, envisagez WhisperX:

pip install whisperx

import whisperx

model = whisperx.load_model("large-v3-turbo", device="cuda", compute_type="float16")
audio = whisperx.load_audio("audio.mp3")
result = model.transcribe(audio, batch_size=16)

# Alignement au niveau des mots
model_a, metadata = whisperx.load_align_model(language_code=result["language"], device="cuda")
result = whisperx.align(result["segments"], model_a, metadata, audio, device="cuda")

# result["word_segments"] contient les horodatages au niveau des mots

➡️ Consultez le guide WhisperX complet pour la diarisation des locuteurs et les fonctionnalités avancées.

Déploiement rapide (recommandé)

Utilisez le serveur Faster-Whisper préconstruit pour un déploiement instantané :

Image Docker :

fedirz/faster-whisper-server:latest-cuda

Ports :

22/tcp
8000/http

Aucune commande requise - le serveur démarre automatiquement.

Vérifier que cela fonctionne

Après le déploiement, trouvez votre http_pub URL dans Mes commandes et testez :

curl https://your-http-pub.clorecloud.net/

# Attendu : réponse JSON d'informations sur le serveur

Si vous obtenez HTTP 502, attendez 1 à 2 minutes - le service est toujours en cours de démarrage.

Transcrire via l'API

# Transcrire un fichier audio
curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \
  -F "file=@audio.mp3" \
  -F "model=Systran/faster-whisper-large-v3" \
  -F "response_format=json"

# Avec horodatages
curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \
  -F "file=@audio.mp3" \
  -F "model=Systran/faster-whisper-large-v3" \
  -F "response_format=verbose_json" \
  -F "timestamp_granularities[]=word"

Référence API complète (Faster-Whisper-Server)

Points de terminaison

Point de terminaison	Méthode	Description
/v1/audio/transcriptions	POST	Transcrire l'audio (compatible OpenAI)
/v1/audio/translations	POST	Traduire l'audio en anglais
/v1/models	GET	Lister tous les modèles disponibles
/v1/models/{model_name}	GET	Obtenir les informations d'un modèle spécifique
/api/ps	GET	Lister les modèles actuellement chargés
/api/ps/{model_name}	GET	Vérifier si un modèle spécifique est chargé
/api/pull/{model_name}	POST	Télécharger et charger un modèle
/health	GET	Point de terminaison de vérification de l'état
/docs	GET	Documentation Swagger UI
/openapi.json	GET	Spécification OpenAPI

Lister les modèles disponibles

curl https://your-http-pub.clorecloud.net/v1/models

Réponse :

{
  "data": [
    {"id": "Systran/faster-whisper-large-v3", "object": "model"},
    {"id": "Systran/faster-whisper-medium", "object": "model"}
  ]
}

Documentation Swagger

Ouvrez dans le navigateur pour des tests API interactifs :

https://your-http-pub.clorecloud.net/docs

Options de transcription

Paramètre	Type	Description
file	Fichier	Fichier audio à transcrire
model	Chaîne	Modèle à utiliser (par défaut : Systran/faster-whisper-large-v3)
language	Chaîne	Forcer une langue spécifique (par ex., en, ja, ru)
response_format	Chaîne	json, text, srt, vtt, verbose_json
temperature	Flottant	Température d'échantillonnage (0.0-1.0)
timestamp_granularities[]	Tableau	word ou segment pour les horodatages

Formats de réponse

JSON (par défaut) :

{"text": "Texte transcrit ici..."}

JSON détaillé :

{
  "text": "Transcription complète...",
  "segments": [
    {"start": 0.0, "end": 2.5, "text": "Premier segment"},
    {"start": 2.5, "end": 5.0, "text": "Deuxième segment"}
  ],
  "language": "en"
}

SRT :

1
00:00:00,000 --> 00:00:02,500
Premier segment

2
00:00:02,500 --> 00:00:05,000
Deuxième segment

Alternative : installation manuelle

Si vous avez besoin de plus de contrôle, déployez avec une installation manuelle :

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Ports :

22/tcp

Commande :

pip install openai-whisper faster-whisper

L'installation manuelle prend 3 à 5 minutes. L'image préconstruite ci-dessus est recommandée pour un démarrage plus rapide.

Utilisation de base (SSH)

ssh -p <port> root@<proxy>

# Transcrire un fichier audio
whisper audio.mp3 --model large-v3 --device cuda

# Sortie vers un format spécifique
whisper audio.mp3 --model large-v3 --output_format txt

# Spécifier la langue
whisper audio.mp3 --model large-v3 --language Japanese

Transcrire avec horodatages

whisper audio.mp3 --model large-v3 --word_timestamps True

Téléverser des fichiers audio

# Téléverser un seul fichier
scp -P <port> interview.mp3 root@<proxy>:/workspace/

# Téléverser un dossier
scp -P <port> -r ./audio_files/ root@<proxy>:/workspace/

API Python

import whisper

# Charger le modèle (téléchargé lors de la première utilisation)
model = whisper.load_model("large-v3", device="cuda")

# Transcrire
result = model.transcribe("audio.mp3")

# Afficher le texte
print(result["text"])

# Afficher avec horodatages
for segment in result["segments"]:
    print(f"[{segment['start']:.2f}s -> {segment['end']:.2f}s] {segment['text']}")

Faster-Whisper (recommandé)

Faster-Whisper est 4x plus rapide avec une utilisation de la VRAM plus faible :

pip install faster-whisper

from faster_whisper import WhisperModel

# Charger le modèle avec des optimisations
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

# Transcrire
segments, info = model.transcribe("audio.mp3")

print(f"Langue détectée : {info.language}")
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Options de langue

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")

# Détection automatique de la langue
segments, info = model.transcribe("audio.mp3")
print(f"Langue : {info.language} ({info.language_probability:.0%})")

# Forcer une langue spécifique
segments, _ = model.transcribe("audio.mp3", language="ja")

Traduction en anglais

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")
segments, _ = model.transcribe("japanese.mp3", task="translate")

for segment in segments:
    print(segment.text)

CLI :

whisper japanese.mp3 --model large-v3 --task translate

Génération de sous-titres

Format SRT

from faster_whisper import WhisperModel

def format_timestamp(seconds):
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = int(seconds % 60)
    millis = int((seconds - int(seconds)) * 1000)
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"

model = WhisperModel("large-v3", device="cuda")
segments, _ = model.transcribe("video.mp4")

with open("subtitles.srt", "w") as f:
    for i, segment in enumerate(segments, 1):
        f.write(f"{i}\n")
        f.write(f"{format_timestamp(segment.start)} --> {format_timestamp(segment.end)}\n")
        f.write(f"{segment.text.strip()}\n\n")

Format VTT

whisper video.mp4 --model large-v3 --output_format vtt

Horodatages au niveau des mots

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")

segments, _ = model.transcribe("audio.mp3", word_timestamps=True)

for segment in segments:
    for word in segment.words:
        print(f"[{word.start:.2f}s] {word.word}")

Diarisation des locuteurs

Qui a dit quoi (nécessite pyannote) :

pip install pyannote.audio

from faster_whisper import WhisperModel
from pyannote.audio import Pipeline

# Diarisation
diarization = Pipeline.from_pretrained(
    "pyannote/speaker-diarization-3.1",
    use_auth_token="YOUR_HF_TOKEN"
)
diarization_result = diarization("audio.mp3")

# Transcription
whisper = WhisperModel("large-v3", device="cuda")
segments, _ = whisper.transcribe("audio.mp3")

# Combiner
for segment in segments:
    # Trouver le locuteur au moment du segment
    speaker = None
    for turn, _, spk in diarization_result.itertracks(yield_label=True):
        if turn.start <= segment.start <= turn.end:
            speaker = spk
            break
    print(f"[{speaker}] {segment.text}")

Serveur d'API REST

Créer une API de transcription :

from fastapi import FastAPI, UploadFile
from faster_whisper import WhisperModel
import tempfile

app = FastAPI()
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

@app.post("/transcribe")
async def transcribe(file: UploadFile):
    with tempfile.NamedTemporaryFile(delete=False) as tmp:
        tmp.write(await file.read())
        tmp_path = tmp.name

    segments, info = model.transcribe(tmp_path)

    return {
        "language": info.language,
        "text": " ".join([s.text for s in segments]),
        "segments": [
            {"start": s.start, "end": s.end, "text": s.text}
            for s in segments
        ]
    }

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000

Références de performance

Modèle	GPU	Audio d'1 h
large-v3	RTX 3090	~5 min
large-v3	RTX 4090	~3 min
large-v3	A100	~2 min
medium	RTX 3090	~2 min

Traitement économe en mémoire

Pour les audios très longs :

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="int8")

# Traiter par morceaux
segments, _ = model.transcribe(
    "long_audio.mp3",
    vad_filter=True,  # Ignorer les silences
    vad_parameters=dict(min_silence_duration_ms=500)
)

Télécharger les résultats

# Télécharger les transcriptions
scp -P <port> -r root@<proxy>:/workspace/transcripts/ ./

# Télécharger les sous-titres
scp -P <port> root@<proxy>:/workspace/subtitles.srt ./

Dépannage

Mémoire CUDA insuffisante

• Utiliser un modèle plus petit (medium au lieu de large)

• Utilisez compute_type="int8" pour faster-whisper

• Traiter des segments audio plus courts

HTTP 502 sur l'URL http_pub

Le service est toujours en cours de démarrage. Attendez 1 à 2 minutes et réessayez :

curl https://your-http-pub.clorecloud.net/

Précision faible

• Utiliser un modèle plus grand

• Spécifier la langue : --language English

• Augmenter beam_size pour faster-whisper

Traitement lent

• S'assurer que le GPU est utilisé : nvidia-smi

• Utiliser faster-whisper à la place de l'original

• Activer VAD pour ignorer les silences

Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

GPU	VRAM	Prix/jour	Idéal pour
RTX 3060	12 Go	$0.15–0.30	modèles petits/moyens
RTX 3090	24GB	$0.30–1.00	large-v3
RTX 4090	24GB	$0.50–2.00	large-v3, rapide
A100	40 Go	$1.50–3.00	traitement par lots

Prix en USD/jour. Les tarifs varient selon le fournisseur — vérifiez la place de marché CLORE.AI les tarifs actuels.