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.
| Checkpoint | Do 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.
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.
| Scenariusz | Zużycie VRAM (orientacyjnie) | Na 24 GB |
|---|---|---|
| LoRA 16-bit, r=64, max_seq_length 2048, batch 1 | ok. 12–16 GB | Tak, z zapasem |
| LoRA 16-bit, max_seq_length 4096 (nagrania do ~16 s) | ok. 18–22 GB | Tak (tak trenował Sunbird na jednym RTX 4090) |
| QLoRA 4-bit | ok. 7–10 GB | Tak, ale Unsloth zaleca 16-bit dla lepszej jakości głosu |
Pełny fine-tuning 3B (oficjalny train.py) | grubo ponad 24 GB | Nie bez DeepSpeed / offloadu |
| Inferencja bf16 (transformers lub vLLM) | 14 GB min., 24 GB zalecane wg Sunbird | Tak |
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.
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:
- 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). - Czyste nagranie. Jeden mikrofon, bez muzyki i pogłosu, stała głośność. Usuń długie pauzy na początku i końcu.
- Naturalna mowa, nie syntetyczna. Canopy Labs wprost odradza trenowanie na wyjściu innych TTS, bo pogarsza to wyniki.
- 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.
- 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.csvPlik 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")"
done4. Ś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ęciOgraniczenie 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.
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ę:
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:
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 vLLM7. Jak dobrać epoki i co obserwować
| Parametr | Mały zbiór (300–1000 próbek, jeden głos) | Nowy język (kilka godzin i więcej) |
|---|---|---|
| Model bazowy | orpheus-3b-0.1-ft (angielski) lub pretrained (polski) | orpheus-3b-0.1-pretrained |
| Epoki | 1–2 | 2–3 |
| Learning rate | 1e-4 – 2e-4 | 2e-4 |
| r / alpha | 32 / 32 lub 64 / 64 | 64 / 64 |
| max_seq_length | 2048 | 2048 (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.logPatrz 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.
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:
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-lorato sam adapter LoRA (kilkaset MB). Wygodny do archiwizacji i dalszego dotrenowania./workspace/orpheus-pl-mergedto 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 soundfileOficjalny 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
| Objaw | Przyczyna | Rozwiązanie |
|---|---|---|
| Model mówi po polsku z angielskim akcentem | Za mało polskich danych albo start z wersji -ft | Start 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óbkowania | Sprawdź 24 kHz mono i identyczną kolejność 7 kodów w przygotowaniu i dekodowaniu |
| Zapętla słowa, nie kończy zdania | Za niski repetition_penalty, przeuczenie | repetition_penalty 1.1–1.3, wcześniejszy checkpoint |
| Ucina dłuższe teksty | max_new_tokens 1200 to ok. 14 s mowy | Dziel tekst na zdania i generuj po kolei |
| Źle czyta liczby i skróty | W danych były cyfry zamiast słów | Normalizuj tekst w zbiorze i na wejściu (liczby słownie) |
| CUDA out of memory | Najdłuższa próbka za długa | Obetnij nagrania powyżej ~15 s albo zmniejsz max_seq_length |
| ValueError przy snac.decode | Wygenerowany token poza zakresem pozycji w ramce | Odrzuć 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
- Oficjalne repozytorium Orpheus TTS (Canopy Labs): modele, skrypt pełnego fine-tuningu, pakiet
orpheus-speech. - Unsloth: fine-tuning modeli TTS oraz notatnik Orpheus (3B) w repozytorium unslothai/notebooks.
- Sunbird orpheus-3b-tts-multilingual: pełna konfiguracja treningu LoRA na jednym RTX 4090 i kod dekodowania.
- Kolekcja multilingual research release: checkpointy dla 7 języków.
- VoxPolska (salihfurkaan) na Hugging Face: społecznościowy polski fine-tune Orpheusa (LoRA, ponad 24 tys. par). Przed użyciem sprawdź licencję i opis zbioru.
Szerzej o samej technice LoRA i doborze modelu bazowego piszemy w poradniku Fine-tuning Llama 3 i Qwen z Unsloth.