> 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/bark-tts.md).

# Bark TTS

Générez une voix et un audio réalistes avec Bark AI sur Clore.ai

Générez une parole et un audio réalistes avec Bark AI.

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

## Exigences du serveur

| Paramètre          | Minimum       | Recommandé     |
| ------------------ | ------------- | -------------- |
| RAM                | 8 Go          | 16 Go+         |
| VRAM               | 4 Go (petit)  | 8 Go+ (normal) |
| Réseau             | 200 Mbps      | 500 Mbps+      |
| Temps de démarrage | 3 à 5 minutes | -              |

{% hint style="warning" %}
**Temps de démarrage :** Au premier lancement, les modèles Bark sont téléchargés (3 à 5 minutes selon la vitesse du réseau). Une erreur HTTP 502 pendant ce temps est normale.
{% endhint %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<proxy-address>`

## Qu'est-ce que Bark ?

Bark de Suno AI peut générer :

* Une parole réaliste dans plusieurs langues
* Différentes voix de locuteurs
* Des sons non verbaux (rire, soupir)
* Musique et effets sonores
* Parole multilingue

## Exigences

| Qualité | VRAM  | Recommandé |
| ------- | ----- | ---------- |
| Petit   | 4 Go  | RTX 3060   |
| Normal  | 8 Go  | RTX 3070   |
| Élevé   | 12 Go | RTX 3090   |

## Déploiement rapide

**Image Docker :**

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

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

```bash
pip install git+https://github.com/suno-ai/bark.git gradio scipy && \
python -c "
import gradio as gr
from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy.io.wavfile as wav
import numpy as np
import tempfile

preload_models()

def generate(text, voice):
    audio = generate_audio(text, history_prompt=voice)
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        return f.name

voices = ['v2/en_speaker_0', 'v2/en_speaker_1', 'v2/en_speaker_2', 'v2/en_speaker_3',
          'v2/en_speaker_4', 'v2/en_speaker_5', 'v2/en_speaker_6', 'v2/en_speaker_7',
          'v2/en_speaker_8', 'v2/en_speaker_9']

demo = gr.Interface(fn=generate, inputs=[gr.Textbox(lines=5), gr.Dropdown(voices)],
                   outputs=gr.Audio(), title='Synthèse vocale Bark')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accéder à votre service

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

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

### Vérifier que cela fonctionne

```bash
# Vérifier si l'interface Gradio est accessible
curl https://your-http-pub.clorecloud.net/
```

{% hint style="warning" %}
Si vous obtenez une erreur HTTP 502, attendez 3 à 5 minutes - le service télécharge les modèles.
{% endhint %}

## Installation

```bash
pip install git+https://github.com/suno-ai/bark.git
pip install scipy
```

## Utilisation de base

```python
from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy.io.wavfile as wav
import numpy as np

# Précharger les modèles (téléchargement au premier lancement)
preload_models()

# Générer l'audio
text = "Bonjour, ceci est un test de la synthèse vocale Bark."
audio = generate_audio(text)

# Enregistrer au format WAV
wav.write("output.wav", SAMPLE_RATE, (audio * 32767).astype(np.int16))
```

## Sélection de la voix

### Voix intégrées

```python

# Voix anglaises (0-9)
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_0")
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_3")
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_9")

# Autres langues
audio = generate_audio("Bonjour !", history_prompt="v2/fr_speaker_0")  # Français
audio = generate_audio("Hallo !", history_prompt="v2/de_speaker_0")    # Allemand
audio = generate_audio("Hola !", history_prompt="v2/es_speaker_0")     # Espagnol
audio = generate_audio("Ciao !", history_prompt="v2/it_speaker_0")     # Italien
audio = generate_audio("Olá !", history_prompt="v2/pt_speaker_0")      # Portugais
audio = generate_audio("Привет !", history_prompt="v2/ru_speaker_0")   # Russe
audio = generate_audio("こんにちは！", history_prompt="v2/ja_speaker_0") # Japonais
audio = generate_audio("你好！", history_prompt="v2/zh_speaker_0")      # Chinois
```

### Langues disponibles

| Langue    | Code | Locuteurs |
| --------- | ---- | --------- |
| Anglais   | en   | 0-9       |
| Allemand  | de   | 0-9       |
| Espagnol  | es   | 0-9       |
| Français  | fr   | 0-9       |
| Hindi     | hi   | 0-9       |
| Italien   | it   | 0-9       |
| Japonais  | ja   | 0-9       |
| Coréen    | ko   | 0-9       |
| Polonais  | pl   | 0-9       |
| Portugais | pt   | 0-9       |
| Russe     | ru   | 0-9       |
| Turc      | tr   | 0-9       |
| Chinois   | zh   | 0-9       |

## Sons non verbaux

Bark peut générer des sons non verbaux :

```python

# Rire
audio = generate_audio("Bonjour ! [laughs] C'est tellement drôle !")

# Soupir
audio = generate_audio("[sighs] Je suis tellement fatigué aujourd'hui.")

# Halètement
audio = generate_audio("[gasps] Mon Dieu !")

# Se racler la gorge
audio = generate_audio("[clears throat] Hum, attention s'il vous plaît.")

# Notes de musique
audio = generate_audio("♪ La la la ♪")
```

## Audio longue durée

Pour un texte de plus de 13 secondes :

```python
from bark import generate_audio
from bark.generation import SAMPLE_RATE
import numpy as np

def generate_long_audio(text, voice="v2/en_speaker_6"):
    # Découper en phrases
    sentences = text.replace(".", ".|").replace("?", "?|").replace("!", "!|").split("|")
    sentences = [s.strip() for s in sentences if s.strip()]

    audio_segments = []
    for sentence in sentences:
        audio = generate_audio(sentence, history_prompt=voice)
        audio_segments.append(audio)
        # Ajouter une courte pause entre les phrases
        audio_segments.append(np.zeros(int(0.25 * SAMPLE_RATE)))

    return np.concatenate(audio_segments)

long_text = """
Ceci est un texte plus long qui sera divisé en plusieurs segments.
Chaque segment sera généré séparément. Puis ils seront concaténés.
Cela permet de générer de l'audio de n'importe quelle durée.
"""

audio = generate_long_audio(long_text)
```

## Clonage vocal

Créer des invites vocales personnalisées :

```python
from bark.generation import preload_models, generate_text_semantic
from bark.api import semantic_to_waveform
from bark import generate_audio, SAMPLE_RATE
import numpy as np

# Générer avec des caractéristiques spécifiques

# L'invite peut inclure la description du locuteur

# D'abord, générer une référence
voice_prompt = "v2/en_speaker_6"
text = "Voilà à quoi je ressemble quand je parle normalement."
audio = generate_audio(text, history_prompt=voice_prompt)

# Enregistrer comme voix personnalisée (exemple simplifié)
np.savez("custom_voice.npz", audio=audio)
```

## Traitement par lots

```python
import os
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np

texts = [
    "Bienvenue dans notre podcast.",
    "Aujourd'hui, nous allons parler d'intelligence artificielle.",
    "Commençons par l'introduction.",
]

output_dir = "./audio_clips"
os.makedirs(output_dir, exist_ok=True)

voice = "v2/en_speaker_6"

for i, text in enumerate(texts):
    print(f"Generating {i+1}/{len(texts)}")
    audio = generate_audio(text, history_prompt=voice)
    wav.write(
        os.path.join(output_dir, f"clip_{i:03d}.wav"),
        SAMPLE_RATE,
        (audio * 32767).astype(np.int16)
    )
```

## Serveur API

```python
from fastapi import FastAPI
from fastapi.responses import FileResponse
from bark import generate_audio, preload_models, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np
import tempfile
import os

app = FastAPI()
preload_models()

@app.post("/generate")
async def generate_speech(text: str, voice: str = "v2/en_speaker_6"):
    audio = generate_audio(text, history_prompt=voice)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        return FileResponse(f.name, media_type="audio/wav")

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

### Utilisation

```bash
curl -X POST "http://localhost:8000/generate?text=Hello%20world&voice=v2/en_speaker_6" \
    --output speech.wav
```

## Optimisation de la mémoire

### Pour une VRAM limitée

```python
import os

# Utiliser un modèle plus petit
os.environ["SUNO_USE_SMALL_MODELS"] = "1"

# Décharger vers le CPU
os.environ["SUNO_OFFLOAD_CPU"] = "1"

from bark import generate_audio
audio = generate_audio("Bonjour le monde")
```

### Activer FP16

```python
os.environ["SUNO_ENABLE_MPS"] = "0"

from bark import generate_audio
audio = generate_audio("Bonjour !", history_prompt="v2/en_speaker_6")
```

## Combinaison avec d'autres audios

```python
from pydub import AudioSegment
import numpy as np
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import tempfile

def bark_to_pydub(audio_array):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio_array * 32767).astype(np.int16))
        return AudioSegment.from_wav(f.name)

