Fast Fine-Tuning
XTTS v2
dla każdego

Czym jest XTTS v2?

XTTS v2 (Cross-lingual Text-to-Speech v2) to otwarty model syntezy mowy stworzony przez firmę Coqui TTS. Potrafi generować naturalnie brzmiący głos na podstawie krótkiej próbki audio — bez konieczności trenowania od zera.

Model obsługuje ponad 17 języków, w tym język polski. Może działać w trybie zero-shot (tylko na podstawie próbki audio, bez żadnego trenowania) lub po fine-tuningu — czyli dostrojeniu do konkretnego głosu.

To kompendium skupia się na fast fine-tuningu — czyli jak wytrenować dobry model w jak najkrótszym czasie, unikając typowych błędów.

Speaker WAV — najważniejsza rzecz w XTTS

XTTS v2 jest zaprojektowany wokół koncepcji speaker embedding — czyli matematycznej reprezentacji głosu wyodrębnionej z krótkiej próbki audio. Model nie "zapamiętuje" głosu jak człowiek — on oblicza jego "odcisk", a potem próbuje go odtworzyć.

Co to oznacza w praktyce?

Nawet bez żadnego trenowania, podając dobry plik WAV jako speaker_wav, możesz uzyskać zaskakująco dobry wynik. Dlatego zanim zaczniesz tygodniowy trening — najpierw poeksperymentuj z różnymi próbkami speaker_wav.

Zły checkpoint treningu żadne parametry inferencji nie naprawią. Ale dobry speaker_wav może sprawić, że fine-tuning w ogóle nie będzie potrzebny.

Dataset — co i jak przygotować

Na potrzeby tych badań użyliśmy datasetu studyjnego jednego polskiego lektora. Poniżej szczegółowe parametry.

Co warto wiedzieć o przygotowaniu danych

Środowisko: Google Colab T4

Wszystkie eksperymenty opisane w tym dokumencie były przeprowadzone na Google Colab z GPU Tesla T4 (16 GB VRAM). To najtańsza opcja dostępna w Colab Pro, wystarczająca do fine-tuningu XTTS v2.

Wymagane biblioteki

BASHpip install TTS
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install trainer

Sprawdzenie GPU

PYTHONimport torch
print(torch.cuda.is_available())        # True
print(torch.cuda.get_device_name(0))    # Tesla T4
print(torch.cuda.get_device_properties(0).total_memory / 1e9)  # ~15.7 GB

TF32 — stabilność bez AMP

Zamiast mixed precision (AMP), który może powodować niestabilności przy fine-tuningu TTS, używamy TF32. Daje przyspieszenie obliczeń macierzowych przy zachowaniu pełnej stabilności.

PYTHONtorch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True

Konfiguracja treningu

Poniżej pełna konfiguracja używana w eksperymentach. Każdy parametr jest wyjaśniony — żebyś wiedział co i dlaczego.

PYTHON — STAŁY CONFIGbatch_size=2              # ile próbek jednocześnie — T4 nie obsługuje więcej bezpiecznie
eval_batch_size=1
batch_group_size=8        # grupowanie próbek podobnej długości — mniej paddingu = wydajniej
num_loader_workers=4
num_eval_loader_workers=2

cudnn_benchmark=True      # optymalizacja kerneli CUDA dla powtarzalnych rozmiarów
mixed_precision=False     # AMP wyłączone — TF32 zamiast
use_grad_scaler=False     # brak skalera gradientów (zbędny bez AMP)
shuffle=False             # shuffle ręcznie przed .fit() — patrz sekcja 06

optimizer='AdamW'
optimizer_params={
    'betas': [0.9, 0.96],   # momentum i adaptacja — standardowe dla TTS
    'eps': 1e-8,
    'weight_decay': 0.01    # L2 regularyzacja — zapobiega przeuczeniu
}

