# 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](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/whisperx):

```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](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/whisperx) 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.*