Bark TTS

Générez une parole 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 CLORE.AI Marketplace.

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	-

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.

Location sur CLORE.AI

1. Visitez 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 :

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

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

Si vous obtenez HTTP 502, attendez 3-5 minutes - le service télécharge des 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é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

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

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

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 :

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

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

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

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

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

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

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

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

• Whisper Transcription

• AudioCraft Music