Eigene Stimme trainieren

Voraussetzungen

• Windows 10/11 mit WSL2
• NVIDIA RTX 3060 (12GB VRAM) oder vergleichbar
• Mindestens 50GB freier Speicherplatz
• Internetverbindung
• Audio-Daten: Mindestens 30 Minuten (empfohlen: 1-2 Stunden)

1. WSL2 Setup

1.1 WSL aktivieren (Erstinstallation)

Wenn du WSL noch nie installiert hast:

1. Öffne CMD (Eingabeaufforderung) in Windows
2. Gib wsl ein und drücke Enter
3. Windows wird melden, dass WSL nicht installiert ist und fragen, ob es installiert werden soll
4. Drücke Enter um zu bestätigen
5. Windows installiert WSL automatisch
6. Starte deinen PC neu

1.2 Ubuntu installieren

In CMD (Eingabeaufforderung) als Administrator:

wsl --install -d Ubuntu-22.04

Nach der Installation wirst du aufgefordert, einen Benutzernamen und Passwort zu erstellen.

WICHTIG: Merke dir Benutzername und Passwort - du brauchst sie später!

Nach der Einrichtung befindest du dich automatisch in der Ubuntu WSL-Umgebung.

1.3 WSL-Session beenden

Du musst jetzt die aktuelle WSL-Session beenden. Schließe einfach das Ubuntu-Fenster (X-Button oben rechts) oder gib ein:

exit

💡 Hinweis: Es kann eine Fehlermeldung erscheinen wie "Fehler beim Installationsprozess" - das ist normal und kann ignoriert werden. Die Installation ist trotzdem erfolgreich abgeschlossen.

1.4 WSL2 als Standard setzen

Öffne ein neues CMD-Fenster als Administrator und führe aus:

wsl --set-default-version 2

wsl --set-default Ubuntu-22.04

1.5 Ubuntu neu starten

wsl -d Ubuntu-22.04

Jetzt bist du wieder in der Ubuntu-Umgebung und kannst mit Schritt 2 fortfahren.

1.6 GPU-Zugriff testen (Optional)

Um zu überprüfen, ob deine NVIDIA GPU in WSL erkannt wird:

nvidia-smi

Erwartetes Ergebnis: Du solltest deine GPU mit VRAM-Angabe sehen. CUDA wird automatisch mit WSL2 ausgeliefert!

2. System-Pakete installieren

2.1 System aktualisieren

WICHTIG: Führe dies zuerst aus, bevor du Pakete installierst!

sudo apt update && sudo apt upgrade -y

Das kann einige Minuten dauern.

2.2 Basis-Pakete

Build-Tools:

sudo apt install -y build-essential ninja-build

Python und Entwicklungs-Tools:

sudo apt install -y python3.10 python3.10-venv python3.10-dev python3-pip

Audio-Bibliotheken:

sudo apt install -y libsndfile1 ffmpeg

espeak-ng:

sudo apt install -y espeak-ng

Git:

sudo apt install -y git

Zusätzliche Abhängigkeiten:

sudo apt install -y libportaudio2 portaudio19-dev

2.3 CMake aktualisieren (Version 3.26+ erforderlich)

Alte CMake-Version entfernen:

sudo apt remove --purge cmake -y

sudo apt autoremove -y

CMake von Kitware installieren:

wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null

echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' | sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null

sudo apt update

sudo apt install -y cmake

Version überprüfen (sollte 3.26 oder höher sein):

cmake --version

3. Piper einrichten

3.1 Arbeitsverzeichnis erstellen

cd ~

mkdir piper-training

cd piper-training

3.2 Repository klonen

git clone https://github.com/OHF-voice/piper1-gpl.git

cd piper1-gpl

3.3 Python Virtual Environment erstellen

python3 -m venv .venv

source .venv/bin/activate

💡 Erfolgreich aktiviert? Du solltest jetzt (.venv) vor deinem Benutzernamen in der Kommandozeile sehen.

