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