F5-TTS

Texto a voz rápido y fluido con F5-TTS en GPUs de Clore.ai

Genera voz natural con F5-TTS: un sistema TTS rápido y fluido.

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

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 F5-TTS?

F5-TTS ofrece:

• Inferencia rápida (más rápida que el tiempo real)

• Prosodia e intonación naturales

• Clonación de voz zero-shot

• Soporte multilingüe

Recursos

• GitHub: SWivid/F5-TTS

• HuggingFace: SWivid/F5-TTS

• Artículo: Artículo F5-TTS

• Demostración: Espacio de HuggingFace

Hardware recomendado

Componente	Mínimo	Recomendado	Óptimo
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	6GB	12GB	16GB
CPU	4 núcleos	8 núcleos	16 núcleos
RAM	16GB	32GB	64GB
Almacenamiento	SSD de 20 GB	50GB NVMe	100GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen Docker:

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

Puertos:

22/tcp
7860/http

Comando:

pip install f5-tts && \
f5-tts-webui

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.

Instalación

pip install f5-tts

# O desde la fuente
git clone https://github.com/SWivid/F5-TTS.git
cd F5-TTS
pip install -e .

Lo que puedes crear

Contenido de voz

• Producción de podcasts

• Narración de audiolibros

• Locución para vídeos

Accesibilidad

• Lectores de pantalla

• Lectores de documentos

• Materiales de aprendizaje

Aplicaciones interactivas

• Asistentes de voz

• NPCs en juegos

• Bots de atención al cliente

Proyectos creativos

• Voces de personajes

• Dramas de audio

• Voces en música

Uso básico

TTS simple

from f5_tts import F5TTS

# Inicializar
tts = F5TTS(device="cuda")

# Generar voz
audio = tts.generate(
    text="¡Hola! Esto es F5-TTS generando voz natural.",
    output_path="output.wav"
)

Clonación de voz

from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Clonar voz desde audio de referencia
audio = tts.generate(
    text="Esta es mi voz clonada hablando un nuevo texto.",
    ref_audio="reference_voice.wav",
    ref_text="Este es el texto de referencia hablado en el audio.",
    output_path="cloned_output.wav"
)

Soporte multilingüe

from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Inglés
tts.generate(
    text="Hello, how are you today?",
    ref_audio="english_speaker.wav",
    output_path="english.wav"
)

# Chino
tts.generate(
    text="你好，今天怎么样？",
    ref_audio="chinese_speaker.wav",
    output_path="chinese.wav"
)

# Francés
tts.generate(
    text="Bonjour, comment allez-vous?",
    ref_audio="french_speaker.wav",
    output_path="french.wav"
)

Procesamiento por lotes

from f5_tts import F5TTS
import os

tts = F5TTS(device="cuda")

texts = [
    "Bienvenido a nuestra demostración del producto.",
    "Hoy le mostraremos las características clave.",
    "Empecemos con el panel principal.",
    "Como puede ver, la interfaz es intuitiva.",
    "¡Gracias por ver!"
]

ref_audio = "narrator_voice.wav"
ref_text = "Texto de muestra del audio de referencia."
output_dir = "./narration"
os.makedirs(output_dir, exist_ok=True)

for i, text in enumerate(texts):
    print(f"Generando {i+1}/{len(texts)}: {text[:50]}...")

    tts.generate(
        text=text,
        ref_audio=ref_audio,
        ref_text=ref_text,
        output_path=f"{output_dir}/segment_{i:03d}.wav"
    )

Audio de larga duración

from f5_tts import F5TTS

tts = F5TTS(device="cuda")

long_text = """
Bienvenido a esta guía completa sobre aprendizaje automático.
En este capítulo, exploraremos los fundamentos de las redes neuronales.
Las redes neuronales son sistemas de computación inspirados en redes neuronales biológicas.
Consisten en nodos interconectados que procesan información.
Empecemos con los conceptos básicos.
"""

# F5-TTS maneja texto largo dividiéndolo en oraciones
audio = tts.generate(
    text=long_text,
    ref_audio="narrator.wav",
    output_path="long_narration.wav",
    chunk_size=200  # Caracteres por fragmento
)

