🔊Text-zu-Sprache (TTS) Finetuning-Anleitung

Lerne, wie man TTS- & STT-Stimmenmodelle mit Unsloth finetunt.

Das Feinabstimmen von TTS-Modellen ermöglicht es ihnen, sich an Ihren spezifischen Datensatz, Anwendungsfall oder gewünschten Stil und Ton anzupassen. Ziel ist es, diese Modelle zu individualisieren, Stimmen zu klonen, Sprechstile und -töne anzupassen, neue Sprachen zu unterstützen, spezifische Aufgaben zu bewältigen und mehr. Wir unterstützen auch Speech-to-Text (STT) Modelle wie OpenAIs Whisper.

Mit Unslothkönnen Sie feinabstimmen jedes TTS-Modell (transformers kompatibel) 1,5x schneller mit 50 % weniger Speicher als andere Implementierungen mit Flash Attention 2.

⭐ Unsloth unterstützt jedes transformers kompatible TTS-Modell. Selbst wenn wir noch kein Notebook oder Upload dafür haben, wird es trotzdem unterstützt, z. B. versuchen Sie, Dia-TTS oder Moshi feinzuabstimmen.

Zero-Shot-Klonen erfasst den Ton, verfehlt aber oft das Tempo und den Ausdruck und klingt häufig robotisch und unnatürlich. Feinabstimmung liefert deutlich genauere und realistischere Stimmreplikationen. Lesen Sie hier mehr.

Notebooks zur Feinabstimmung:

Wir haben auch TTS-Modelle (original und quantisiert) auf unsere Hugging Face-Seite.

Sesame-CSM (1B)	Orpheus-TTS (3B)	Whisper Large V3 (STT)
Spark-TTS (0.5B)	Llasa-TTS (1B)	Oute-TTS (1B)

Wenn Sie feststellen, dass die Ausgabedauer ein Maximum von 10 Sekunden erreicht, erhöhen Siemax_new_tokens = 125 von seinem Standardwert 125. Da 125 Tokens ungefähr 10 Sekunden Audio entsprechen, müssen Sie einen höheren Wert einstellen, um längere Ausgaben zu erhalten.

Auswahl und Laden eines TTS-Modells

Für TTS werden oft kleinere Modelle bevorzugt, da sie geringere Latenz und schnellere Inferenz für Endnutzer bieten. Das Feinabstimmen eines Modells mit unter 3B Parametern ist oft ideal, und unsere Hauptbeispiele verwenden Sesame-CSM (1B) und Orpheus-TTS (3B), ein auf Llama basierendes Sprachmodell.

Details zu Sesame-CSM (1B)

CSM-1B ist ein Basismodell, während Orpheus-ft auf 8 professionellen Synchronsprechern feinabgestimmt ist, wodurch die Stimmkonsistenz der zentrale Unterschied ist. CSM benötigt Audiokontext für jeden Sprecher, um gut zu funktionieren, während Orpheus-ft diese Konsistenz eingebaut hat.

Feinabstimmung von einem Basismodell wie CSM erfordert im Allgemeinen mehr Rechenressourcen, während der Start von einem feinabgestimmten Modell wie Orpheus-ft bessere Ergebnisse sofort bietet.

Um CSM zu unterstützen, haben wir neue Sampling-Optionen und ein Beispiel hinzugefügt, das zeigt, wie man Audiokontext für verbesserte Stimmkonsistenz verwendet.

Details zu Orpheus-TTS (3B)

Orpheus ist auf einem großen Sprachkorpus vortrainiert und eignet sich hervorragend zur Erzeugung realistischer Sprache mit integriertem Support für emotionale Hinweise wie Lachen und Seufzer. Seine Architektur macht es zu einem der einfachsten TTS-Modelle in Nutzung und Training, da es über llama.cpp exportiert werden kann und somit eine hervorragende Kompatibilität über alle Inferenz-Engines bietet. Für nicht unterstützte Modelle können Sie nur den LoRA-Adapter als safetensors speichern.

Laden der Modelle

Da Stimmmodelle in der Regel klein sind, können Sie die Modelle mit LoRA 16-Bit oder vollständiger Feinabstimmung (FFT) trainieren, was möglicherweise qualitativ höhere Ergebnisse liefert. Um es in LoRA 16-Bit zu laden:

from unsloth import FastModel

model_name = "unsloth/orpheus-3b-0.1-pretrained"
model, tokenizer = FastModel.from_pretrained(
    model_name,
    load_in_4bit=False  # use 4-bit precision (QLoRA)
)

Wenn dies ausgeführt wird, lädt Unsloth die Modellgewichte herunter. Wenn Sie 8-Bit bevorzugen, könnten Sie load_in_8bit = Trueverwenden, oder für vollständige Feinabstimmung setzen Sie full_finetuning = True (stellen Sie sicher, dass Sie genug VRAM haben). Sie können den Modellnamen auch durch andere TTS-Modelle ersetzen.

Hinweis: Orpheus’ Tokenizer enthält bereits spezielle Tokens für Audioausgabe (mehr dazu später). Sie brauchen keinen separaten Vocoder – Orpheus wird Audio-Tokens direkt ausgeben, die zu einer Wellenform dekodiert werden können.

Vorbereitung Ihres Datensatzes

Mindestens besteht ein TTS-Feinabstimmungsdatensatz aus Audioclips und deren entsprechenden Transkripten (Text). Verwenden wir den Elise Datensatz bei dem es sich um ein etwa 3-stündiges Monosprecher-englisches Sprachkorpus handelt. Es gibt zwei Varianten:

• MrDragonFox/Elise – eine augmentierte Version mit Emotionstags (z. B. <sigh>, <laughs>) eingebettet in den Transkripten. Diese Tags in spitzen Klammern markieren Ausdrücke (Lachen, Seufzer usw.) und werden vom Tokenizer von Orpheus als spezielle Tokens behandelt

• Jinsaryko/Elise – Basisversion mit Transkripten ohne spezielle Tags.

Der Datensatz ist so organisiert, dass pro Eintrag ein Audio und ein Transkript vorhanden sind. Auf Hugging Face haben diese Datensätze Felder wie audio (die Wellenform), text (die Transkription) und einige Metadaten (Sprechername, Pitch-Statistiken usw.). Wir müssen Unsloth einen Datensatz aus Audio-Text-Paaren bereitstellen.

Anstatt sich ausschließlich auf Ton, Kadenz und Pitch zu konzentrieren, sollte die Priorität darin liegen, sicherzustellen, dass Ihr Datensatz vollständig annotiert und ordnungsgemäß normalisiert ist.

Bei einigen Modellen wie Sesame-CSM-1Bkönnen Sie eine Stimmvariation über Generierungen hinweg bemerken, wenn Sie speaker ID 0 verwenden, weil es ein Basismodellist — es hat keine festen Stimmidentitäten. Speaker-ID-Tokens helfen hauptsächlich dabei, Konsistenz innerhalb einer Unterhaltungaufrechtzuerhalten, nicht über separate Generierungen hinweg.

Um eine konsistente Stimme zu erhalten, liefern Sie kontextuelle Beispiele, wie ein paar Referenz-Audioclips oder vorherige Äußerungen. Dies hilft dem Modell, die gewünschte Stimme zuverlässiger zu imitieren. Ohne dies ist Variation zu erwarten, selbst bei derselben Speaker-ID.

Option 1: Verwendung der Hugging Face Datasets-Bibliothek – Wir können den Elise-Datensatz mit Hugging Face’s datasets Bibliothek laden:

from datasets import load_dataset, Audio

# Laden des Elise-Datensatzes (z. B. die Version mit Emotionstags)
dataset = load_dataset("MrDragonFox/Elise", split="train")
print(len(dataset), "samples")  # ~1200 Samples in Elise

# Stellen Sie sicher, dass alle Audios eine Abtastrate von 24 kHz haben (Orpheus’ erwartete Rate)
dataset = dataset.cast_column("audio", Audio(sampling_rate=24000))

Dies wird den Datensatz herunterladen (~328 MB für ~1,2k Samples). Jeder Eintrag in Datensatz ist ein Wörterbuch mit mindestens:

• "audio": dem Audioclip (Wellenform-Array und Metadaten wie Abtastrate), und

