GPU•12 min czytania•Aktualizacja: 2026-11-16

Fine-tuning Orpheus TTS na RTX 3090 / 4090: własny polski głos z Unsloth

Dostrajanie Orpheus TTS 3B do polskiego głosu na jednej karcie 24 GB: przygotowanie nagrań, kodowanie SNAC, LoRA w Unsloth, generowanie mowy i wdrożenie.

1. Orpheus TTS: model językowy, który mówi

Orpheus TTS od Canopy Labs to otwarty model zamiany tekstu na mowę zbudowany na Llama 3.2 3B. Nie ma osobnego modułu akustycznego: model po prostu przewiduje kolejne tokeny, tyle że zamiast słów są to kody kodeka audio SNAC (24 kHz, mono). Dekoder SNAC zamienia je z powrotem na falę dźwiękową.

Z tego wynika najważniejsza rzecz dla fine-tuningu: trenujesz go tak samo jak zwykły LLM (LoRA, Unsloth, Hugging Face Trainer), tylko dane to pary tekst → tokeny audio. Samo podanie tekstu niczego nie nauczy, model musi zobaczyć zakodowane nagrania.

Każda ramka dźwięku to 7 tokenów z trzech poziomów SNAC (1 zgrubny, 2 średnie, 4 drobne). Przy ok. 11,7 ramki na sekundę daje to około 82 tokenów na sekundę mowy, więc 10 s nagrania to ok. 820 tokenów. To przelicznik, którego użyjesz przy ustawianiu max_seq_length i max_new_tokens.

CheckpointDo czego
canopylabs/orpheus-3b-0.1-pretrained (w Unsloth: unsloth/orpheus-3b-0.1-pretrained)Baza po 100k+ godzin angielskiej mowy. Najlepszy start dla nowego języka, np. polskiego
canopylabs/orpheus-3b-0.1-ft (unsloth/orpheus-3b-0.1-ft)Dostrojony na 8 lektorach (tara, leah, jess, leo, dan, mia, zac, zoe). Dobry do klonowania angielskiego głosu na małym zbiorze
Multilingual research release (kwiecień 2025)Pary pretrained + ft dla francuskiego, niemieckiego, koreańskiego, hindi, mandaryńskiego oraz hiszpańskiego z włoskim. Polskiego brak

Kod repozytorium jest na licencji Apache 2.0, ale wagi dziedziczą licencję Llama 3.2 Community License. Przed komercyjnym użyciem przeczytaj jej warunki.

Wskazówka: Wersja -ft ma silne „przyzwyczajenie” do angielskich lektorów. Zespół Sunbird, który dostrajał Orpheusa do 20 języków afrykańskich, celowo wystartował z wersji pretrained właśnie z tego powodu. Dla polskiego zrób tak samo.

2. RTX 3090 czy RTX 4090: ile VRAM i czasu potrzeba

Obie karty mają 24 GB VRAM i obsługują bf16, więc zmieszczą ten sam trening LoRA. Różnica to szybkość: RTX 4090 liczy wyraźnie szybciej (orientacyjnie 1,5–2x w treningu bf16), RTX 3090 jest tańszy na rynku wtórnym i w chmurze. Model 3B w bf16 zajmuje ok. 6,5 GB, resztę zjadają aktywacje, optymalizator i adaptery.

ScenariuszZużycie VRAM (orientacyjnie)Na 24 GB
LoRA 16-bit, r=64, max_seq_length 2048, batch 1ok. 12–16 GBTak, z zapasem
LoRA 16-bit, max_seq_length 4096 (nagrania do ~16 s)ok. 18–22 GBTak (tak trenował Sunbird na jednym RTX 4090)
QLoRA 4-bitok. 7–10 GBTak, ale Unsloth zaleca 16-bit dla lepszej jakości głosu
Pełny fine-tuning 3B (oficjalny train.py)grubo ponad 24 GBNie bez DeepSpeed / offloadu
Inferencja bf16 (transformers lub vLLM)14 GB min., 24 GB zalecane wg SunbirdTak

