Bark TTS

Générez de la parole et de l'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

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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:

Aller à la Mes commandes page
Cliquez sur votre commande
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

0-9

Allemand

0-9

Espagnol

0-9

Français

0-9

Hindi

0-9

Italien

0-9

Japonais

0-9

Coréen

0-9

Polonais

0-9

Portugais

0-9

Russe

0-9

Turc

0-9

Chinois

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

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

PrécédentWhisperX avec diarisation SuivantXTTS (Coqui)

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagExigences du serveur

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce que Bark ?

hashtagExigences

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagVérifiez que cela fonctionne

hashtagInstallation

hashtagUtilisation de base

hashtagSélection de la voix

hashtagVoix intégrées

hashtagLangues disponibles

hashtagSons non verbaux

hashtagAudio longue durée

hashtagClonage de voix

hashtagTraitement par lots

hashtagServeur API

hashtagUtilisation

hashtagOptimisation de la mémoire

hashtagPour VRAM limitée

hashtagActiver FP16

hashtagCombinaison avec d'autres audio

hashtagPerformances

hashtagComparaison avec d'autres TTS

hashtagDépannage

hashtagMémoire insuffisante

hashtagGénération lente

hashtagProblèmes de qualité audio

hashtagEstimation des coûts

hashtagProchaines étapes

Exigences du serveur

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce que Bark ?

Exigences

Déploiement rapide

Accéder à votre service

Vérifiez que cela fonctionne

Installation

Utilisation de base

Sélection de la voix

Voix intégrées

Langues disponibles

Sons non verbaux

Audio longue durée

Clonage de voix

Traitement par lots

Serveur API

Utilisation

Optimisation de la mémoire

Pour VRAM limitée

Activer FP16

Combinaison avec d'autres audio

Performances

Comparaison avec d'autres TTS

Dépannage

Mémoire insuffisante

Génération lente

Problèmes de qualité audio

Estimation des coûts

Prochaines étapes