pip install --upgrade pip setuptools wheel

3.4 PyTorch mit CUDA Support installieren

WICHTIG: Zuerst PyTorch installieren, BEVOR du Piper installierst!

PyTorch 2.0.1 mit CUDA 11.8 (Installation kann dauern):

pip install torch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118

PyTorch Lightning:

pip install pytorch-lightning==2.0.9 lightning==2.0.9

NumPy auf kompatible Version setzen:

pip install "numpy<2.0"

3.5 PyTorch CUDA-Zugriff testen

python3 -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}'); print(f'CUDA device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"None\"}')"

Erwartetes Ergebnis: CUDA available: True und dein GPU-Name

3.6 Piper Training Dependencies installieren

pip install -e .[train]

3.7 Cython Extension bauen

chmod +x build_monotonic_align.sh

./build_monotonic_align.sh

💡 Performance-Warnungen sind normal und können ignoriert werden!

3.8 scikit-build und Dev Build

pip install scikit-build

WICHTIG: pip installiert manchmal eine alte CMake-Version im venv - diese muss entfernt werden:

pip uninstall cmake -y

CMake-Version prüfen (sollte 3.26+ sein):

cmake --version

Dev Build:

python3 setup.py build_ext --inplace

3.9 Checkpoint herunterladen

mkdir -p ~/piper-training/checkpoints

cd ~/piper-training/checkpoints

Wähle das Checkpoint für deine Sprache (nur EINS herunterladen!):

# Deutsch
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/en/en_US/lessac/medium/epoch%3D2164-step%3D1355540.ckpt

# Englisch
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/en/en_US/lessac/medium/epoch%3D2164-step%3D1355540.ckpt

# Russisch
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/ru/ru_RU/ruslan/medium/epoch%3D2436-step%3D1724372.ckpt

# Polnisch
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/pl/pl_PL/gosia/medium/epoch%3D5001-step%3D1457672.ckpt

# Rumänisch
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/ro/ro_RO/mihai/medium/epoch%3D7809-step%3D1558760.ckpt

# Spanisch (Spanien)
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/es/es_ES/davefx/medium/epoch%3D5629-step%3D1605020.ckpt

# Spanisch (Mexiko)
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/es/es_MX/ald/medium/epoch%3D9999-step%3D1753600.ckpt

# Tschechisch
wget https://huggingface.co/datasets/rhasspy/piper-checkpoints/resolve/main/cs/cs_CZ/jirka/medium/epoch%3D8819-step%3D1435400.ckpt

💡 Hinweis für Italienisch: Es gibt derzeit kein offizielles italienisches Checkpoint. Verwende das deutsche oder englische Checkpoint als Basis.

3.10 Verzeichnisstruktur vorbereiten

cd ~/piper-training

mkdir -p voice-data/raw-audio

mkdir -p voice-data/audio

mkdir -p voice-data/cache

mkdir -p voice-data/output

4. Audio-Daten vorbereiten

4.1 Audio-Dateien nach WSL kopieren

Von Windows PowerShell:

copy C:\Pfad\zu\deinen\*.wav \\wsl$\Ubuntu-22.04\home\DEIN_USERNAME\piper-training\voice-data\raw-audio\

Oder Windows Explorer:

Adresse: \\wsl$\Ubuntu-22.04\home\DEIN_USERNAME\piper-training\voice-data\raw-audio\

Dateien per Drag & Drop kopieren

💡 Hinweis: Das Audio-Format ist egal - das Automatisierungs-Script konvertiert alle Dateien automatisch zu 22050 Hz Mono!

5. Automatische Verarbeitung mit Whisper

5.1 Whisper installieren

cd ~/piper-training/piper1-gpl

Virtual Environment aktivieren (falls nicht bereits aktiv):

source .venv/bin/activate

Whisper installieren:

pip install openai-whisper pydub

5.2 Automatisierungs-Script erstellen

Erstelle die Datei mit:

cd ~/piper-training