save_step=1000            # zapisuj checkpoint co 1000 kroków
save_n_checkpoints=2      # zachowaj tylko 2 ostatnie — oszczędność miejsca
save_best_after=5000      # nie zapisuj "najlepszego" przed 5k — za wcześnie
epochs=1000               # duża liczba, ale zatrzymujemy ręcznie
scheduler_after_epoch=False
run_eval_steps=500        # ewaluacja co 500 kroków (~90s na T4)

Zalecane tryby treningu

Podejście sesyjne i shuffle

Ze względu na limity czasowe Google Colab, trening jest podzielony na sesje po ~1000 kroków. Kluczowe odkrycie: wznawianie treningu z losowym przetasowaniem danych nie destabilizuje modelu — a może poprawiać pokrycie fonemów.

PYTHON — PEŁNY PROTOKÓŁ SESJISESSION_SEED = int(time.time()) % 100000   # nowy seed przy każdej sesji

# Kolejność operacji PRZED .fit()

# 1. Filtr długości próbek
train_samples = [s for s in train_samples
                 if SAMPLE_DURATION_MIN <= get_duration(s) <= SAMPLE_DURATION_MAX]

# 2. Ustawienie seedów (reprodukowalność w ramach sesji)
random.seed(SESSION_SEED)
np.random.seed(SESSION_SEED)
torch.manual_seed(SESSION_SEED)
torch.cuda.manual_seed_all(SESSION_SEED)

# 3. Losowe przetasowanie próbek
random.shuffle(train_samples)

# 4. Opcjonalne okrojenie datasetu
if MAX_TARGET_WAVS > 0:
    train_samples = train_samples[:MAX_TARGET_WAVS]

# 5. Start / wznowienie treningu
trainer.fit()

Wznawianie treningu (resume)

PYTHON — WZNOWIENIE Z CHECKPOINTU# Wskaż ścieżkę do ostatniego checkpointu
trainer = Trainer(
    args,
    config,
    output_path=OUTPUT_PATH,
    model=model,
    train_samples=train_samples,
    eval_samples=eval_samples,
    restore_path="./checkpoints/checkpoint_3000.pth"  # ← tutaj checkpoint
)

Wyniki eksperymentów

Przeprowadzono trzy serie eksperymentów (sesje A, B, C) z różnymi kombinacjami learning rate i grad_clip. Wszystkie na tym samym datasecie ~50k próbek polskiego lektora.

Szczegółowe dane — Sesja C (lr=5e-6, re-shuffle co 1k)

* Eval spike przy 5000 — to artefakt losowości (trudniejsza pula eval przy nowym seedzie). MA nadal spada, model nie degraduje. Zawsze patrz na MA, nie na pojedynczy eval.

Porównanie szybkości zejścia do loss_mel_ce ~3.6

Krzywa uczenia — strefy

Trening XTTS v2 przebiega przez charakterystyczne strefy. Rozumienie ich pozwala zatrzymać trening w odpowiednim momencie — zanim model zacznie się "przeuczać".

Zasady bezwzględne

Overfitting — jak go rozpoznać

Overfitting (przeuczenie) to sytuacja, w której model tak bardzo "zapamiętał" dane treningowe, że przestał generalizować. Zamiast "mówić", zaczyna "przypominać sobie" konkretne próbki audio.

Parametry inferencji

Gdy masz gotowy checkpoint, generujesz audio przez inferencję. Trzy parametry mają największy wpływ na wynik.

PYTHON — PRZYKŁAD INFERENCJIfrom TTS.api import TTS

tts = TTS(model_path="./checkpoints/checkpoint_3000.pth",
          config_path="./config.json")

tts.tts_to_file(
    text="Szczególnie rzeczywiście trudne jest rozróżnienie dźwięków.",
    speaker_wav="./speaker_reference.wav",
    language="pl",
    file_path="output.wav",
    temperature=0.75,
    top_p=0.83,
    repetition_penalty=1.25
)

Wnioski końcowe

Optymalna recepta (potwierdzona empirycznie)

Kluczowe odkrycia