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