nano process_audio_auto.py

#!/usr/bin/env python3
"""
Automatische Audio-Verarbeitung für Piper Voice Training
- Konvertiert Audio zu 22050 Hz Mono
- Splittet in kurze Segmente
- Transkribiert mit Whisper
- Erstellt metadata.csv
"""

import os
import sys
import subprocess
from pathlib import Path
from pydub import AudioSegment
from pydub.silence import split_on_silence
import whisper
from tqdm import tqdm

# Konfiguration
RAW_AUDIO_DIR = "voice-data/raw-audio"
OUTPUT_AUDIO_DIR = "voice-data/audio"
METADATA_FILE = "voice-data/metadata.csv"
WHISPER_MODEL = "large"  # tiny, base, small, medium, large

# Segment-Einstellungen
MIN_SILENCE_LEN = 500  # ms
SILENCE_THRESH = -40   # dB
KEEP_SILENCE = 200     # ms
MIN_SEGMENT_LEN = 1000 # ms
MAX_SEGMENT_LEN = 15000 # ms

def convert_to_mono_22050(input_file, output_file):
    """Konvertiert Audio zu 22050 Hz Mono"""
    print(f"  Konvertiere: {input_file.name}")
    
    # Erst mit ffmpeg zu Standard-WAV konvertieren (behebt ADPCM-Problem)
    temp_standard_wav = f"/tmp/temp_standard_{input_file.stem}.wav"
    result = subprocess.run([
        'ffmpeg', '-i', str(input_file),
        '-acodec', 'pcm_s16le',  # Standard PCM 16-bit
        '-ar', '44100',           # Erstmal auf 44100 Hz
        '-ac', '1',               # Mono
        '-y',                     # Überschreiben
        temp_standard_wav
    ], capture_output=True, text=True)
    
    if result.returncode != 0:
        print(f"  FEHLER bei ffmpeg-Konvertierung: {result.stderr}")
        raise Exception(f"ffmpeg failed for {input_file}")
    
    # Jetzt mit pydub weiterverarbeiten
    audio = AudioSegment.from_file(temp_standard_wav)
    
    # Sample Rate auf 22050 Hz setzen
    if audio.frame_rate != 22050:
        audio = audio.set_frame_rate(22050)
    
    # Als WAV speichern
    audio.export(output_file, format="wav")
    
    # Temp-Datei löschen
    os.remove(temp_standard_wav)
    
    return audio

def split_audio(audio, base_name):
    """Splittet Audio in kurze Segmente"""
    print(f"  Splitte Audio...")
    
    chunks = split_on_silence(
        audio,
        min_silence_len=MIN_SILENCE_LEN,
        silence_thresh=SILENCE_THRESH,
        keep_silence=KEEP_SILENCE
    )
    
    segments = []
    for i, chunk in enumerate(chunks):
        chunk_len = len(chunk)
        
        # Nur Chunks zwischen MIN und MAX Länge
        if MIN_SEGMENT_LEN <= chunk_len <= MAX_SEGMENT_LEN:
            segments.append(chunk)
        
        # Zu lange Chunks weiter splitten
        elif chunk_len > MAX_SEGMENT_LEN:
            # In kleinere Teile aufteilen
            num_parts = int(chunk_len / MAX_SEGMENT_LEN) + 1
            part_len = chunk_len // num_parts
            
            for j in range(num_parts):
                start = j * part_len
                end = start + part_len if j < num_parts - 1 else chunk_len
                part = chunk[start:end]
                
                if len(part) >= MIN_SEGMENT_LEN:
                    segments.append(part)
    
    print(f"  {len(segments)} Segmente erstellt")
    return segments

