Bark TTS

Genera habla y audio realistas con Bark AI en Clore.ai

Genera voz y audio realistas con Bark AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

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	-

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.

Alquilar en CLORE.AI

1. Visita 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:

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

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

Si obtienes HTTP 502, espera 3-5 minutos: el servicio está descargando modelos.

Instalación

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

Uso básico

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

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

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

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:

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

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

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

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

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

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

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

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

• Whisper Transcription

• AudioCraft Music