Guía de inicio rápido de Clonación de Voz Profesional

Esta guía te mostrará cómo crear un Clon de Voz Profesional (PVC) con la API de PVC. Para crear un PVC desde el panel de control, consulta la guía de producto Clon de Voz Profesional.

Para crear un PVC, necesitas tener el plan Creator o superior.

Para obtener una explicación detallada de cómo funcionan IVC y PVC internamente y cuándo elegir cada uno, consulta Clonación de voz: cómo funciona.

Si no tienes claro qué está permitido desde un punto de vista legal, consulta los Términos del servicio y nuestra información sobre seguridad de la IA para obtener más información.

Crear un PVC mediante la API implica muchos más pasos que crear un Clon de Voz Instantáneo. Esto se debe a que los PVC son más complejos y requieren más datos y ajuste fino para crear un clon de alta calidad.

Uso de la API de Clon de Voz Profesional

Esta guía asume que ya has configurado tu clave de API y SDK. Completa primero la guía de inicio rápido si aún no lo has hecho.

Crear una voz PVC

Crea un archivo llamado example.py o example.mts, según el lenguaje que elijas, y añade el siguiente código para crear una voz PVC:

# example.py
import os
import time
import base64
from contextlib import ExitStack
from io import BytesIO
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs
load_dotenv()
elevenlabs = ElevenLabs(
  api_key=os.getenv("ELEVENLABS_API_KEY"),
)
voice = elevenlabs.voices.pvc.create(
    name="My Professional Voice Clone",
    language="en",
    description="A professional voice clone of my voice"
)
print(voice)

Subir archivos de audio

A continuación, subiremos los archivos de muestra de audio que se usarán para entrenar el PVC. Consulta la sección Consejos y sugerencias de la guía de producto de PVC para obtener más información sobre cómo lograr los mejores resultados con tus archivos de audio.

# Define the list of file paths explicitly
# Replace with the paths to your audio and/or video files.
# The more files you add, the better the clone will be.
sample_file_paths = [
    "/path/to/your/first_sample.mp3",
    "/path/to/your/second_sample.wav",
    "relative/path/to/another_sample.mp4"
]
samples = None
files_to_upload = []
# Use ExitStack to manage multiple open files
with ExitStack() as stack:
    for filepath in sample_file_paths:
        # Open each file and add it to the stack
        audio_file = stack.enter_context(open(filepath, "rb"))
        filename = os.path.basename(filepath)
        # Create a File object for the SDK
        files_to_upload.append(
            BytesIO(audio_file.read())
        )
    samples = elevenlabs.voices.pvc.samples.create(
        voice_id=voice.voice_id,
        files=files_to_upload # Pass the list of File objects
    )

Iniciar la separación de hablantes

Este paso intentará separar los archivos de audio en hablantes individuales. Es necesario si subes audio con varios hablantes.

sample_ids_to_check = []
for sample in samples:
    if sample.sample_id:
        print(f"Starting separation for sample: {sample.sample_id}")
        elevenlabs.voices.pvc.samples.speakers.separate(
            voice_id=voice.voice_id,
            sample_id=sample.sample_id
        )
        sample_ids_to_check.append(sample.sample_id)
while sample_ids_to_check:
    # Create a copy of the list to iterate over, so we can remove items from the original
    ids_in_batch = list(sample_ids_to_check)
    for sample_id in ids_in_batch:
        status_response = elevenlabs.voices.pvc.samples.speakers.get(
            voice_id=voice.voice_id,
            sample_id=sample_id
        )
        status = status_response.status
        print(f"Sample {sample_id} status: {status}")
        if status == "completed" or status == "failed":
            sample_ids_to_check.remove(sample_id)
    if sample_ids_to_check:
        # Wait before the next poll cycle
        time.sleep(5) # Wait for 5 seconds
print("All samples have been processed or removed from polling.")

Recuperar el audio de los hablantes

Dado que el paso anterior tardará un tiempo en completarse, el siguiente paso debe ejecutarse en un proceso independiente después de que finalice el paso anterior.

Cuando finalice la separación de hablantes, tendrás una lista de hablantes para cada muestra. En el caso de muestras con varios hablantes, tendrás que elegir el hablante que quieres usar para el PVC. Para identificarlo, puedes recuperar el audio de cada hablante y escucharlo.

# Get the list of samples from the voice created in Step 3
voice = elevenlabs.voices.get(voice_id=voice_id)
samples = voice.samples
# Loop over each sample and save the audio for each speaker to a file
speaker_audio_output_dir = "path/to/speakers/"
if not os.path.exists(speaker_audio_output_dir):
    os.makedirs(speaker_audio_output_dir)