def transcribe_segments(segments, segment_files):
    """Transkribiert alle Segmente mit Whisper"""
    print(f"\nLade Whisper-Modell '{WHISPER_MODEL}'...")
    model = whisper.load_model(WHISPER_MODEL)
    
    print(f"Transkribiere {len(segments)} Segmente...")
    transcriptions = []
    
    for i, (segment, file_path) in enumerate(tqdm(zip(segments, segment_files), total=len(segments))):
        # Segment temporär speichern für Whisper
        temp_file = f"/tmp/temp_segment_{i}.wav"
        segment.export(temp_file, format="wav")
        
        # Transkription
        result = model.transcribe(
            temp_file,
            language="de",  # Deutsch
            task="transcribe",
            fp16=True  # Nutzt GPU wenn verfügbar
        )
        
        text = result["text"].strip()
        transcriptions.append(text)
        
        # Temp-Datei löschen
        os.remove(temp_file)
    
    return transcriptions

def main():
    # Verzeichnisse erstellen
    os.makedirs(OUTPUT_AUDIO_DIR, exist_ok=True)
    
    # Alle Audio-Dateien finden
    raw_audio_path = Path(RAW_AUDIO_DIR)
    audio_files = list(raw_audio_path.glob("*.wav")) + \
                  list(raw_audio_path.glob("*.WAV")) + \
                  list(raw_audio_path.glob("*.mp3")) + \
                  list(raw_audio_path.glob("*.MP3")) + \
                  list(raw_audio_path.glob("*.m4a")) + \
                  list(raw_audio_path.glob("*.M4A")) + \
                  list(raw_audio_path.glob("*.flac")) + \
                  list(raw_audio_path.glob("*.FLAC"))
    
    if not audio_files:
        print(f"Keine Audio-Dateien in {RAW_AUDIO_DIR} gefunden!")
        sys.exit(1)
    
    print(f"Gefunden: {len(audio_files)} Audio-Datei(en)")
    print(f"Whisper-Modell: {WHISPER_MODEL}")
    print()
    
    all_segments = []
    all_segment_files = []
    segment_counter = 0
    
    # Jede Audio-Datei verarbeiten
    for audio_file in audio_files:
        print(f"Verarbeite: {audio_file.name}")
        
        # Konvertieren
        converted_file = f"/tmp/converted_{audio_file.stem}.wav"
        audio = convert_to_mono_22050(audio_file, converted_file)
        
        # Splitten
        segments = split_audio(audio, audio_file.stem)
        
        # Segmente speichern
        for segment in segments:
            filename = f"utt_{segment_counter:04d}.wav"
            filepath = os.path.join(OUTPUT_AUDIO_DIR, filename)
            segment.export(filepath, format="wav")
            
            all_segments.append(segment)
            all_segment_files.append(filename)
            segment_counter += 1
        
        # Temp-Datei löschen
        os.remove(converted_file)
        print()
    
    print(f"\nGesamt: {len(all_segments)} Segmente erstellt")
    
    # Transkription
    transcriptions = transcribe_segments(all_segments, all_segment_files)
    
    # metadata.csv erstellen
    print(f"\nErstelle {METADATA_FILE}...")
    with open(METADATA_FILE, "w", encoding="utf-8") as f:
        for filename, text in zip(all_segment_files, transcriptions):
            # Bereinige Text (entferne Zeilenumbrüche, etc.)
            text = text.replace("\n", " ").replace("\r", " ").strip()
            # Schreibe Zeile
            f.write(f"{filename}|{text}\n")
    
    print(f"✅ Fertig!")
    print(f"   Segmente: {len(all_segments)}")
    print(f"   Metadata: {METADATA_FILE}")
    print(f"\nÜberprüfe die metadata.csv und korrigiere bei Bedarf Fehler!")
    print(f"Dann starte das Training mit den Anweisungen in der Anleitung")

if __name__ == "__main__":
    main()

Speichern: Ctrl+O, Enter, Ctrl+X

5.3 Script ausführen

chmod +x process_audio_auto.py

cd ~/piper-training

source ~/piper-training/piper1-gpl/.venv/bin/activate

python3 process_audio_auto.py