• "text": der Transkript-String

Orpheus unterstützt Tags wie <laugh>, <chuckle>, <sigh>, <cough>, <sniffle>, <groan>, <yawn>, <gasp>, usw. Zum Beispiel: "I missed you <laugh> so much!". Diese Tags sind in spitze Klammern eingeschlossen und werden vom Modell als spezielle Tokens behandelt (sie entsprechen Orpheus’ erwarteten Tags wie <laugh> und <sigh>. Während des Trainings wird das Modell lernen, diese Tags mit den entsprechenden Audiomustern zu assoziieren. Der Elise-Datensatz mit Tags enthält bereits viele davon (z. B. 336 Vorkommen von „laughs“, 156 von „sighs“ usw., wie in seiner Card aufgeführt). Wenn Ihr Datensatz solche Tags nicht enthält, Sie sie aber einbeziehen möchten, können Sie die Transkripte manuell annotieren, wo das Audio diese Ausdrücke enthält.

Option 2: Vorbereitung eines eigenen Datensatzes – Wenn Sie eigene Audiodateien und Transkripte haben:

• Organisieren Sie Audioclips (WAV/FLAC-Dateien) in einem Ordner.

• Erstellen Sie eine CSV- oder TSV-Datei mit Spalten für Dateipfad und Transkript. Zum Beispiel:

  filename,text
  0001.wav,Hello there!
  0002.wav,<sigh> I am very tired.

• Verwenden Sie load_dataset("csv", data_files="mydata.csv", split="train") um sie zu laden. Möglicherweise müssen Sie dem Dataset-Loader mitteilen, wie Audio-Pfade zu behandeln sind. Eine Alternative ist die Verwendung des datasets.Audio Features, um Audiodaten bei Bedarf zu laden:

  from datasets import Audio
  dataset = load_dataset("csv", data_files="mydata.csv", split="train")
  dataset = dataset.cast_column("filename", Audio(sampling_rate=24000))

  Dann dataset[i]["audio"] wird das Audio-Array enthalten.

• Stellen Sie sicher, dass Transkripte normalisiert sind (keine ungewöhnlichen Zeichen, die der Tokenizer möglicherweise nicht kennt, außer den Emotionstags, falls verwendet). Stellen Sie außerdem sicher, dass alle Audios eine konsistente Abtastrate haben (resampeln Sie sie bei Bedarf auf die Zielrate, die das Modell erwartet, z. B. 24 kHz für Orpheus).

Zusammenfassend, für die Datensatzvorbereitung:

• benötigen Sie eine Liste von (Audio, Text) Paaren.

• Verwenden Sie die HF datasets Bibliothek, um das Laden und optionale Preprocessing (wie Resampling) zu handhaben.

• Fügen Sie alle spezial Tags in den Text ein, die das Modell lernen soll (stellen Sie sicher, dass sie im <angle_brackets> Format sind, damit das Modell sie als eigene Tokens behandelt).

• (Optional) Wenn Multi-Sprecher, könnten Sie ein Speaker-ID-Token in den Text einfügen oder einen separaten Speaker-Embedding-Ansatz verwenden, aber das geht über diese grundlegende Anleitung hinaus (Elise ist Ein-Sprecher).

Feinabstimmung von TTS mit Unsloth

Nun beginnen wir mit der Feinabstimmung! Wir illustrieren dies mit Python-Code (den Sie in einem Jupyter-Notebook, Colab usw. ausführen können).

Schritt 1: Modell und Datensatz laden

In allen unseren TTS-Notebooks aktivieren wir LoRA (16-Bit) Training und deaktivieren QLoRA (4-Bit) Training mit: load_in_4bit = False. Dies ermöglicht es dem Modell in der Regel, Ihren Datensatz besser zu lernen und eine höhere Genauigkeit zu erzielen.

from unsloth import FastLanguageModel
import torch
dtype = None # None zur automatischen Erkennung. Float16 für Tesla T4, V100, Bfloat16 für Ampere+
load_in_4bit = False # Verwenden Sie 4-Bit-Quantisierung zur Reduzierung des Speicherbedarfs. Kann False sein.

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/orpheus-3b-0.1-ft",
    max_seq_length= 2048, # Wählen Sie beliebig für langen Kontext!
    dtype = dtype,
    load_in_4bit = load_in_4bit,
    #token = "hf_...", # verwenden Sie einen, wenn Sie gesperrte Modelle wie meta-llama/Llama-2-7b-hf nutzen
)