for sample in samples:
    speaker_info = elevenlabs.voices.pvc.samples.speakers.get(
        voice_id=voice.voice_id,
        sample_id=sample.sample_id
    )
    # Proceed only if separation is actually complete
    if getattr(speaker_info, 'status', 'unknown') != "completed":
        continue
    if hasattr(speaker_info, 'speakers') and speaker_info.speakers:
        speaker_list = speaker_info.speakers
        if isinstance(speaker_info.speakers, dict):
            speaker_list = speaker_info.speakers.values()
        for speaker in speaker_list:
            audio_response = elevenlabs.voices.pvc.samples.speakers.audio.get(
                voice_id=voice.voice_id,
                sample_id=sample.sample_id,
                speaker_id=speaker.speaker_id
            )
            audio_base64 = audio_response.audio_base_64
            audio_data = base64.b64decode(audio_base64)
            output_filename = os.path.join(speaker_audio_output_dir, f"sample_{sample.sample_id}_speaker_{speaker.speaker_id}.mp3")
            with open(output_filename, "wb") as f:
                f.write(audio_data)

Actualizar muestras con ID de hablante

Una vez completada la separación de hablantes, puedes actualizar las muestras para seleccionar qué hablante quieres usar para el PVC.

elevenlabs.voices.pvc.samples.update(
    voice_id=voice.voice_id,
    sample_id=sample.sample_id,
    selected_speaker_ids=[speaker.speaker_id]
)

Verificar el PVC

Antes de iniciar el entrenamiento, se requiere un paso de verificación para garantizar que tienes permiso para usar la voz. Primero, solicita el CAPTCHA de verificación.

captcha_response = elevenlabs.voices.pvc.verification.captcha.get(voice.voice_id)
# Save captcha image to file
captcha_buffer = base64.b64decode(captcha_response)
with open('captcha.png', 'wb') as f:
    f.write(captcha_buffer)

La imagen contiene varias líneas de texto que el propietario de la voz deberá leer en voz alta y grabar. Cuando termine, envía la grabación para verificar la identidad del propietario de la voz.

elevenlabs.voices.pvc.verification.captcha.verify(
    voice_id=voice.voice_id,
    recording=open('path/to/recording.mp3', 'rb')
)

(Opcional) Solicitar verificación manual

Si no puedes verificar el CAPTCHA, puedes solicitar una verificación manual. Ten en cuenta que tardará más en procesarse.

Esto solo debe utilizarse si los pasos de verificación anteriores han fallado o no son posibles, por ejemplo, si el propietario de la voz tiene discapacidad visual.

Para obtener una lista de los archivos necesarios para la verificación manual, ponte en contacto con soporte, ya que cada caso puede ser único.

elevenlabs.voices.pvc.verification.request(
    voice_id=voice.voice_id,
    files=[open('path/to/verification/files.txt', 'rb')],
)

Entrenar el PVC

A continuación, inicia el proceso de entrenamiento. Tardará un tiempo en completarse según la duración y el número de muestras proporcionadas.

elevenlabs.voices.pvc.train(
    voice_id=voice.voice_id,
    # Specify the model the PVC should be trained on
    model_id="eleven_multilingual_v2"
)
# Poll the fine tuning status until it is complete or fails
# This example specifically checks for the eleven_multilingual_v2 model
while True:
    voice_details = elevenlabs.voices.get(voice_id=voice.voice_id)
    fine_tuning_state = None
    if voice_details.fine_tuning and voice_details.fine_tuning.state:
        fine_tuning_state = voice_details.fine_tuning.state.get("eleven_multilingual_v2")
    if fine_tuning_state:
        progress = None
        if voice_details.fine_tuning.progress and voice_details.fine_tuning.progress.get("eleven_multilingual_v2"):
            progress = voice_details.fine_tuning.progress.get("eleven_multilingual_v2")
        print(f"Fine tuning progress: {progress}")
        if fine_tuning_state == "fine_tuned" or fine_tuning_state == "failed":
            print("Fine tuning completed or failed")
            break
    # Wait for 5 seconds before polling again
    time.sleep(5)

Usar la voz recién creada

Una vez verificado el PVC, puedes usarlo igual que cualquier otra voz. Consulta la guía de inicio rápido de Texto a Voz para obtener más información sobre cómo usar una voz.

Siguientes pasos

Clonación de voz instantánea

Crea un clon de voz a partir de una breve muestra de audio sin entrenamiento.

Clonación de voz: cómo funciona

Comprende las diferencias técnicas entre IVC y PVC y cuándo elegir cada uno.