🔊Leitfaden zum Fine-Tuning von Text-to-Speech (TTS)

Erfahren Sie, wie Sie TTS- und STT-Sprachmodelle mit Unsloth feinabstimmen.

Durch Feinabstimmung von TTS-Modellen können sie sich an Ihren spezifischen Datensatz, Anwendungsfall oder gewünschten Stil und Ton anpassen. Das Ziel ist, diese Modelle zu individualisieren, um Stimmen zu klonen, Sprechstile und Tonlagen anzupassen, neue Sprachen zu unterstützen, bestimmte Aufgaben zu bewältigen und mehr. Wir unterstützen auch Speech-to-Text (STT) Modelle wie Whisper von OpenAI.

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

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

Zero-Shot-Klonen erfasst den Ton, verfehlt aber Tempo und Ausdruck und klingt oft roboterhaft und unnatürlich. Feinabstimmung liefert eine wesentlich genauere und realistischere Stimmreplikation. Hier mehr lesen.

Notebooks zur Feinabstimmung:

Wir haben außerdem TTS-Modelle (original und quantisiert) auf unserer 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 bemerken, dass die Ausgabelänge ein Maximum von 10 Sekunden erreicht, erhöhen Siemax_new_tokens = 125 vom Standardwert 125. Da 125 Tokens 10 Sekunden Audio entsprechen, müssen Sie für längere Ausgaben einen höheren Wert festlegen.

Ein TTS-Modell auswählen und laden

Für TTS werden kleinere Modelle wegen der geringeren Latenz und schnelleren Inferenz für Endnutzer oft bevorzugt. Eine Feinabstimmung eines Modells 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 professionelle Sprecherinnen und Sprecher feinabgestimmt ist, wodurch Stimmkonsistenz der entscheidende Unterschied ist. CSM benötigt Audiokontext für jede sprechende Person, um gut zu funktionieren, während Orpheus-ft diese Konsistenz bereits eingebaut hat.

Die Feinabstimmung von einem Basismodell wie CSM erfordert im Allgemeinen mehr Rechenleistung, während der Start von einem feinabgestimmten Modell wie Orpheus-ft bessere Ergebnisse direkt aus der Box bietet.

Zur Unterstützung von CSM 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 zeichnet sich durch die Erzeugung realistischer Sprache mit integrierter Unterstützung für emotionale Hinweise wie Lachen und Seufzen aus. Seine Architektur macht es zu einem der am einfachsten zu nutzenden und zu trainierenden TTS-Modelle, da es über llama.cpp exportiert werden kann, was eine hervorragende Kompatibilität über alle Inferenz-Engines hinweg bedeutet. Für nicht unterstützte Modelle können Sie nur die LoRA-Adapter-Safetensors speichern.

Modelle laden

Da Sprachmodelle normalerweise klein sind, können Sie die Modelle mit LoRA 16-Bit oder vollständigem Fine-Tuning FFT trainieren, was möglicherweise qualitativ bessere 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  # 4-Bit-Präzision verwenden (QLoRA)
)

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

Hinweis: Der Tokenizer von Orpheus enthält bereits spezielle Tokens für Audioausgabe (mehr dazu später). Sie nicht benötigen keinen separaten Vocoder – Orpheus gibt Audio-Tokens direkt aus, die zu einer Wellenform dekodiert werden können.

Ihr Datenset vorbereiten

Ein TTS-Feinabstimmungsdatensatz besteht mindestens aus Audioclips und ihren entsprechenden Transkripten (Text). Verwenden wir das Elise Datenset das ein etwa 3-stündiger englischer Sprachkorpus mit nur einer sprechenden Person ist. Es gibt zwei Varianten:

• MrDragonFox/Elise – eine angereicherte Version mit Emotions-Tags (z. B. <sigh>, <laughs>), die in den Transkripten eingebettet sind. Diese Tags in spitzen Klammern kennzeichnen Ausdrücke (Lachen, Seufzen 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 es pro Eintrag ein Audio und ein Transkript gibt. Auf Hugging Face haben diese Datensätze Felder wie audio (die Wellenform), text (die Transkription) und einige Metadaten (Sprechername, Tonhöhenstatistiken usw.). Wir müssen Unsloth ein Datenset aus Audio-Text-Paaren zuführen.

Anstatt sich ausschließlich auf Ton, Rhythmus und Tonhöhe zu konzentrieren, sollte die Priorität darauf liegen, sicherzustellen, dass Ihr Datensatz vollständig annotiert und korrekt normalisiert ist.

Bei einigen Modellen wie Sesame-CSM-1Bkönnen Sie eine Variabilität der Stimme über Generierungen hinweg mit Sprecher-ID 0 bemerken, weil es ein Basismodellist – es hat keine festgelegten Stimmidentitäten. Sprecher-ID-Tokens helfen hauptsächlich dabei, Konsistenz innerhalb eines Gesprächszu erhalten, nicht über separate Generierungen hinweg.

Um eine konsistente Stimme zu erhalten, geben Sie kontextuelle Beispielean, etwa einige Referenz-Audioclips oder vorherige Äußerungen. Das hilft dem Modell, die gewünschte Stimme zuverlässiger zu imitieren. Ohne das ist Variabilität zu erwarten, selbst bei derselben Sprecher-ID.

Option 1: Verwendung der Hugging-Face-Datasets-Bibliothek – Wir können das Elise-Datenset mit Hugging Faces datasets Bibliothek laden:

from datasets import load_dataset, Audio

# Lade das Elise-Datenset (z. B. die Version mit Emotions-Tags)
dataset = load_dataset("MrDragonFox/Elise", split="train")
print(len(dataset), "Samples")  # ca. 1200 Samples in Elise

# Stelle sicher, dass alle Audiodaten mit 24 kHz Abtastrate vorliegen (die von Orpheus erwartete Rate)
dataset = dataset.cast_column("audio", Audio(sampling_rate=24000))

Dadurch wird der Datensatz heruntergeladen (ca. 328 MB für etwa 1,2k Samples). Jedes Element in Datenset ist ein Dictionary mit mindestens:

• "audio": der Audioclip (Wellenformarray und Metadaten wie Abtastrate) und

• "text": die Transkript-String

Orpheus unterstützt Tags wie <laugh>, <chuckle>, <sigh>, <cough>, <sniffle>, <groan>, <yawn>, <gasp>usw. Zum Beispiel: "Ich habe dich so sehr vermisst <laugh>!". Diese Tags sind in spitze Klammern eingeschlossen und werden vom Modell als spezielle Tokens behandelt (sie entsprechen den erwarteten Tags von Orpheus wie <laugh> und <sigh>. Während des Trainings lernt das Modell, diese Tags mit den entsprechenden Audiomustern zu verknüpfen. Der Elise-Datensatz mit Tags enthält bereits viele davon (z. B. 336 Vorkommen von „laughs“, 156 von „sighs“ usw., wie auf der Dataset-Card aufgeführt). Wenn Ihr Datensatz solche Tags nicht enthält, Sie sie aber einbinden möchten, können Sie die Transkripte manuell an den Stellen annotieren, an denen das Audio diese Ausdrucksformen enthält.

Option 2: Einen benutzerdefinierten Datensatz vorbereiten – Wenn Sie Ihre eigenen 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,Hallo!
  0002.wav,<sigh> Ich bin sehr müde.

• Verwenden Sie load_dataset("csv", data_files="mydata.csv", split="train") zum Laden. Möglicherweise müssen Sie dem Dataset-Loader mitteilen, wie Audiopfadnamen behandelt werden sollen. Eine Alternative ist die Verwendung der datasets.Audio Funktion, 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 Emotions-Tags, falls verwendet). Stellen Sie außerdem sicher, dass alle Audiodateien eine einheitliche Abtastrate haben (resamplen Sie sie bei Bedarf auf die Zielrate, die das Modell erwartet, z. B. 24 kHz für Orpheus).

Zusammenfassend gilt für die Datensatzvorbereitung:

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

• Verwenden Sie die HF datasets Bibliothek, um das Laden und optional die Vorverarbeitung (z. B. Resampling) zu handhaben.

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

• (Optional) Bei mehreren Sprecherinnen/Sprechern könnten Sie ein Sprecher-ID-Token im Text einfügen oder einen separaten Ansatz mit Sprecher-Embedding verwenden, aber das geht über diesen Grundleitfaden hinaus (Elise ist Ein-Sprecherinnen-/Ein-Sprecher-Datensatz).

TTS mit Unsloth feinabstimmen

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

Schritt 1: Modell und Datensatz laden

In all unseren TTS-Notebooks aktivieren wir das LoRA-Training (16-Bit) und deaktivieren das QLoRA-Training (4-Bit) mit: load_in_4bit = False. So kann das Modell Ihren Datensatz in der Regel besser lernen und eine höhere Genauigkeit erreichen.

from unsloth import FastLanguageModel
import torch
dtype = None # None für automatische Erkennung. Float16 für Tesla T4, V100, Bfloat16 für Ampere+
load_in_4bit = False # 4-Bit-Quantisierung verwenden, um den Speicherverbrauch zu reduzieren. Kann auch False sein.

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

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 Blöcken laden. Hier passen 3 Stunden Audio problemlos in den RAM. Wenn Sie Ihr eigenes Datensatz-CSV verwenden, laden Sie es entsprechend.

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

Wir müssen Eingaben für den Trainer vorbereiten. Für Text-zu-Sprache ist ein Ansatz, das Modell kausal zu trainieren: Text- und Audio-Token-IDs als Zielsequenz zu verketten. Da Orpheus jedoch ein rein dekoderbasiertes LLM ist, das Audio ausgibt, können wir den Text als Eingabe (Kontext) übergeben und die Audio-Token-IDs als Labels verwenden. In der Praxis kann Unsloths Integration dies automatisch tun, wenn die Konfiguration des Modells es als Text-zu-Sprache identifiziert. Falls nicht, können wir etwas wie Folgendes tun:

# Den Text der Transkripte tokenisieren
def preprocess_function(example):
    # Den Text tokenisieren (die speziellen Tokens wie <laugh> beibehalten)
    tokens = tokenizer(example["text"], return_tensors="pt")
    # Auf Liste von Token-IDs reduzieren
    input_ids = tokens["input_ids"].squeeze(0)
    # Das Modell wird nach diesen Text-Tokens Audio-Tokens erzeugen.
    # Für das Training können wir Labels gleich input_ids setzen (so lernt es, das nächste Token vorherzusagen).
    # Aber das deckt nur Text-Tokens ab, die das nächste Text-Token vorhersagen (das könnte ein Audio-Token oder das Ende sein).
    # Ein ausgefeilterer Ansatz: Fügen Sie ein spezielles Token hinzu, das den Start von Audio signalisiert, und lassen Sie das Modell den Rest erzeugen.
    # Für die Einfachheit verwenden Sie die gleiche Eingabe als Labels (das Modell lernt, die Sequenz aus sich selbst heraus auszugeben).
    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 korrekt feinabzustimmen, die Audio-Tokens als Teil der Trainings-Labelshaben. Das Vortraining von Orpheus umfasste wahrscheinlich die Umwandlung von Audio in diskrete Tokens (über einen Audio-Codec) und das Training des Modells, diese anhand des vorhergehenden Textes vorherzusagen. Für die Feinabstimmung auf neue Sprachdaten müssten Sie auf ähnliche Weise die Audio-Tokens für jeden Clip erhalten (mithilfe des Audio-Codecs von Orpheus). Das Orpheus-GitHub stellt ein Skript für die Datenverarbeitung bereit – es kodiert Audio in Sequenzen von <custom_token_x> Tokens.

Allerdings kann Unsloth das möglicherweise abstrahieren: Wenn das Modell ein FastModel mit einem zugehörigen Processor ist, der mit Audio umgehen kann, könnte es das Audio im Datensatz automatisch in Tokens kodieren. Falls nicht, müssten Sie jeden Audioclip manuell in Token-IDs kodieren (mithilfe des Codebooks von Orpheus). Dies ist ein fortgeschrittener Schritt über diesen Leitfaden hinaus, aber beachten Sie, dass das bloße Verwenden von Text-Tokens dem Modell nicht das eigentliche Audio beibringt – es muss den Audiomustern entsprechen.

Nehmen wir an, Unsloth bietet eine Möglichkeit, Audio direkt einzuspeisen (zum Beispiel durch Setzen von processor und Übergabe des Audio-Arrays). Falls Unsloth die automatische Audio-Tokenisierung noch nicht unterstützt, müssen Sie möglicherweise die encode_audio Funktion des Orpheus-Repositories verwenden, um Token-Sequenzen für das Audio zu erhalten, und diese dann als Labels verwenden. (Die Datensatzeinträge enthalten tatsächlich Phoneme und einige akustische Merkmale, was auf eine entsprechende 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, # Legen Sie dies für einen vollständigen Trainingslauf auf 1 fest.
        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", # Verwenden Sie dies für WandB usw.
    ),
)