# Générer la parole
speech = generate_audio("Bienvenue dans l'émission !")
speech_audio = bark_to_pydub(speech)

# Charger la musique de fond
music = AudioSegment.from_mp3("background.mp3")

# Mélanger ensemble
music = music - 20  # Baisser le volume de la musique
combined = speech_audio.overlay(music)
combined.export("output.mp3", format="mp3")
```

## Performances

| Mode   | GPU      | Temps (10 mots) |
| ------ | -------- | --------------- |
| Normal | RTX 3090 | \~5 s           |
| Normal | RTX 4090 | \~3 s           |
| Petit  | RTX 3060 | \~8 s           |
| CPU    | -        | \~60 s          |

## Comparaison avec d'autres synthèses vocales

| Fonctionnalité | Bark     | Coqui     | Piper  |
| -------------- | -------- | --------- | ------ |
| Qualité        | Meilleur | Excellent | Bon    |
| Vitesse        | Lent     | Moyen     | Rapide |
| Langues        | 13+      | 20+       | 30+    |
| Non verbal     | Oui      | Non       | Non    |
| VRAM           | 8GB+     | 4 Go      | 1 Go   |

## Dépannage

### Mémoire insuffisante

```python

# Utiliser de petits modèles
os.environ["SUNO_USE_SMALL_MODELS"] = "1"
os.environ["SUNO_OFFLOAD_CPU"] = "1"
```

### Génération lente

* Utiliser le GPU (pas le CPU)
* Garder les modèles chargés entre les générations
* Générer des segments plus courts

### Problèmes de qualité audio

* Essayer différents locuteurs
* Découper le texte long en phrases
* Éviter les caractères spéciaux

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

| GPU        | Tarif horaire | Tarif journalier | Session de 4 heures |
| ---------- | ------------- | ---------------- | ------------------- |
| RTX 3060   | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090   | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090   | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs

## Étapes suivantes

* [Clonage vocal RVC](/guides/guides_v2-fr/audio-et-voix/rvc-voice-clone.md)
* [Whisper Transcription](/guides/guides_v2-fr/audio-et-voix/whisper-transcription.md)
* [Musique AudioCraft](/guides/guides_v2-fr/audio-et-voix/audiocraft-music.md)


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/bark-tts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.