Interfaz Gradio

import gradio as gr
from f5_tts import F5TTS
import tempfile

tts = F5TTS(device="cuda")

def generate_speech(text, ref_audio, ref_text):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        tts.generate(
            text=text,
            ref_audio=ref_audio,
            ref_text=ref_text,
            output_path=f.name
        )
        return f.name

demo = gr.Interface(
    fn=generate_speech,
    inputs=[
        gr.Textbox(label="Texto a hablar", lines=5),
        gr.Audio(type="filepath", label="Voz de referencia"),
        gr.Textbox(label="Texto de referencia", lines=2)
    ],
    outputs=gr.Audio(label="Voz generada"),
    title="Clonación de voz F5-TTS",
    description="Clona cualquier voz con F5-TTS en los servidores de CLORE.AI"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Servidor API

from fastapi import FastAPI, UploadFile, File, Form
from fastapi.responses import FileResponse
from f5_tts import F5TTS
import tempfile

app = FastAPI()
tts = F5TTS(device="cuda")

@app.post("/synthesize")
async def synthesize(
    text: str = Form(...),
    ref_audio: UploadFile = File(...),
    ref_text: str = Form(...)
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref_file:
        ref_file.write(await ref_audio.read())
        ref_path = ref_file.name

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_file:
        tts.generate(
            text=text,
            ref_audio=ref_path,
            ref_text=ref_text,
            output_path=out_file.name
        )
        return FileResponse(out_file.name, media_type="audio/wav")

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

Rendimiento

Longitud del texto	GPU	Tiempo de generación	Factor en tiempo real
100 caracteres	RTX 3090	0.5s	5x
100 caracteres	RTX 4090	0.3s	8x
500 caracteres	RTX 4090	1.2s	10x
1000 caracteres	A100	2.0s	12x

Problemas comunes y soluciones

Pobre coincidencia de voz

Problema: La voz generada no coincide con la de referencia

Soluciones:

• Use 5-15 segundos de audio de referencia claro

• Proporcione una transcripción precisa del texto de referencia

• Evite el ruido de fondo en la referencia

• Haga coincidir el idioma del texto y de la referencia

Problemas de pronunciación

Problema: Pronuncia mal palabras o nombres

Soluciones:

# Use pistas fonéticas para palabras difíciles
text = "Bienvenido a CLORE (pronunciado KLOR) plataforma AI."

# O use formato similar a SSML
text = "El CEO, John Smith (SMIHTH), hablará."

Problemas de calidad de audio

Problema: La salida suena robótica o distorsionada

Soluciones:

• Use audio de referencia de alta calidad (24 kHz+)

• Limpie la referencia del ruido

• Pruebe diferentes muestras de referencia

• Aumente las configuraciones de calidad de generación

Problemas de memoria

Problema: Memoria insuficiente para textos largos

Soluciones:

# Procese en fragmentos más pequeños
tts.generate(
    text=long_text,
    chunk_size=100,  # Fragmentos más pequeños
    overlap=20  # Transiciones suaves
)

Generación lenta

Problema: Tarda demasiado en generar

Soluciones:

• Use inferencia en GPU (CUDA)

• Reduzca chunk_size para un procesamiento más rápido

• Use RTX 4090 o superior

• Habilite media precisión (fp16)

Solución de problemas

La voz no coincide con la referencia

• Use 5-15 segundos de audio de referencia claro

• Transcriba con precisión el texto de referencia

• Evite el ruido de fondo en la referencia

Problemas de calidad de audio

• Use referencia con alta tasa de muestreo (24 kHz+)

• Limpie la referencia del ruido

• Pruebe diferentes muestras de referencia

Generación lenta

• Use CUDA (no CPU)

• Reduzca la longitud del texto o divídalo en fragmentos

• Use tamaños de lote más pequeños

Desajuste de idioma

• Haga coincidir el idioma del texto con el del audio de referencia

• Algunos idiomas necesitan modelos específicos

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

• XTTS - TTS alternativo

• Bark TTS - TTS expresivo

• SadTalker - Cabezas parlantes