Wir machen 60 Schritte, um die Sache zu beschleunigen, aber Sie können setzen num_train_epochs=1 für einen vollständigen Durchlauf und max_steps=None. Die Verwendung von per_device_train_batch_size >1 kann bei Multi-GPU-Setup zu Fehlern führen. 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 nach Bedarf an.

Schritt 4: Mit der Feinabstimmung beginnen

Dies startet die Trainingsschleife. Sie sollten Protokolle des Loss alle 50 Schritte sehen (wie durch logging_stepsfestgelegt). Das Training kann je nach GPU einige Zeit dauern – zum Beispiel können auf einer Colab-T4-GPU ein paar Epochen mit 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 mitten drin stoppen, wenn es Ihnen ausreichend erscheint), speichern Sie das Modell. Dadurch werden NUR die LoRA-Adapter gespeichert, nicht das vollständige Modell. Um in 16-Bit oder GGUF zu speichern, weiter unten scrollen!

model.save_pretrained("lora_model")  # Lokales 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

Dadurch werden die Modellgewichte gespeichert (bei LoRA werden möglicherweise nur die Adaptergewichte gespeichert, wenn das Basismodell nicht vollständig feinabgestimmt ist). Wenn Sie --push_model in der CLI oder trainer.push_to_hub()verwendet haben, könnten Sie es direkt auf den Hugging Face Hub hochladen.

Jetzt 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 Sprachmodellen vs. Zero-Shot-Stimmklonen

Man sagt, man könne eine Stimme mit nur 30 Sekunden Audio mit Modellen wie XTTS klonen – ohne Training. Technisch stimmt das, aber es verfehlt den Punkt.

Zero-Shot-Stimmklonen, das auch in Modellen wie Orpheus und CSM verfügbar ist, ist eine Annäherung. Es erfasst die allgemeine Tonlage und Klangfarbe einer Stimme, reproduziert aber nicht das gesamte Ausdrucksspektrum. Details wie Sprechgeschwindigkeit, Formulierungen, vokale Eigenheiten und die Feinheiten der Prosodie gehen verloren – Dinge, die einer Stimme ihre Persönlichkeit und Einzigartigkeit.

verleihen. Wenn Sie nur eine andere Stimme möchten und mit denselben Wiedergabemustern einverstanden sind, ist Zero-Shot normalerweise gut genug. Die Sprache wird jedoch weiterhin dem Stil des Modellsfolgen, nicht dem der sprechenden Person.

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