Erwartete Dauer (RTX 3060, large-Modell): 2 Stunden Audio = ca. 30-60 Minuten Verarbeitung

5.4 Ergebnis überprüfen

Segmente zählen:

ls ~/piper-training/voice-data/audio/*.wav | wc -l

metadata.csv prüfen:

head -10 ~/piper-training/voice-data/metadata.csv

WICHTIG: Überprüfe die Transkriptionen und korrigiere Fehler:

• Zahlen ausschreiben: "drei" statt "3"
• Namen korrigieren
• Satzzeichen hinzufügen

nano ~/piper-training/voice-data/metadata.csv

6. Training starten

6.1 Virtual Environment aktivieren

cd ~/piper-training/piper1-gpl

Virtual Environment aktivieren (falls nicht bereits aktiv):

source .venv/bin/activate

6.2 Training-Befehl

Passe espeak_voice und max_epochs an deine Sprache an:

python3 -m piper.train fit \
  --data.voice_name "meine_stimme" \
  --data.csv_path ~/piper-training/voice-data/metadata.csv \
  --data.audio_dir ~/piper-training/voice-data/audio/ \
  --model.sample_rate 22050 \
  --data.espeak_voice "de" \
  --data.cache_dir ~/piper-training/voice-data/cache/ \
  --data.config_path ~/piper-training/voice-data/output/config.json \
  --data.batch_size 16 \
  --ckpt_path ~/piper-training/checkpoints/*.ckpt \
  --trainer.max_epochs 4000 \
  --trainer.check_val_every_n_epoch 10

Sprach-spezifische Einstellungen

Weitere Parameter:

• voice_name: Name deiner Stimme
• batch_size: 16 für RTX 3060 (reduziere auf 8 bei OOM-Fehlern)
• ckpt_path: *.ckpt findet automatisch dein heruntergeladenes Checkpoint

6.3 Training überwachen

Zweites Terminal für GPU-Monitoring:

wsl
watch -n 1 nvidia-smi

Erwartete Trainingszeit (RTX 3060):

• Mit Checkpoint + 30 Min Audio: 2-4 Stunden
• Mit Checkpoint + 1-2 Std Audio: 4-8 Stunden

6.4 Training unterbrechen und fortsetzen

Unterbrechen: Ctrl+C

Fortsetzen:

Letzten Checkpoint finden:

ls -lht ~/piper-training/piper1-gpl/lightning_logs/version_*/checkpoints/

Training fortsetzen (passe espeak_voice und max_epochs an deine Sprache an):

python3 -m piper.train fit \
  --ckpt_path ~/piper-training/piper1-gpl/lightning_logs/version_0/checkpoints/last.ckpt \
  --data.voice_name "meine_stimme" \
  --data.csv_path ~/piper-training/voice-data/metadata.csv \
  --data.audio_dir ~/piper-training/voice-data/audio/ \
  --model.sample_rate 22050 \
  --data.espeak_voice "de" \
  --data.cache_dir ~/piper-training/voice-data/cache/ \
  --data.config_path ~/piper-training/voice-data/output/config.json \
  --data.batch_size 16 \
  --trainer.max_epochs 4000

max_epochs pro Sprache: DE: 4000 | EN: 3000 | RU: 3300 | PL: 5900 | RO: 8700 | ES(ES): 6500 | ES(MX): 10800 | CS: 9700

7. Modell exportieren und testen

7.1 Nach ONNX exportieren

cd ~/piper-training/piper1-gpl

Virtual Environment aktivieren (falls nicht bereits aktiv):

source .venv/bin/activate

Besten Checkpoint finden:

ls -lht lightning_logs/version_*/checkpoints/

Export:

python3 -m piper.train.export_onnx \
  --checkpoint lightning_logs/version_0/checkpoints/epoch=999-step=10000.ckpt \
  --output-file ~/piper-training/voice-data/output/de_DE-meine_stimme-medium.onnx

7.2 Config-Datei umbenennen

cd ~/piper-training/voice-data/output

