> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/grundlagen/text-to-speech-tts-fine-tuning.md). # Anleitung zur Feinabstimmung von Text-to-Speech (TTS) 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 [Unsloth](https://github.com/unslothai/unsloth)kö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. {% hint style="info" %} 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](#fine-tuning-voice-models-vs.-zero-shot-voice-cloning). {% endhint %} ### Notebooks zur Feinabstimmung: Wir haben außerdem TTS-Modelle (original und quantisiert) auf unserer [Hugging-Face-Seite](https://huggingface.co/collections/unsloth/text-to-speech-tts-models-68007ab12522e96be1e02155). | [Sesame-CSM (1B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Sesame_CSM_\(1B\)-TTS.ipynb) | [Orpheus-TTS (3B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Orpheus_\(3B\)-TTS.ipynb) | [Whisper Large V3](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Whisper.ipynb) (STT) | | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | [Spark-TTS (0.5B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Spark_TTS_\(0_5B\).ipynb) | [Llasa-TTS (1B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llasa_TTS_\(1B\).ipynb) | [Oute-TTS (1B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Oute_TTS_\(1B\).ipynb) | {% hint style="success" %} Wenn Sie bemerken, dass die Ausgabelänge ein Maximum von 10 Sekunden erreicht, erhöhen Sie`max_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. {% endhint %} ### 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: ```python 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. {% hint style="info" %} **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. {% endhint %} ### Ihr Datenset vorbereiten Ein TTS-Feinabstimmungsdatensatz besteht mindestens aus **Audioclips und ihren entsprechenden Transkripten** (Text). Verwenden wir das [*Elise* Datenset](https://huggingface.co/datasets/MrDragonFox/Elise) das ein etwa 3-stündiger englischer Sprachkorpus mit nur einer sprechenden Person ist. Es gibt zwei Varianten: * [`MrDragonFox/Elise`](https://huggingface.co/datasets/MrDragonFox/Elise) – eine angereicherte Version mit **Emotions-Tags** (z. B. \, \), 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`](https://huggingface.co/datasets/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. {% hint style="success" %} 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. {% endhint %} {% hint style="info" %} Bei einigen Modellen wie **Sesame-CSM-1B**können Sie eine Variabilität der Stimme über Generierungen hinweg mit Sprecher-ID 0 bemerken, weil es ein **Basismodell**ist – es hat keine festgelegten Stimmidentitäten. Sprecher-ID-Tokens helfen hauptsächlich dabei, **Konsistenz innerhalb eines Gesprächs**zu erhalten, nicht über separate Generierungen hinweg. Um eine konsistente Stimme zu erhalten, geben Sie **kontextuelle Beispiele**an, 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. {% endhint %} **Option 1: Verwendung der Hugging-Face-Datasets-Bibliothek** – Wir können das Elise-Datenset mit Hugging Faces `datasets` Bibliothek laden: ```python 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 ``, ``, ``, ``, ``, ``, ``, ``usw. Zum Beispiel: `"Ich habe dich so sehr vermisst !"`. Diese Tags sind in spitze Klammern eingeschlossen und werden vom Modell als spezielle Tokens behandelt (sie entsprechen [den erwarteten Tags von Orpheus](https://github.com/canopyai/Orpheus-TTS) wie `` und ``. 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, 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: ```python 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 `` 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. ```python 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") ``` {% hint style="info" %} 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. {% endhint %} **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: ```python # Den Text der Transkripte tokenisieren def preprocess_function(example): # Den Text tokenisieren (die speziellen Tokens wie 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) ``` {% hint style="info" %} Das Obige ist eine Vereinfachung. In Wirklichkeit müssten Sie, um Orpheus korrekt feinabzustimmen, die *Audio-Tokens als Teil der Trainings-Labels*haben. 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 `` Tokens. {% endhint %} 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** ```python 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_steps`festgelegt). 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! ```python 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 Modells**folgen, 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. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/grundlagen/text-to-speech-tts-fine-tuning.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.