Czas: Unsloth podaje, że kilka epok na 3 godzinach nagrań zajmuje 1–2 godziny na Colabie z T4. RTX 4090 jest kilkukrotnie szybszy od T4, więc ten sam zbiór to rząd kilkunastu do kilkudziesięciu minut na epokę (szacunek, zależy od długości próbek).

Nie masz karty? RTX 4090 wynajmiesz na godziny w chmurze GPU, a cały trening z przygotowaniem danych zamyka się zwykle w kilku dolarach. Sposób uruchomienia poda opisuje poradnik RunPod od zera.

Wskazówka: Wartości VRAM w tabeli to szacunki dla Unsloth z gradient checkpointingiem. Dokładne zużycie zależy od najdłuższej próbki w zbiorze, bo to ona wyznacza szczyt pamięci. Jeśli dostajesz CUDA out of memory, najpierw obetnij najdłuższe nagrania.

3. Dane: nagrania i transkrypcje po polsku

Jakość głosu po fine-tuningu zależy przede wszystkim od nagrań. Canopy Labs pisze, że pierwsze sensowne efekty widać już po ok. 50 przykładach, a do najlepszych wyników potrzeba 300 przykładów na mówcę. Dotyczy to jednak angielskiego, którego model już umie. Dla nowego języka, jak polski, model musi się nauczyć wymowy od zera, więc licz raczej na kilka do kilkunastu godzin mowy (nasz szacunek; społecznościowy polski fine-tune VoxPolska użył ponad 24 tys. par tekst–audio).

Zasady, które oszczędzą Ci kilku nieudanych treningów:

  1. Długość próbek 3–15 s. Model gorzej trzyma jakość powyżej ok. 10 s, a jedna próbka nie może przekroczyć max_seq_length (2048 tokenów to ok. 23 s razem z tekstem).
  2. Czyste nagranie. Jeden mikrofon, bez muzyki i pogłosu, stała głośność. Usuń długie pauzy na początku i końcu.
  3. Naturalna mowa, nie syntetyczna. Canopy Labs wprost odradza trenowanie na wyjściu innych TTS, bo pogarsza to wyniki.
  4. Tekst pisany tak, jak jest czytany. Liczby, skróty i daty zamień na słowa: „2026” na „dwa tysiące dwudziesty szósty”, „np.” na „na przykład”. Model czyta dokładnie to, co dostanie.
  5. Emocje jako tagi. Jeśli w nagraniu jest śmiech albo westchnienie, wpisz w transkrypcji <laugh> lub <sigh> w tym samym miejscu. Model nauczy się tylko tych tagów, które widział w danych.

Masz długie nagrania bez transkrypcji? Potnij je na zdania i przepisz modelem Whisper large-v3 (dobrze radzi sobie z polskim), a potem przejrzyj tekst ręcznie. Błędy transkrypcji model wiernie powtórzy.

Docelowa struktura katalogu:

/workspace/dane/
├── wavs/
│   ├── 0001.wav
│   ├── 0002.wav
│   └── ...
└── metadata.csv

Plik metadata.csv ma jedną linię na nagranie, separator |:

0001.wav|Dzień dobry, nazywam się Ania i dziś opowiem o chmurach obliczeniowych.
0002.wav|To było naprawdę zabawne <laugh> nie spodziewałam się tego.

Wszystkie pliki przekonwertuj do 24 kHz, mono, WAV, bo w takim formacie pracuje kodek SNAC:

mkdir -p wavs24
for f in wavs/*.wav; do
  ffmpeg -loglevel error -y -i "$f" -ac 1 -ar 24000 "wavs24/$(basename "$f")"
done
Wskazówka: Głos to dane osobowe. Trenuj tylko na nagraniach własnych albo osób, które wyraziły na to wyraźną zgodę, i nie podszywaj się sklonowanym głosem pod innych. Wagi Orpheusa mają też wbudowany znak wodny (Silent Cipher) w oficjalnym pakiecie inferencji.

4. Środowisko: Linux lub WSL2, Python i Unsloth

Unsloth działa najpewniej na Linuksie. Na Windowsie użyj WSL2 z Ubuntu i sterownikiem NVIDIA zainstalowanym po stronie Windowsa. W chmurze wybierz obraz PyTorch z CUDA 12.x (np. szablon PyTorch w RunPod).

python3 -m venv ~/orpheus && source ~/orpheus/bin/activate
pip install --upgrade pip
pip install unsloth snac soundfile "datasets>=3.4.1,<4.0.0"
nvidia-smi   # sprawdź, czy widać kartę i 24 GB pamięci

Ograniczenie wersji datasets pochodzi z oficjalnej instrukcji modelu Sunbird: nowsze wersje zmieniły dekodowanie audio. Unsloth sam dobiera zgodne wersje transformers i trl, więc nie aktualizuj ich ręcznie w tym środowisku.

Wskazówka: Jeśli później chcesz serwować model przez vLLM, zrób na niego osobne środowisko wirtualne. vLLM i Unsloth przypinają różne wersje bibliotek i w jednym venv potrafią się nawzajem psuć.

5. Zamiana nagrań na tokeny SNAC

Ten krok jest sercem całego procesu i właśnie jego brakuje w wielu skróconych tutorialach. Skrypt koduje każde nagranie kodekiem SNAC, układa 7 kodów ramki z odpowiednimi przesunięciami (każda pozycja ma własny zakres 4096 tokenów od ID 128266) i skleja wszystko w sekwencję treningową:

[START_OF_HUMAN] ania: tekst [END_OF_TEXT] [END_OF_HUMAN]
[START_OF_AI] [START_OF_SPEECH] ...tokeny audio... [END_OF_SPEECH] [END_OF_AI]

Zapisz poniższy kod jako prepare_dataset.py i uruchom go raz. Przetworzenie tysiąca nagrań zajmuje na GPU ok. minutę:

Wskazówka: Prefiks „ania:” to nazwa głosu. W zbiorze z kilkoma mówcami nadaj każdemu inną nazwę (kolumna z mówcą w metadata.csv) i użyj tej samej nazwy w prompcie przy generowaniu.
prepare_dataset.py
import csv
import soundfile as sf
import torch
from datasets import Dataset
from snac import SNAC
from transformers import AutoTokenizer

MODEL = "unsloth/orpheus-3b-0.1-pretrained"
SPEAKER = "ania"                 # nazwa głosu, później podajesz ją w prompcie
DATA_DIR = "/workspace/dane"     # wavs/ + metadata.csv
MAX_LEN = 2048                   # musi się zgadzać z max_seq_length w treningu

# Tokeny specjalne Orpheusa (Llama 3.2 + 7 x 4096 kodów SNAC)
SOH, EOH, SOA, EOA = 128259, 128260, 128261, 128262
SOS, EOS, EOT = 128257, 128258, 128009
AUDIO = 128266

tokenizer = AutoTokenizer.from_pretrained(MODEL)
snac = SNAC.from_pretrained("hubertsiuzdak/snac_24khz").eval().to("cuda")


def encode_audio(path):
    data, sr = sf.read(path, dtype="float32", always_2d=True)
    assert sr == 24000, f"{path}: {sr} Hz, przekonwertuj do 24 kHz"
    wav = torch.from_numpy(data.mean(axis=1)).view(1, 1, -1).to("cuda")  # mono
    with torch.inference_mode():
        c = snac.encode(wav)  # 3 poziomy: 1, 2 i 4 kody na ramkę
    tokens, prev = [], None
    for i in range(c[0].shape[1]):
        frame = [
            c[0][0][i].item(),
            c[1][0][2 * i].item() + 4096,
            c[2][0][4 * i].item() + 2 * 4096,
            c[2][0][4 * i + 1].item() + 3 * 4096,
            c[1][0][2 * i + 1].item() + 4 * 4096,
            c[2][0][4 * i + 2].item() + 5 * 4096,
            c[2][0][4 * i + 3].item() + 6 * 4096,
        ]
        if frame == prev:  # identyczna ramka pod rząd (np. cyfrowa cisza)
            continue
        prev = frame
        tokens.extend(t + AUDIO for t in frame)
    return tokens


rows, skipped = [], 0
with open(f"{DATA_DIR}/metadata.csv", encoding="utf-8") as f:
    for file_name, text in csv.reader(f, delimiter="|"):
        text_ids = tokenizer.encode(f"{SPEAKER}: {text.strip()}", add_special_tokens=True) + [EOT]
        audio_ids = encode_audio(f"{DATA_DIR}/wavs/{file_name}")
        ids = [SOH] + text_ids + [EOH, SOA, SOS] + audio_ids + [EOS, EOA]
        if len(ids) > MAX_LEN:
            skipped += 1
            continue
        rows.append({"input_ids": ids, "labels": ids, "attention_mask": [1] * len(ids)})

print(f"Próbek: {len(rows)}, pominięte (za długie): {skipped}")
Dataset.from_list(rows).save_to_disk("/workspace/orpheus_ds")

6. Trening LoRA w Unsloth

Ustawienia poniżej to konfiguracja, którą stosują Unsloth i Sunbird: LoRA 16-bit (nie 4-bit), r=64, wszystkie warstwy attention i MLP, learning rate 2e-4, optymalizator adamw_8bit, efektywny batch 4. Zapisz jako train.py:

train.py
from unsloth import FastLanguageModel, is_bfloat16_supported
from datasets import load_from_disk
from transformers import Trainer, TrainingArguments

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/orpheus-3b-0.1-pretrained",
    max_seq_length=2048,
    dtype=None,           # auto: bf16 na RTX 3090 i 4090
    load_in_4bit=False,   # LoRA 16-bit; True tylko przy braku VRAM
)

model = FastLanguageModel.get_peft_model(
    model,
    r=64,
    lora_alpha=64,
    lora_dropout=0,
    bias="none",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

ds = load_from_disk("/workspace/orpheus_ds").train_test_split(test_size=0.03, seed=3407)

trainer = Trainer(
    model=model,
    train_dataset=ds["train"],
    eval_dataset=ds["test"],
    args=TrainingArguments(
        output_dir="/workspace/outputs",
        per_device_train_batch_size=1,
        per_device_eval_batch_size=1,
        gradient_accumulation_steps=4,
        num_train_epochs=2,
        learning_rate=2e-4,
        warmup_steps=20,
        lr_scheduler_type="linear",
        optim="adamw_8bit",
        weight_decay=0.01,
        logging_steps=10,
        eval_strategy="steps",
        eval_steps=200,
        save_steps=200,
        save_total_limit=3,
        bf16=is_bfloat16_supported(),
        fp16=not is_bfloat16_supported(),
        seed=3407,
        report_to="none",
    ),
)
trainer.train()

model.save_pretrained("/workspace/orpheus-lora")        # sam adapter (~kilkaset MB)
tokenizer.save_pretrained("/workspace/orpheus-lora")
model.save_pretrained_merged("/workspace/orpheus-pl-merged", tokenizer,
                             save_method="merged_16bit")  # pełny model do vLLM

7. Jak dobrać epoki i co obserwować

ParametrMały zbiór (300–1000 próbek, jeden głos)Nowy język (kilka godzin i więcej)
Model bazowyorpheus-3b-0.1-ft (angielski) lub pretrained (polski)orpheus-3b-0.1-pretrained
Epoki1–22–3
Learning rate1e-4 – 2e-42e-4
r / alpha32 / 32 lub 64 / 6464 / 64
max_seq_length20482048 (4096 przy nagraniach do 16 s)

Uruchom trening w tle, żeby nie przerwał go zamknięty terminal:

nohup python train.py > train.log 2>&1 &
tail -f train.log

Patrz na eval_loss, nie tylko na training loss. Gdy eval_loss przestaje spadać, a training loss dalej leci w dół, model zaczyna uczyć się nagrań na pamięć: brzmi świetnie na zdaniach ze zbioru i źle na nowych. Wtedy weź checkpoint z najniższym eval_loss z katalogu /workspace/outputs.

Najlepszy test to odsłuch. Co kilkaset kroków wygeneruj te same 3–4 zdania, których nie ma w danych treningowych (z liczbami, pytaniem i dłuższym zdaniem złożonym), i porównaj.

Wskazówka: Na RTX 3090 trening idzie wolniej, ale zużycie pamięci jest takie samo. Jeśli 3090 grzeje się do throttlingu, ogranicz moc poleceniem sudo nvidia-smi -pl 300: trening zwolni o kilka procent, a karta będzie znacznie chłodniejsza.

8. Generowanie mowy z dostrojonego modelu

Po treningu wygeneruj próbkę. Skrypt buduje prompt w tym samym formacie co w danych, odcina wszystko przed ostatnim START_OF_SPEECH, cofa przesunięcia kodów i dekoduje je SNAC-iem do pliku WAV 24 kHz:

Wskazówka: Parametry z oficjalnych instrukcji: repetition_penalty co najmniej 1.1 (inaczej model się zapętla), top_p nie niżej niż 0.9 (niżej głos robi się robotyczny). Wyższe temperature i repetition_penalty sprawiają, że model mówi szybciej.
infer.py
import soundfile as sf
import torch
from snac import SNAC
from unsloth import FastLanguageModel

SOH, EOH, SOS, EOS, EOT, AUDIO = 128259, 128260, 128257, 128258, 128009, 128266

model, tokenizer = FastLanguageModel.from_pretrained(
    "/workspace/orpheus-pl-merged", max_seq_length=2048, load_in_4bit=False)
FastLanguageModel.for_inference(model)
snac = SNAC.from_pretrained("hubertsiuzdak/snac_24khz").eval()  # dekoder na CPU


def speak(text, speaker="ania", out="test.wav"):
    prompt = [SOH] + tokenizer.encode(f"{speaker}: {text}", add_special_tokens=True) + [EOT, EOH]
    input_ids = torch.tensor([prompt], device="cuda")
    gen = model.generate(
        input_ids=input_ids,
        attention_mask=torch.ones_like(input_ids),
        max_new_tokens=1200,       # ok. 14 s mowy
        do_sample=True,
        temperature=0.6,
        top_p=0.95,
        repetition_penalty=1.1,    # poniżej 1.1 model się zapętla
        eos_token_id=EOS,
    )[0].tolist()[len(prompt):]

    if SOS in gen:  # zostaw tylko to, co po ostatnim START_OF_SPEECH
        gen = gen[len(gen) - gen[::-1].index(SOS):]
    codes = [t - AUDIO for t in gen if AUDIO <= t < AUDIO + 7 * 4096]
    codes = codes[: len(codes) // 7 * 7]

    l1, l2, l3 = [], [], []
    for i in range(0, len(codes), 7):
        f = codes[i:i + 7]
        l1.append(f[0])
        l2 += [f[1] - 4096, f[4] - 4 * 4096]
        l3 += [f[2] - 2 * 4096, f[3] - 3 * 4096, f[5] - 5 * 4096, f[6] - 6 * 4096]

    with torch.inference_mode():
        audio = snac.decode([torch.tensor([l]) for l in (l1, l2, l3)])
    sf.write(out, audio.squeeze().numpy(), 24000)


speak("Cześć, to mój własny głos wygenerowany przez dostrojony model Orpheus.")

9. Zapis, scalanie i wdrożenie (vLLM, GGUF)

Skrypt treningowy zapisuje dwie wersje:

  • /workspace/orpheus-lora to sam adapter LoRA (kilkaset MB). Wygodny do archiwizacji i dalszego dotrenowania.
  • /workspace/orpheus-pl-merged to pełny model 16-bit po scaleniu adaptera z bazą (ok. 6,5 GB). Ten wrzucasz do vLLM lub na Hugging Face.

Najprostsze produkcyjne serwowanie to vLLM w osobnym środowisku. Ten sam format promptu, tylko z stop_token_ids=[128258] i skip_special_tokens=False w SamplingParams, a dekodowanie tokenów do audio bez zmian:

python3 -m venv ~/orpheus-serve && source ~/orpheus-serve/bin/activate
pip install vllm snac soundfile

Oficjalny pakiet orpheus-speech (pip install orpheus-speech) daje streaming z opóźnieniem ok. 200 ms. Możesz w nim wskazać własny scalony model zamiast canopylabs/orpheus-tts-0.1-finetune-prod.

Unsloth pozwala też wyeksportować model do GGUF dla llama.cpp. To dobra droga do uruchamiania bez dużej karty, ale dekoder SNAC i tak musisz dołożyć sam.

10. Typowe problemy i rozwiązania

ObjawPrzyczynaRozwiązanie
Model mówi po polsku z angielskim akcentemZa mało polskich danych albo start z wersji -ftStart z pretrained, więcej godzin nagrań, 1 epoka więcej
Generuje szum albo ciszęBłąd w kolejności kodów SNAC lub zła częstotliwość próbkowaniaSprawdź 24 kHz mono i identyczną kolejność 7 kodów w przygotowaniu i dekodowaniu
Zapętla słowa, nie kończy zdaniaZa niski repetition_penalty, przeuczenierepetition_penalty 1.1–1.3, wcześniejszy checkpoint
Ucina dłuższe tekstymax_new_tokens 1200 to ok. 14 s mowyDziel tekst na zdania i generuj po kolei
Źle czyta liczby i skrótyW danych były cyfry zamiast słówNormalizuj tekst w zbiorze i na wejściu (liczby słownie)
CUDA out of memoryNajdłuższa próbka za długaObetnij nagrania powyżej ~15 s albo zmniejsz max_seq_length
ValueError przy snac.decodeWygenerowany token poza zakresem pozycji w ramceOdrzuć niepełne ramki (kod robi to przez obcięcie do wielokrotności 7) i zwiększ repetition_penalty

11. Źródła i dalsza lektura

Szerzej o samej technice LoRA i doborze modelu bazowego piszemy w poradniku Fine-tuning Llama 3 i Qwen z Unsloth.

Często zadawane pytania (FAQ)

Czy Orpheus TTS mówi po polsku bez fine-tuningu?

Nie. Oficjalne modele obsługują angielski, a wydanie wielojęzyczne dodaje francuski, niemiecki, koreański, hindi, mandaryński oraz hiszpański z włoskim. Polski trzeba dotrenować na własnych nagraniach albo skorzystać z modelu społeczności, np. VoxPolska.

Ile nagrań potrzebuję, żeby sklonować swój głos?

Dla angielskiego Canopy Labs podaje, że efekty widać po ok. 50 przykładach, a najlepsze wyniki daje 300 na mówcę. Dla polskiego model musi się nauczyć języka, więc potrzeba więcej: realnie kilka godzin czystej mowy w próbkach po 3–15 sekund.

Czy RTX 3090 wystarczy do fine-tuningu Orpheus 3B?

Tak. RTX 3090 ma te same 24 GB VRAM co RTX 4090 i obsługuje bf16, więc trening LoRA 16-bit z max_seq_length 2048 mieści się z zapasem. Różnica to czas: RTX 4090 trenuje orientacyjnie 1,5–2 razy szybciej.

Lepiej trenować LoRA czy pełny fine-tuning?

Na jednej karcie 24 GB wybierz LoRA 16-bit w Unsloth. Oficjalny skrypt Canopy Labs robi pełny fine-tuning bez LoRA, a pełny trening modelu 3B nie mieści się w 24 GB bez DeepSpeed albo offloadu. Unsloth zaleca też LoRA 16-bit zamiast QLoRA 4-bit dla lepszej jakości głosu.

Czy mogę używać dostrojonego modelu komercyjnie?

Kod Orpheusa jest na licencji Apache 2.0, ale wagi pochodzą od Llama 3.2 i obowiązuje dla nich Llama 3.2 Community License. Dodatkowo musisz mieć prawa do nagrań i zgodę osoby, której głos trenujesz.