# Bark TTS

Erzeuge realistische Sprache und Audio mit Bark AI.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Serveranforderungen

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

{% hint style="warning" %}
**Startzeit:** Beim ersten Start werden Bark-Modelle heruntergeladen (3–5 Minuten, abhängig von der Netzwerkgeschwindigkeit). HTTP 502 ist in dieser Zeit normal.
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen Sie [CLORE.AI Marketplace](https://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:**

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

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

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

{% hint style="warning" %}
Wenn Sie HTTP 502 erhalten, warten Sie 3–5 Minuten – der Dienst lädt Modelle herunter.
{% endhint %}

## Installation

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

## Grundlegende Verwendung

```python
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

```python

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

```python

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

```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"):
    # 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:

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

# 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

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

## API-Server

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

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

### Verwendung

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

## Speicheroptimierung

### Für begrenzten VRAM

```python
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

```python
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

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

# 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

```python

# 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*](https://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](/guides/guides_v2-de/audio-and-sprache/rvc-voice-clone.md)
* [Whisper Transcription](/guides/guides_v2-de/audio-and-sprache/whisper-transcription.md)
* [AudioCraft Music](/guides/guides_v2-de/audio-and-sprache/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-de/audio-and-sprache/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.