from datasets import load_dataset
dataset = load_dataset("MrDragonFox/Elise", split = "train")

Wenn der Speicher sehr begrenzt ist oder der Datensatz groß ist, können Sie streamen oder in Teilen laden. Hier passen 3 Stunden Audio leicht in den RAM. Wenn Sie Ihre eigene Datensatz-CSV verwenden, laden Sie sie ähnlich.

Schritt 2: Fortgeschritten – Daten für das Training vorverarbeiten (Optional)

Wir müssen Eingaben für den Trainer vorbereiten. Für Text-to-Speech ist ein Ansatz, das Modell kausal zu trainieren: Text- und Audio-Token-IDs als Zielsequenz zu verketten. Da Orpheus jedoch ein Decoder-only-LLM ist, das Audio ausgibt, können wir den Text als Eingabe (Kontext) zuführen und die Audio-Token-IDs als Labels verwenden. In der Praxis könnte Unsloths Integration dies automatisch tun, wenn die Modellkonfiguration es als Text-to-Speech identifiziert. Falls nicht, können wir so etwas tun wie:

# Tokenize the text transcripts
def preprocess_function(example):
    # Tokenize the text (keep the special tokens like <laugh> intact)
    tokens = tokenizer(example["text"], return_tensors="pt")
    # Flatten to list of token IDs
    input_ids = tokens["input_ids"].squeeze(0)
    # The model will generate audio tokens after these text tokens.
    # For training, we can set labels equal to input_ids (so it learns to predict next token).
    # But that only covers text tokens predicting the next text token (which might be an audio token or end).
    # A more sophisticated approach: append a special token indicating start of audio, and let the model generate the rest.
    # For simplicity, use the same input as labels (the model will learn to output the sequence given itself).
    return {"input_ids": input_ids, "labels": input_ids}

train_data = dataset.map(preprocess_function, remove_columns=dataset.column_names)

Das Obige ist eine Vereinfachung. In Wirklichkeit müssten Sie, um Orpheus richtig feinabzustimmen, die Audio-Tokens als Teil der Trainingslabelshaben. Orpheus’ Vortraining beinhaltete wahrscheinlich die Umwandlung von Audio in diskrete Tokens (über einen Audiocodec) und das Training des Modells, diese vorherzusagen, gegebenem vorausgehenden Text. Für die Feinabstimmung auf neue Sprachdaten müssten Sie ähnlich die Audio-Tokens für jeden Clip erhalten (mithilfe von Orpheus’ Audiocodec). Das Orpheus-GitHub stellt ein Skript zur Datenverarbeitung bereit – es kodiert Audio in Sequenzen von <custom_token_x> Tokens.

Allerdings kann Unsloth dies abstrahieren: Wenn das Modell ein FastModel mit einem zugehörigen Processor ist, der weiß, wie mit Audio umzugehen ist, könnte es die Audiokodierung im Datensatz automatisch vornehmen. Falls nicht, müssten Sie jeden Audioclip manuell in Token-IDs kodieren (mithilfe von Orpheus’ Codebook). Dies ist ein fortgeschrittener Schritt, der über diese Anleitung hinausgeht, aber bedenken Sie, dass das bloße Verwenden von Text-Tokens das Modell nicht das tatsächliche Audio lehren wird – es muss die Audiomuster abgleichen.

Gehen wir davon aus, dass Unsloth eine Möglichkeit bietet, Audio direkt zuzufüttern (zum Beispiel durch Setzen von processor und Übergabe des Audio-Arrays). Wenn Unsloth automatische Audiotokenisierung noch nicht unterstützt, müssen Sie möglicherweise die Orpheus-Repository- encode_audio Funktion verwenden, um Token-Sequenzen für das Audio zu erhalten und diese dann als Labels zu verwenden. (Die Datensatz-Einträge haben tatsächlich Phoneme und einige akustische Merkmale, was auf eine Pipeline hindeutet.)

