Snelstartgids voor Professional Voice Cloning

In deze handleiding leer je hoe je een Professional Voice Clone (PVC) maakt met de PVC API. Raadpleeg de producthandleiding Professional Voice Clone om via het dashboard een PVC te maken.

Voor het maken van een PVC heb je minimaal het Creator-abonnement nodig.

Lees Stemklonen: hoe het werkt voor een uitgebreide uitleg over hoe IVC en PVC onder de motorkap werken en wanneer je welke kiest.

Raadpleeg de Servicevoorwaarden en onze informatie over AI-veiligheid voor meer informatie als je niet zeker weet wat juridisch is toegestaan.

Een PVC maken via de API omvat aanzienlijk meer stappen dan een Instant Voice Clone maken. Dit komt doordat PVC’s complexer zijn en meer data en finetuning vereisen om een kloon van hoge kwaliteit te maken.

De Professional Voice Clone API gebruiken

Deze handleiding gaat ervan uit dat je je API-sleutel en SDK hebt ingesteld. Voltooi eerst de snelstartgids als je dat nog niet hebt gedaan.

Een PVC-stem maken

Maak een nieuw bestand met de naam example.py of example.mts, afhankelijk van de programmeertaal van je keuze, en voeg de volgende code toe om een PVC-stem te maken:

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

Audiobestanden uploaden

Vervolgens uploaden we de audiovoorbeeldbestanden die worden gebruikt om de PVC te trainen. Bekijk het onderdeel Tips en suggesties van de PVC-producthandleiding voor meer informatie over hoe je de beste resultaten uit je audiobestanden haalt.

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

Sprekerscheiding starten

In deze stap wordt geprobeerd de audiobestanden in afzonderlijke sprekers te scheiden. Dit is nodig als je audio met meerdere sprekers uploadt.

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.")

Audio van sprekers ophalen

Omdat de vorige stap enige tijd kost, moet je de volgende stap na voltooiing van de vorige stap in een afzonderlijk proces uitvoeren.

Zodra de sprekerscheiding is voltooid, heb je voor elk sample een lijst met sprekers. Bij samples met meerdere sprekers moet je de spreker kiezen die je voor de PVC wilt gebruiken. Om de spreker te identificeren, kun je de audio van elke spreker ophalen en beluisteren.

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

Samples bijwerken met spreker-ID's

Zodra de sprekerscheiding is voltooid, kun je de samples bijwerken om te selecteren welke spreker je voor de PVC wilt gebruiken.

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

De PVC verifiëren

Voordat de training kan beginnen, is een verificatiestap nodig om te controleren of je toestemming hebt om de stem te gebruiken. Vraag eerst de verificatie-CAPTCHA aan.

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)

De afbeelding bevat meerdere tekstregels die de stemhouder hardop moet voorlezen en opnemen. Dien de opname vervolgens in om de identiteit van de eigenaar van de stem te verifiëren.

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

(Optioneel) Handmatige verificatie aanvragen

Als je de CAPTCHA niet kunt verifiëren, kun je handmatige verificatie aanvragen. Houd er rekening mee dat de verwerking hiervan langer duurt.

Gebruik dit alleen als de vorige verificatiestappen zijn mislukt of niet mogelijk zijn, bijvoorbeeld als de stemhouder slechtziend is.

Neem contact op met support voor een lijst van de bestanden die nodig zijn voor handmatige verificatie, omdat elk geval uniek kan zijn.

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

De PVC trainen

Start vervolgens het trainingsproces. De voltooiing hiervan duurt enige tijd, afhankelijk van de lengte en het aantal aangeleverde samples.

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)

De nieuw gemaakte stem gebruiken

Zodra de PVC is geverifieerd, kun je deze op dezelfde manier gebruiken als elke andere stem. Zie de Text to Speech-snelstartgids voor meer informatie over het gebruik van een stem.

Volgende stappen

Instant voice cloning

Maak zonder training een stemkloon op basis van een kort audiosample.

Stemklonen: hoe het werkt

Begrijp de technische verschillen tussen IVC en PVC en wanneer je welke kiest.