Bark TTS

Generieren Sie realistische Sprache und Audio mit Bark AI auf Clore.ai

Erzeuge realistische Sprache und Audio mit Bark AI.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	8GB	16GB+
VRAM	4GB (klein)	8GB+ (normal)
Netzwerk	200Mbps	500Mbps+
Startzeit	3–5 Minuten	-

Startzeit: Beim ersten Start werden Bark-Modelle heruntergeladen (3–5 Minuten, abhängig von der Netzwerkgeschwindigkeit). HTTP 502 ist in dieser Zeit normal.

Mieten auf CLORE.AI

1. Besuchen Sie CLORE.AI Marketplace

2. Nach GPU-Typ, VRAM und Preis filtern

3. Wählen On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfigurieren Sie Ihre Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Umgebungsvariablen bei Bedarf hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf Bereitstellung warten

Zugriff auf Ihren Server

• Verbindungsdetails finden Sie in Meine Bestellungen

• Webschnittstellen: Verwenden Sie die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist Bark?

Bark von Suno AI kann erzeugen:

• Realistische Sprache in mehreren Sprachen

• Verschiedene Sprecherstimmen

• Nicht-verbale Geräusche (Lachen, Seufzen)

• Musik und Soundeffekte

• Mehrsprachige Sprache

Anforderungen

Qualität	VRAM	Empfohlen
Klein	4GB	RTX 3060
Normal	8GB	RTX 3070
Hoch	12GB	RTX 3090

Schnelle Bereitstellung

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

Ports:

22/tcp
7860/http

Befehl:

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)
"

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Überprüfen, ob es funktioniert

# Prüfen, ob die Gradio-Oberfläche erreichbar ist
curl https://your-http-pub.clorecloud.net/

Wenn Sie HTTP 502 erhalten, warten Sie 3–5 Minuten – der Dienst lädt Modelle herunter.

Installation

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

Grundlegende Verwendung

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

# Modelle vorladen (Downloads beim ersten Lauf)
preload_models()

# Audio erzeugen
text = "Hello, this is a test of Bark text to speech."
audio = generate_audio(text)

# Als WAV speichern
wav.write("output.wav", SAMPLE_RATE, (audio * 32767).astype(np.int16))

Stimmenauswahl

Eingebaute Stimmen

# Englische Sprecher (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")

# Andere Sprachen
audio = generate_audio("Bonjour!", history_prompt="v2/fr_speaker_0")  # Französisch
audio = generate_audio("Hallo!", history_prompt="v2/de_speaker_0")    # Deutsch
audio = generate_audio("Hola!", history_prompt="v2/es_speaker_0")     # Spanisch
audio = generate_audio("Ciao!", history_prompt="v2/it_speaker_0")     # Italienisch
audio = generate_audio("Olá!", history_prompt="v2/pt_speaker_0")      # Portugiesisch
audio = generate_audio("Привет!", history_prompt="v2/ru_speaker_0")   # Russisch
audio = generate_audio("こんにちは!", history_prompt="v2/ja_speaker_0") # Japanisch
audio = generate_audio("你好!", history_prompt="v2/zh_speaker_0")      # Chinesisch

Verfügbare Sprachen

Sprache	Code	Sprecher
Englisch	en	0-9
Deutsch	de	0-9
Spanisch	es	0-9
Französisch	fr	0-9
Hindi	hi	0-9
Italienisch	it	0-9
Japanisch	ja	0-9
Koreanisch	ko	0-9
Polnisch	pl	0-9
Portugiesisch	pt	0-9
Russisch	ru	0-9
Türkisch	tr	0-9
Chinesisch	zh	0-9

Nicht-verbale Geräusche

Bark kann nicht-verbales Audio erzeugen:

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

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

# Keuchen
audio = generate_audio("[gasps] Oh my god!")

# Räuspern
audio = generate_audio("[clears throat] Ahem, attention please.")

# Musiknoten
audio = generate_audio("♪ La la la ♪")

Langform-Audio

Für Text länger als 13 Sekunden:

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"):
    # In Sätze aufteilen
    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)
        # Kleine Pause zwischen den Sätzen hinzufügen
        audio_segments.append(np.zeros(int(0.25 * SAMPLE_RATE)))

    return np.concatenate(audio_segments)

long_text = """
Dies ist ein längerer Text, der in mehrere Segmente aufgeteilt wird.
Jedes Segment wird separat erzeugt. Danach werden sie zusammengefügt.
Dies ermöglicht die Erzeugung von Audio beliebiger Länge.
"""

audio = generate_long_audio(long_text)

Stimmenklon

Erstelle benutzerdefinierte Stimmprompts:

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

# Mit bestimmten Eigenschaften erzeugen

# Das Prompt kann eine Sprecherbeschreibung enthalten

# Zuerst eine Referenz erzeugen
voice_prompt = "v2/en_speaker_6"
text = "This is how I sound when I speak normally."
audio = generate_audio(text, history_prompt=voice_prompt)

# Als benutzerdefinierte Stimme speichern (vereinfachtes Beispiel)
np.savez("custom_voice.npz", audio=audio)

Batch-Verarbeitung

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

API-Server

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")

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000

Verwendung

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

Speicheroptimierung

Für begrenzten VRAM

import os

# Kleineres Modell verwenden
os.environ["SUNO_USE_SMALL_MODELS"] = "1"

# Auf die CPU auslagern
os.environ["SUNO_OFFLOAD_CPU"] = "1"

from bark import generate_audio
audio = generate_audio("Hello world")

FP16 aktivieren

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

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

Kombination mit anderem 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)

# Sprache generieren
speech = generate_audio("Welcome to the show!")
speech_audio = bark_to_pydub(speech)

# Hintergrundmusik laden
music = AudioSegment.from_mp3("background.mp3")

# Zusammen mischen
music = music - 20  # Musiklautstärke verringern
combined = speech_audio.overlay(music)
combined.export("output.mp3", format="mp3")

Leistung

Modus	GPU	Zeit (10 Wörter)
Normal	RTX 3090	~5s
Normal	RTX 4090	~3s
Klein	RTX 3060	~8s
CPU	-	~60s

Vergleich mit anderen TTS

Funktion	Bark	Coqui	Piper
Qualität	Am besten	Großartig	Gut
Geschwindigkeit	Langsam	Mittel	Schnell
Sprachen	13+	20+	30+
Nicht-verbal	Ja	Nein	Nein
VRAM	8GB+	4GB	1GB

Fehlerbehebung

Kein Speicher mehr

# Kleine Modelle verwenden
os.environ["SUNO_USE_SMALL_MODELS"] = "1"
os.environ["SUNO_OFFLOAD_CPU"] = "1"

Langsame Generierung

• GPU verwenden (nicht CPU)

• Modelle zwischen den Generierungen geladen halten

• Kürzere Segmente erzeugen

Audioqualitätsprobleme

• Verschiedene Sprecher ausprobieren

• Langen Text in Sätze aufteilen

• Sonderzeichen vermeiden

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

• Verwenden Sie Spot Markt für flexible Workloads (oft 30–50% günstiger)

• Bezahlen mit CLORE Token

• Preise bei verschiedenen Anbietern vergleichen

Nächste Schritte

• RVC Voice Cloning

• Whisper Transcription

• AudioCraft Music