# F5-TTS

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

{% 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 %}

## 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 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](https://github.com/SWivid/F5-TTS)
* **HuggingFace:** [SWivid/F5-TTS](https://huggingface.co/SWivid/F5-TTS)
* **Artículo:** [Artículo F5-TTS](https://arxiv.org/abs/2410.06885)
* **Demostración:** [Espacio de HuggingFace](https://huggingface.co/spaces/mrfakename/E2-F5-TTS)

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

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

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

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

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

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

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

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

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

```python
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:**

```python

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

```python

# 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*](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

* [XTTS](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/xtts-coqui) - TTS alternativo
* [Bark TTS](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/bark-tts) - TTS expresivo
* [SadTalker](https://docs.clore.ai/guides/guides_v2-es/cabezas-parlantes/sadtalker) - Cabezas parlantes