> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/whisper-transcription.md).

# Transcription Whisper

Transcrire des fichiers audio et vidéo en utilisant Whisper d'OpenAI sur les GPU CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

| Paramètre          | Minimum       | Recommandé       |
| ------------------ | ------------- | ---------------- |
| RAM                | 8 Go          | 16 Go+           |
| VRAM               | 4Go (petit)   | 10Go+ (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 qui peut :

* Transcrire l'audio en 99 langues
* Traduire vers l'anglais
* Générer des horodatages
* Gérer l'audio bruyant

## Tailles de modèles

| Modèle             | VRAM     | Vitesse                | Qualité      | Remarques                                          |
| ------------------ | -------- | ---------------------- | ------------ | -------------------------------------------------- |
| tiny               | 1Go      | \~32x en temps réel    | Basique      | Le plus rapide, précision la plus faible           |
| base               | 1Go      | \~16x en temps réel    | Bon          | Bon équilibre pour les tâches rapides              |
| small              | 2Go      | \~6x en temps réel     | Meilleur     | Recommandé pour la plupart des cas d'utilisation   |
| medium             | 5Go      | \~2x en temps réel     | Excellent    | Haute précision, vitesse modérée                   |
| large-v3           | 10Go     | \~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 exigences VRAM plus faibles.

### Utiliser large-v3-turbo

```python
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 :

```python
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 **horodatages au niveau des mots**, **diarisation des locuteurs**, et **jusqu'à 70x plus rapide** de traitement, envisagez [WhisperX](/guides/guides_v2-fr/audio-et-voix/whisperx.md):

```bash
pip install whisperx
```

```python
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
```

➡️ Voir le guide complet [WhisperX guide](/guides/guides_v2-fr/audio-et-voix/whisperx.md) 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 nécessaire** - le serveur démarre automatiquement.

### Vérifiez que cela fonctionne

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

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

# Attendu : réponse JSON d'information du serveur
```

{% hint style="warning" %}
Si vous obtenez HTTP 502, attendez 1-2 minutes - le service est encore en cours de démarrage.
{% endhint %}

### Transcrire via l'API

```bash
# 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 complète de l'API (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 vers l'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 santé   |
| `/docs`                    | GET     | Documentation Swagger UI                        |
| `/openapi.json`            | GET     | Spécification OpenAPI                           |

#### Lister les modèles disponibles

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

Réponse :

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

#### Documentation Swagger

Ouvrir dans le navigateur pour tester l'API de manière interactive :

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

### Options de transcription

| Paramètre                   | Type    | Description                                                        |
| --------------------------- | ------- | ------------------------------------------------------------------ |
| `fichier`                   | Fichier | Fichier audio à transcrire                                         |
| `modèle`                    | Chaîne  | Modèle à utiliser (par défaut : `Systran/faster-whisper-large-v3`) |
| `langue`                    | Chaîne  | Forcer une langue spécifique (par ex., `en`, `ja`, `ru`)           |
| `response_format`           | Chaîne  | `json`, `texte`, `srt`, `vtt`, `verbose_json`                      |
| `température`               | Float   | 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) :**

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

**JSON détaillé :**

```json
{
  "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.5.1-cuda12.4-cudnn9-runtime
```

**Ports :**

```
22/tcp
```

**Commande :**

```bash
pip install openai-whisper faster-whisper
```

{% hint style="info" %}
L'installation manuelle prend 3-5 minutes. L'image préconstruite ci-dessus est recommandée pour un démarrage plus rapide.
{% endhint %}

## Utilisation de base (SSH)

```bash
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

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

## Téléverser des fichiers audio

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

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

## API Python

```python
import whisper

# Charger le modèle (téléchargements au premier usage)
model = whisper.load_model("large-v3", device="cuda")

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

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

# Imprimer 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 VRAM plus faible :

```bash
pip install faster-whisper
```

```python
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

```python
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 vers l'anglais

```python
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 :

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

## Génération de sous-titres

### Format SRT

```python
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

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

## Horodatages au niveau des mots

```python
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) :

```bash
pip install pyannote.audio
```

```python
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 REST API

Créer une API de transcription :

```python
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
        ]
    }

# Lancer : uvicorn server:app --host 0.0.0.0 --port 8000
```

## Benchmarks de performance

| Modèle   | GPU      | 1h Audio |
| -------- | -------- | -------- |
| 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 :

```python
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

```bash
# 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

{% hint style="danger" %}
**CUDA out of memory**
{% endhint %}

* 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 encore en cours de démarrage. Attendez 1-2 minutes et réessayez :

```bash
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 au lieu de l'original
* Activer la VAD pour ignorer les silences

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

| GPU      | VRAM  | Prix/jour   | Convient pour        |
| -------- | ----- | ----------- | -------------------- |
| RTX 3060 | 12Go  | 0,15–0,30 $ | modèles small/medium |
| RTX 3090 | 24 Go | 0,30–1,00 $ | large-v3             |
| RTX 4090 | 24 Go | 0,50–2,00 $ | large-v3, rapide     |
| A100     | 40Go  | 1,50–3,00 $ | traitement par lots  |

*Prix en USD/jour. Les tarifs varient selon le fournisseur — vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/whisper-transcription.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.