> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Szybki start z Professional Voice Cloning

Ten przewodnik pokaże ci, jak stworzyć profesjonalny klon głosu (PVC) za pomocą API PVC. Aby stworzyć PVC w panelu, zobacz przewodnik po produkcie [Professional Voice Clone](/docs/pl/eleven-creative/voices/voice-cloning/professional-voice-cloning).

> **Info**
>
> Utworzenie PVC wymaga planu [Creator lub wyższego](https://elevenlabs.io/pricing).

Szczegółowe wyjaśnienie działania IVC i PVC oraz wskazówki, kiedy wybrać które rozwiązanie, znajdziesz w [Klonowanie głosu: jak działa](/docs/pl/eleven-api/concepts/voice-cloning).

> **Warning**
>
> Jeśli nie masz pewności, co jest dozwolone z prawnego punktu widzenia, zapoznaj się z [Warunkami korzystania](https://elevenlabs.io/terms-of-use) oraz informacjami o [bezpieczeństwie AI ](https://elevenlabs.io/safety).

Tworzenie PVC przez API wymaga znacznie więcej kroków niż stworzenie Instant Voice Clone. PVC są bardziej złożone i potrzebują więcej danych oraz dostrajania, by powstał klon wysokiej jakości.

## Korzystanie z API Professional Voice Clone

> **Note**
>
> Ten przewodnik zakłada, że [skonfigurowałeś klucz API i SDK](/docs/pl/eleven-api/quickstart). Jeśli jeszcze tego nie zrobiłeś, najpierw przejdź przez quickstart.

#### Utwórz głos PVC

Utwórz nowy plik o nazwie `example.py` lub `example.mts`, zależnie od wybranego języka, i dodaj poniższy kod, aby utworzyć głos PVC:

```python maxLines=0
# 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)
```

```typescript maxLines=0
// example.mts
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";
import fs from "node:fs";

const elevenlabs = new ElevenLabsClient();

const voice = await elevenlabs.voices.pvc.create({
    name: "My Professional Voice Clone",
    language: "en",
    description: "A professional voice clone of my voice",
});

console.log(voice.voiceId);
```

#### Prześlij pliki audio

Teraz prześlemy pliki z próbkami audio, które posłużą do trenowania PVC. Więcej informacji o tym, jak uzyskać najlepsze wyniki z plików audio, znajdziesz w sekcji [Wskazówki i sugestie](/docs/pl/eleven-creative/voices/voice-cloning/professional-voice-cloning#tips-and-suggestions) przewodnika po PVC.

```python maxLines=0
# 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
    )
```

```typescript
const samples = await elevenlabs.voices.pvc.samples.create(voice.voiceId, {
    // Replace with the paths to your audio and/or video files.
    // The more files you add, the better the clone will be.
    files: [fs.createReadStream("/path/to/your/audio/file.mp3")],
})
```

#### Rozpocznij rozdzielanie mówców

Ten krok spróbuje rozdzielić pliki audio na poszczególnych mówców. Jest wymagany, jeśli przesyłasz audio z wieloma mówcami.

```python maxLines=0
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.")
```

```typescript maxLines=0
// Trigger the speaker separation action, this will take some time to complete
for (const sample of samples) {
    if (sample.sampleId) {
        await elevenlabs.voices.pvc.samples.speakers.separate(voiceId, sample.sampleId);
    }
}

// Check the status of the speaker separation action
const ids = samples.map((sample) => sample.sampleId);
const interval = setInterval(async () => {
    // Poll the status of the speaker separation action
    for (const id of ids) {
        if (!id) continue;

        const { status } = await elevenlabs.voices.pvc.samples.speakers.get(voice.voiceId, id);
        console.log(`Sample ${id} status: ${status}`);
        if (status === "completed" || status === "failed") {
            ids.splice(ids.indexOf(id), 1);
        }

        if (ids.length === 0) {
            clearInterval(interval);
            console.log("All samples have been processed or removed from polling");
        }
    }
}, 5000);
```

#### Pobierz audio mówców

> **Warning**
>
> Ponieważ wykonanie poprzedniego kroku zajmie trochę czasu, kolejny krok uruchom w osobnym procesie po jego zakończeniu.

Po zakończeniu rozdzielania mówców otrzymasz listę mówców dla każdej próbki. W przypadku próbek z wieloma mówcami musisz wybrać mówcę, którego chcesz użyć w PVC. Aby go zidentyfikować, możesz pobrać audio każdego mówcy i je odsłuchać.

```python maxLines=0
# 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)
```

```typescript maxLines=0
// Get the list of samples from the voice created in Step 3
const { samples } = await elevenlabs.voices.get(voiceId);

// After separation is completed, get the list of speakers and their audio
if (samples) {
    for (const sample of samples) {
        if (!sample.sampleId) continue;

        const { speakers } = await elevenlabs.voices.pvc.samples.speakers.get(voiceId, sample.sampleId)

        if (speakers) {
            for (const speaker of Object.values(speakers)) {
                if (!speaker || !speaker.speakerId) continue;
                const { audioBase64 } = await elevenlabs.voices.pvc.samples.speakers.audio.get(voiceId, sample.sampleId, speaker.speakerId);
                const audioBuffer = Buffer.from(audioBase64, 'base64');

                // Write the audio to a file
                // Note which speaker ID you wish to use for the PVC
                fs.writeFileSync(`path/to/speakers/sample_${sample.sampleId}_speaker_${speaker.speakerId}.mp3`, audioBuffer);
            }
        }
    }
}
```

#### Zaktualizuj próbki o identyfikatory mówców

Po zakończeniu rozdzielania mówców możesz zaktualizować próbki, aby wybrać mówcę, którego chcesz użyć w PVC.

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

```typescript
await elevenlabs.voices.pvc.samples.update(voice.voiceId, sample.sampleId, {
    selectedSpeakerIds: [speaker.speakerId],
})
```

Powtórz ten proces dla każdej próbki z wieloma mówcami.

#### Zweryfikuj PVC

Zanim rozpocznie się trening, wymagany jest etap weryfikacji, aby potwierdzić, że masz zgodę na użycie głosu. Najpierw poproś o CAPTCHA weryfikacyjne.

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

```typescript
const captchaResponse = await elevenlabs.voices.pvc.verification.captcha.get(voice.voiceId);

// Save captcha image to file
const captchaBuffer = Buffer.from(captchaResponse, 'base64');
fs.writeFileSync('path/to/captcha.png', captchaBuffer);
```

Obraz zawiera kilka linii tekstu, które właściciel głosu musi przeczytać na głos i nagrać. Gdy to zrobi, prześlij nagranie, aby zweryfikować tożsamość właściciela głosu.

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

```typescript
await elevenlabs.voices.pvc.verification.captcha.verify(voice.voiceId, {
	recording: fs.createReadStream("/path/to/recording.mp3"),
})
```

#### (Opcjonalnie) Poproś o ręczną weryfikację

Jeśli nie możesz zweryfikować CAPTCHA, możesz poprosić o ręczną weryfikację. Pamiętaj, że jej przetworzenie potrwa dłużej.

Użyj tej opcji tylko wtedy, gdy poprzednie kroki weryfikacji nie powiodły się lub nie są możliwe, na przykład gdy właściciel głosu ma wadę wzroku.

Aby uzyskać listę plików wymaganych do ręcznej weryfikacji, skontaktuj się z pomocą techniczną, ponieważ każdy przypadek może być inny.

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

```typescript
await elevenlabs.voices.pvc.verification.request(voice.voiceId, {
    files: [fs.createReadStream("/path/to/verification/files.txt")],
});
```

#### Trenuj PVC

Następnie rozpocznij trening. Jego ukończenie zajmie trochę czasu, zależnie od długości i liczby dostarczonych próbek.

```python maxLines=0
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)
```

```typescript maxLines=0
await elevenlabs.voices.pvc.train(voiceId, {
    // Specify the model the PVC should be trained on
    modelId: "eleven_multilingual_v2",
});

// Poll the fine tuning status until it is complete or fails
// This example specifically checks for the eleven_multilingual_v2 model
const interval = setInterval(async () => {
    const { fineTuning } = await elevenlabs.voices.get(voiceId);
    if (!fineTuning) return;

    console.log(`Fine tuning progress: ${fineTuning?.progress?.eleven_multilingual_v2}`);

    if (fineTuning?.state?.eleven_multilingual_v2 === "fine_tuned" || fineTuning?.state?.eleven_multilingual_v2 === "failed") {
        clearInterval(interval);
        console.log("Fine tuning completed or failed");
    }
}, 5000);
```

#### Użyj nowo utworzonego głosu

Po zweryfikowaniu PVC możesz używać go tak samo jak każdego innego głosu. Więcej informacji o używaniu głosu znajdziesz w [quickstarcie Text to Speech](/docs/pl/eleven-api/quickstart).

## Kolejne kroki

#### [Natychmiastowe klonowanie głosu](/docs/pl/eleven-api/guides/how-to/voices/instant-voice-cloning)

Stwórz klon głosu z krótkiej próbki audio bez treningu.

#### [Klonowanie głosu: jak działa](/docs/pl/eleven-api/concepts/voice-cloning)

Poznaj techniczne różnice między IVC i PVC oraz dowiedz się, kiedy wybrać które rozwiązanie.