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 Marketplace de CLORE.AI.

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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 en tiempo real)

• Prosodia y entonación naturales

• Clonación de voz zero-shot

• Compatibilidad multilingüe

Recursos

• GitHub: SWivid/F5-TTS

• HuggingFace: SWivid/F5-TTS

• Artículo: Artículo de F5-TTS

• Demo: Espacio de Hugging Face

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 de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Instalación

pip install f5-tts

# O desde el código 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 pódcasts

• Narración de audiolibros

• Locución para videos

Accesibilidad

• Lectores de pantalla

• Lectores de documentos

• Materiales de aprendizaje

Aplicaciones interactivas

• Asistentes de voz

• PNJ de videojuegos

• Bots de atención al cliente

Proyectos creativos

• Voces de personajes

• Dramas de audio

• Voces para música

Uso básico

TTS simple

from f5_tts import F5TTS

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

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

Clonación de voz

from f5_tts import F5TTS

tts = F5TTS(device="cuda")

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

Compatibilidad multilingüe

from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Inglés
tts.generate(
    text="Hola, ¿cómo estás hoy?",
    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 = [
    "Bienvenidos a nuestra demostración del producto.",
    "Hoy les mostraremos las funciones clave.",
    "Comencemos con el panel principal.",
    "Como pueden 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 formato largo

from f5_tts import F5TTS

tts = F5TTS(device="cuda")

long_text = """
Bienvenidos 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 informáticos inspirados en las redes neuronales biológicas.
Consisten en nodos interconectados que procesan información.
Comencemos con los conceptos básicos.
"""

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

Interfaz de 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 pronunciar", lines=5),
        gr.Audio(type="filepath", label="Voz de referencia"),
        gr.Textbox(label="Texto de referencia", lines=2)
    ],
    outputs=gr.Audio(label="Audio generado"),
    title="Clonación de voz con 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,5 s	5x
100 caracteres	RTX 4090	0,3 s	8x
500 caracteres	RTX 4090	1,2 s	10x
1000 caracteres	A100	2.0 s	12x

Problemas comunes y soluciones

Mala coincidencia de voz

Problema: La voz generada no coincide con la referencia

Soluciones:

• Usa entre 5 y 15 segundos de audio de referencia limpio

• Proporciona una transcripción precisa del texto de referencia

• Evita el ruido de fondo en la referencia

• Haz coincidir el idioma del texto y de la referencia

Problemas de pronunciación

Problema: Pronuncia mal palabras o nombres

Soluciones:

# Usa pistas fonéticas para palabras difíciles
text = "Bienvenido a la plataforma de IA CLORE (pronunciado KLOR)."

# O usa un formato similar a SSML
text = "El director ejecutivo, John Smith (SMIHTH), hablará."

Problemas de calidad de audio

Problema: La salida suena robótica o distorsionada

Soluciones:

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

• Limpia la referencia del ruido

• Prueba diferentes muestras de referencia

• Aumenta los ajustes de calidad de generación

Problemas de memoria

Problema: Memoria insuficiente para textos largos

Soluciones:

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

• Usa inferencia en GPU (CUDA)

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

• Usa una RTX 4090 o superior

• Habilita precisión media (fp16)

Solución de problemas

La voz no coincide con la referencia

• Usa entre 5 y 15 segundos de audio de referencia limpio

• Transcribe con precisión el texto de referencia

• Evita el ruido de fondo en la referencia

Problemas de calidad de audio

• Usa una referencia con alta frecuencia de muestreo (24 kHz+)

• Limpia la referencia del ruido

• Prueba diferentes muestras de referencia

Generación lenta

• Usa CUDA (no CPU)

• Reduce la longitud del texto o divídelo en fragmentos

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

Incompatibilidad de idioma

• Haz 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 partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• XTTS - TTS alternativos

• Bark TTS - TTS expresivos

• SadTalker - Avatares parlantes