Schritt 3: Trainingsargumente und Trainer einrichten

from transformers import TrainingArguments,Trainer,DataCollatorForSeq2Seq
from unsloth import is_bfloat16_supported

trainer = Trainer(
    model = model,
    train_dataset = dataset,
    args = TrainingArguments(
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        # num_train_epochs = 1, # Set this for 1 full training run.
        max_steps = 60,
        learning_rate = 2e-4,
        fp16 = not is_bfloat16_supported(),
        bf16 = is_bfloat16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
        report_to = "none", # Use this for WandB etc
    ),
)

Wir machen 60 Schritte, um die Dinge zu beschleunigen, aber Sie können num_train_epochs=1 für einen vollständigen Lauf setzen und max_steps=Nonedeaktivieren. Bei Verwendung eines per_device_train_batch_size >1 kann es zu Fehlern kommen, wenn ein Multi-GPU-Setup verwendet wird; um Probleme zu vermeiden, stellen Sie sicher, dass CUDA_VISIBLE_DEVICES auf eine einzelne GPU gesetzt ist (z. B. CUDA_VISIBLE_DEVICES=0). Passen Sie es bei Bedarf an.

Schritt 4: Feinabstimmung beginnen

Dies startet die Trainingsschleife. Sie sollten alle 50 Schritte Loss-Logs sehen (wie durch logging_stepsgesetzt). Das Training kann je nach GPU einige Zeit dauern – zum Beispiel können auf einer Colab T4 GPU einige Epochen auf 3 Stunden Daten 1–2 Stunden dauern. Unsloths Optimierungen machen es schneller als das Standard-HF-Training.

Schritt 5: Das feinabgestimmte Modell speichern

Nachdem das Training abgeschlossen ist (oder wenn Sie es unterwegs stoppen, wenn Sie es für ausreichend halten), speichern Sie das Modell. Dies speichert NUR die LoRA-Adapter und nicht das vollständige Modell. Um in 16-Bit oder GGUF zu speichern, scrollen Sie nach unten!

model.save_pretrained("lora_model")  # Lokal speichern
tokenizer.save_pretrained("lora_model")
# model.push_to_hub("your_name/lora_model", token = "...") # Online speichern
# tokenizer.push_to_hub("your_name/lora_model", token = "...") # Online speichern

Dies speichert die Modellgewichte (für LoRA könnte es nur Adaptergewichte speichern, wenn die Basis nicht vollständig feinabgestimmt wurde). Wenn Sie --push_model im CLI oder trainer.push_to_hub()verwendet haben, könnten Sie es direkt zum Hugging Face Hub hochladen.

Nun sollten Sie ein feinabgestimmtes TTS-Modell im Verzeichnis haben. Der nächste Schritt ist, es zu testen und, falls unterstützt, können Sie llama.cpp verwenden, um es in eine GGUF-Datei zu konvertieren.

Feinabstimmung von Stimmmodellen vs. Zero-Shot-Stimmenklonen

Man sagt, man könne eine Stimme mit nur 30 Sekunden Audio mit Modellen wie XTTS klonen – kein Training erforderlich. Das ist technisch richtig, aber es verfehlt den Punkt.

Zero-Shot-Stimmenklonen, das auch in Modellen wie Orpheus und CSM verfügbar ist, ist eine Annäherung. Es erfasst das allgemeine Ton und Timbre der Stimme eines Sprechers, reproduziert jedoch nicht den vollen expressiven Bereich. Sie verlieren Details wie Sprechgeschwindigkeit, Phrasierung, vokale Eigenheiten und die Feinheiten der Prosodie – Dinge, die einer Stimme ihre Persönlichkeit und Einzigartigkeit.

geben. Wenn Sie nur eine andere Stimme möchten und mit den gleichen Vortragsmustern zufrieden sind, ist Zero-Shot in der Regel ausreichend. Die Sprache wird jedoch weiterhin dem Stil des Modellsfolgen, nicht dem des Sprechers.

Für alles, was persönlicher oder ausdrucksstärker sein soll, benötigen Sie Training mit Methoden wie LoRA, um wirklich einzufangen, wie jemand spricht.