# Bark TTS

Genera voz y audio realistas con Bark AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Requisitos del servidor

| Parámetro        | Mínimo        | Recomendado   |
| ---------------- | ------------- | ------------- |
| RAM              | 8GB           | 16GB+         |
| VRAM             | 4GB (pequeño) | 8GB+ (normal) |
| Red              | 200Mbps       | 500Mbps+      |
| Tiempo de inicio | 3-5 minutos   | -             |

{% hint style="warning" %}
**Tiempo de inicio:** El primer lanzamiento descarga los modelos de Bark (3-5 minutos dependiendo de la velocidad de la red). HTTP 502 durante este tiempo es normal.
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis Pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es Bark?

Bark de Suno AI puede generar:

* Voz realista en múltiples idiomas
* Varias voces de hablantes
* Sonidos no verbales (risas, suspiros)
* Música y efectos de sonido
* Discurso multilingüe

## Requisitos

| Calidad | VRAM | Recomendado |
| ------- | ---- | ----------- |
| Pequeña | 4GB  | RTX 3060    |
| Normal  | 8GB  | RTX 3070    |
| Alto    | 12GB | RTX 3090    |

## Despliegue rápido

**Imagen Docker:**

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

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

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

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

### Verificar que funciona

```bash
# Comprobar si la interfaz de Gradio es accesible
curl https://your-http-pub.clorecloud.net/
```

{% hint style="warning" %}
Si obtienes HTTP 502, espera 3-5 minutos: el servicio está descargando modelos.
{% endhint %}

## Instalación

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

## Uso básico

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

# Precargar modelos (descargas en la primera ejecución)
preload_models()

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

# Guardar como WAV
wav.write("output.wav", SAMPLE_RATE, (audio * 32767).astype(np.int16))
```

## Selección de voz

### Voces integradas

```python

# Hablantes en inglés (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")

# Otros idiomas
audio = generate_audio("Bonjour!", history_prompt="v2/fr_speaker_0")  # Francés
audio = generate_audio("Hallo!", history_prompt="v2/de_speaker_0")    # Alemán
audio = generate_audio("Hola!", history_prompt="v2/es_speaker_0")     # Español
audio = generate_audio("Ciao!", history_prompt="v2/it_speaker_0")     # Italiano
audio = generate_audio("Olá!", history_prompt="v2/pt_speaker_0")      # Portugués
audio = generate_audio("Привет!", history_prompt="v2/ru_speaker_0")   # Ruso
audio = generate_audio("こんにちは!", history_prompt="v2/ja_speaker_0") # Japonés
audio = generate_audio("你好!", history_prompt="v2/zh_speaker_0")      # Chino
```

### Idiomas disponibles

| Idioma    | Código | Hablantes |
| --------- | ------ | --------- |
| Inglés    | en     | 0-9       |
| Alemán    | de     | 0-9       |
| Español   | es     | 0-9       |
| Francés   | fr     | 0-9       |
| Hindi     | hi     | 0-9       |
| Italiano  | it     | 0-9       |
| Japonés   | ja     | 0-9       |
| Coreano   | ko     | 0-9       |
| Polaco    | pl     | 0-9       |
| Portugués | pt     | 0-9       |
| Ruso      | ru     | 0-9       |
| Turco     | tr     | 0-9       |
| Chino     | zh     | 0-9       |

## Sonidos no verbales

Bark puede generar audio no verbal:

```python

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

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

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

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

# Notas musicales
audio = generate_audio("♪ La la la ♪")
```

## Audio de larga duración

Para texto más largo que 13 segundos:

```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"):
    # Dividir en oraciones
    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)
        # Añadir una pequeña pausa entre oraciones
        audio_segments.append(np.zeros(int(0.25 * SAMPLE_RATE)))

    return np.concatenate(audio_segments)

long_text = """
Este es un texto más largo que se dividirá en múltiples segmentos.
Cada segmento se generará por separado. Luego se concatenarán.
Esto permite generar audio de cualquier duración.
"""

audio = generate_long_audio(long_text)
```

## Clonación de voz

Crear prompts de voz personalizados:

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

# Generar con características específicas

# El prompt puede incluir descripción del hablante

# Primero, generar una referencia
voice_prompt = "v2/en_speaker_6"
text = "This is how I sound when I speak normally."
audio = generate_audio(text, history_prompt=voice_prompt)

# Guardar como voz personalizada (ejemplo simplificado)
np.savez("custom_voice.npz", audio=audio)
```

## Procesamiento por lotes

```python
import os
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np

texts = [
    "Bienvenidos a nuestro podcast.",
    "Hoy discutiremos la inteligencia artificial.",
    "Comencemos con la introducción.",
]

output_dir = "./audio_clips"
os.makedirs(output_dir, exist_ok=True)

voice = "v2/en_speaker_6"

for i, text in enumerate(texts):
    print(f"Generando {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)
    )
```

## Servidor API

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

# Ejecutar: uvicorn server:app --host 0.0.0.0 --port 8000
```

### Uso

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

## Optimización de memoria

### Para VRAM limitada

```python
import os

# Use un modelo más pequeño
os.environ["SUNO_USE_SMALL_MODELS"] = "1"

# Derivar a la CPU
os.environ["SUNO_OFFLOAD_CPU"] = "1"

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

### Habilitar FP16

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

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

## Combinando con otro 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)

# Generar voz
speech = generate_audio("Welcome to the show!")
speech_audio = bark_to_pydub(speech)

# Cargar música de fondo
music = AudioSegment.from_mp3("background.mp3")

# Mezclar juntos
music = music - 20  # Reducir volumen de la música
combined = speech_audio.overlay(music)
combined.export("output.mp3", format="mp3")
```

## Rendimiento

| Modo    | GPU      | Tiempo (10 palabras) |
| ------- | -------- | -------------------- |
| Normal  | RTX 3090 | \~5s                 |
| Normal  | RTX 4090 | \~3s                 |
| Pequeña | RTX 3060 | \~8s                 |
| CPU     | -        | \~60s                |

## Comparación con otros TTS

| Función   | Bark  | Coqui  | Piper  |
| --------- | ----- | ------ | ------ |
| Calidad   | Mejor | Genial | Bueno  |
| Velocidad | Lento | Medio  | Rápido |
| Idiomas   | 13+   | 20+    | 30+    |
| No verbal | Sí    | No     | No     |
| VRAM      | 8GB+  | 4GB    | 1GB    |

## Solución de problemas

### Memoria insuficiente

```python

# Usar modelos pequeños
os.environ["SUNO_USE_SMALL_MODELS"] = "1"
os.environ["SUNO_OFFLOAD_CPU"] = "1"
```

### Generación lenta

* Usar GPU (no CPU)
* Mantener los modelos cargados entre generaciones
* Generar segmentos más cortos

### Problemas de calidad de audio

* Probar diferentes hablantes
* Dividir texto largo en oraciones
* Evitar caracteres especiales

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| 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           |

*Los precios varían según el proveedor y la demanda. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** market para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores

## Próximos pasos

* [Clonación de voz RVC](/guides/guides_v2-es/audio-y-voz/rvc-voice-clone.md)
* [Whisper Transcription](/guides/guides_v2-es/audio-y-voz/whisper-transcription.md)
* [AudioCraft Music](/guides/guides_v2-es/audio-y-voz/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-es/audio-y-voz/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.