cp config.json de_DE-meine_stimme-medium.onnx.json

ls -lh

7.3 Piper CLI herunterladen und testen

cd ~/piper-training

wget https://github.com/rhasspy/piper/releases/download/2023.11.14-2/piper_linux_x86_64.tar.gz

tar -xzf piper_linux_x86_64.tar.gz

Test-Synthese:

echo "Dies ist ein Test meiner neuen Stimme. Ich hoffe, sie klingt gut!" | \
  ./piper/piper \
  --model voice-data/output/de_DE-meine_stimme-medium.onnx \
  --output_file test_output.wav

Audio abspielen:

sudo apt install -y sox

play test_output.wav

7.4 Nach Windows kopieren

cp ~/piper-training/voice-data/output/de_DE-meine_stimme-medium.onnx* /mnt/c/Users/DEIN_USERNAME/Desktop/

8. Qualität verbessern

8.1 Mehr Audio aufnehmen (WICHTIGSTE MASSNAHME!)

Empfohlene Aufnahme-Richtlinien:

• Mindestens 30 Minuten (besser: 1-2+ Stunden)
• Verschiedene Sätze und Satzlängen
• Verschiedene Emotionen/Betonungen
• Klare, deutliche Aussprache
• Ruhige Umgebung (kein Hintergrundgeräusch)
• Konstanter Abstand zum Mikrofon
• Keine Clipping (Pegel nicht zu hoch)

Aufnahme-Einstellungen:

• Sample Rate: 22050 Hz
• Bit Depth: 16-bit
• Kanäle: Mono
• Format: WAV (unkomprimiert)

8.2 Training-Parameter anpassen

Für längeres Training:

--trainer.max_epochs 5000

Für bessere Qualität (langsamer):

--data.batch_size 8

8.3 Mit mehr Daten neu trainieren

1. Neue Audio-Dateien nach voice-data/raw-audio/ kopieren
2. process_audio_auto.py erneut ausführen
3. Training mit altem Checkpoint fortsetzen

9. Problembehebung

Problem: "CUDA out of memory"

Lösung:

--data.batch_size 8  # oder 4

Problem: "Weights only load failed"

Lösung: PyTorch downgraden

pip install torch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118

pip install pytorch-lightning==2.0.9 lightning==2.0.9

Problem: Training konvergiert nicht (Loss sinkt nicht)

Lösungen:

• Überprüfe metadata.csv auf Tippfehler
• Stelle sicher, dass Audio-Dateien korrekt sind
• Reduziere Learning Rate: --optimizer.lr 0.00005

Problem: Stimme klingt roboterhaft

Ursachen:

• Zu wenig Trainingsdaten
• Training zu kurz
• Schlechte Audio-Qualität

Lösungen:

• Mehr Audio aufnehmen (mindestens 30 Min)
• Länger trainieren (2000+ Epochen)
• Audio-Qualität verbessern

Problem: WSL ist langsam

WICHTIG: Arbeite IMMER im Linux-Dateisystem (/home/...), NICHT im Windows-Dateisystem (/mnt/c/...)!

Problem: Whisper ist sehr langsam

Lösungen:

• GPU-Zugriff testen: python3 -c "import torch; print(torch.cuda.is_available())"
• Kleineres Modell: WHISPER_MODEL = "small"

Nützliche Befehle

WSL herunterfahren (von Windows):

wsl --shutdown

WSL starten:

wsl

Virtual Environment aktivieren:

source ~/piper-training/piper1-gpl/.venv/bin/activate

GPU-Status:

nvidia-smi

Speicherplatz:

df -h

WSL Backup:

wsl --export Ubuntu-22.04 D:\wsl-backup.tar

WSL Wiederherstellen:

wsl --import Ubuntu-22.04 D:\WSL\Ubuntu D:\wsl-backup.tar

Ressourcen

• Piper GitHub
• Piper Checkpoints
• Whisper
• espeak-ng
• Vollständige Markdown-Anleitung