# Bark TTS

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 [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

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

{% hint style="warning" %}
**Temps de démarrage :** Le premier lancement télécharge les modèles Bark (3-5 minutes selon la vitesse du réseau). HTTP 502 pendant ce temps est normal.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À 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@<adresse-proxy>`

## Qu'est-ce que Bark ?

Bark de Suno AI peut générer :

* Une parole réaliste en plusieurs langues
* Diffantes voix de locuteurs
* Sons non verbaux (rire, soupir)
* Musique et effets sonores
* Parole multilingue

## Exigences

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

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-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='Bark TTS')
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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

### Vérifiez 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 HTTP 502, attendez 3-5 minutes - le service télécharge des 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échargements au premier lancement)
preload_models()

# Générer de l'audio
text = "Hello, this is a test of Bark text to speech."
audio = generate_audio(text)

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

## Sélection de la voix

### Voix intégrées

```python

# Locuteurs anglais (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 de l'audio non verbal :

```python

# Rire
audio = generate_audio("Hello! [laughs] That's so funny!")

# Soupirs
audio = generate_audio("[sighs] I'm so tired today.")

# Halètements
audio = generate_audio("[gasps] Oh my god!")

# Se racler la gorge
audio = generate_audio("[clears throat] Ahem, attention please.")

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

## Audio longue durée

Pour un texte plus long que 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"):
    # Diviser 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 petite 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. Ensuite ils seront concaténés.
Cela permet de générer de l'audio de n'importe quelle longueur.
"""

audio = generate_long_audio(long_text)
```

## Clonage de voix

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 une description du locuteur

# D'abord, générer une référence
voice_prompt = "v2/en_speaker_6"
text = "This is how I sound when I speak normally."
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 = [
    "Welcome to our podcast.",
    "Today we'll discuss artificial intelligence.",
    "Let's get started with the 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")

# Lancer : 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 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("Hello world")
```

### Activer FP16

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

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

## Combinaison avec d'autres audio

```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("Welcome to the show!")
speech_audio = bark_to_pydub(speech)

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

# Mixer 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 | \~5s            |
| Normal | RTX 4090 | \~3s            |
| Faible | RTX 3060 | \~8s            |
| CPU    | -        | \~60s           |

## Comparaison avec d'autres TTS

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

## Dépannage

### Mémoire insuffisante

```python

# Utiliser des 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
* Diviser le texte long en phrases
* Éviter les caractères spéciaux

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 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 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

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


---

# Agent Instructions: 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/bark-tts.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.