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.

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)	8 Go+ (normal)
Réseau	200 Mbps	500 Mbps+
Temps de démarrage	3 à 5 minutes	-

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.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

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 :

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

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

Si vous obtenez une erreur HTTP 502, attendez 3 à 5 minutes - le service télécharge les modèles.

Installation

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

Utilisation de base

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

# 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 :

# 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 :

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 :

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

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

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

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

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

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

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

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

• Whisper Transcription

• Musique AudioCraft