Tutorial: Addestrare una Rete Neurale con la Tua Voce usando Piper TTS

Questo è un tutorial breve e intelligente per utilizzare Piper TTS per addestrare una rete neurale con la tua voce.

Introduzione

Piper TTS è un motore di sintesi vocale (text-to-speech) neurale open source, focalizzato su progetti self-hosted (ospitati localmente). È sviluppato dalla Open Home Foundation.

Link al repository GitHub

Caratteristiche Principali

Completamente Offline: Nessun dato lascia la tua macchina. Una volta scaricati i modelli vocali, non hai bisogno di una connessione internet.
Velocità Incredibile: Utilizza il runtime ONNX (Open Neural Network Exchange), rendendolo molto più veloce di molti altri sistemi TTS basati su AI come Tortoise o XTTS.
Requisiti Bassi: È ottimizzato per dispositivi ARM a basso consumo (come Raspberry Pi o Jetson Nano) ma funziona benissimo anche su Windows, Linux e macOS.
Ampio Supporto Linguistico: Supporta oltre 40 lingue e centinaia di voci, spaziando dall’inglese e lo spagnolo a inclusioni più rare come Swahili, Kazako e Gallese.

Livelli di Qualità della Voce

Piper offre voci in quattro livelli per bilanciare qualità e prestazioni:

x_low: Modelli minuscoli (5-7M parametri), estremamente veloci, audio a 16kHz.
low: Piccoli e veloci con una qualità decente.
medium: Il punto di equilibrio (“sweet spot”) per la maggior parte degli utenti; audio a 22kHz con intonazione naturale.
high: I modelli più grandi (28-32M parametri) con la migliore chiarezza, ma richiedono più potenza della CPU.

Casi d’Uso

Grazie alla sua velocità e privacy, è il motore principale utilizzato in:

Home Assistant: È l’impostazione predefinita per il progetto di assistente vocale locale “Year of the Voice”.
Strumenti di Accessibilità: Screen reader o plugin (come l’estensione Piper per VS Code) che necessitano di feedback istantaneo.
E-book Reader: Le persone lo usano spesso per trasformare localmente gli EPUB in audiolibri senza pagare per i crediti delle API cloud.

Addestrare la Tua Voce

Basandosi sulla documentazione ufficiale per addestrare la propria voce, devi prima installare le dipendenze su Linux o Windows (via WSL).

Installazione & Configurazione dell’Ambiente

Installa le dipendenze di sistema:

1
sudo apt-get install build-essential cmake ninja-build espeak-ng

Clona e installa Piper:

1
2
3
4
5
6
7
git clone https://github.com/OHF-voice/piper1-gpl.git 
cd piper1-gpl 
python3 -m venv .venv 
source .venv/bin/activate 
python3 -m pip install -e .[train]

pip install scikit-build cmake ninja

1
2
./build_monotonic_align.sh 
python3 setup.py build_ext --inplace

Troubleshooting

Errore su build_monotonic_align.sh

Se ricevete il seguente errore quando eseguite lo script sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
$ ./build_monotonic_align.sh

Compiling /mnt/d/Projects/piper/piper1-gpl/src/piper/train/vits/monotonic_align/core.pyx because it changed.
[1/1] Cythonizing /mnt/d/Projects/piper/piper1-gpl/src/piper/train/vits/monotonic_align/core.pyx
performance hint: core.pyx:5:0: Exception check on 'maximum_path_each' will always require the GIL to be acquired.
Possible solutions:
        1. Declare 'maximum_path_each' as 'noexcept' if you control the definition and you're sure you don't want the function to raise exceptions.
        2. Use an 'int' return type on 'maximum_path_each' to allow an error code to be returned.
performance hint: core.pyx:36:0: Exception check on 'maximum_path_c' will always require the GIL to be acquired.
Possible solutions:
        1. Declare 'maximum_path_c' as 'noexcept' if you control the definition and you're sure you don't want the function to raise exceptions.
        2. Use an 'int' return type on 'maximum_path_c' to allow an error code to be returned.
performance hint: core.pyx:42:21: Exception check after calling 'maximum_path_each' will always require the GIL to be acquired.
Possible solutions:
        1. Declare 'maximum_path_each' as 'noexcept' if you control the definition and you're sure you don't want the function to raise exceptions.
        2. Use an 'int' return type on 'maximum_path_each' to allow an error code to be returned.

è necessario modificare il file /piper1-gpl/src/piper/train/vits/monotonic_align/core.pyx

1
vi /piper1-gpl/src/piper/train/vits/monotonic_align/core.pyx

Allo snippet di codice

1
cdef void maximum_path_each(...)

aggiungere

1
cdef void maximum_path_each(...) noexcept:

e allo snippet

1
cpdef void maximum_path_c(...)

aggiungere

1
cpdef void maximum_path_c(...) noexcept:

Il codice finale dovrebbe essere questo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
cimport cython
from cython.parallel import prange


@cython.boundscheck(False)
@cython.wraparound(False)
cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) noexcept nogil:
  cdef int x
  cdef int y
  cdef float v_prev
  cdef float v_cur
  cdef float tmp
  cdef int index = t_x - 1

  for y in range(t_y):
    for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
      if x == y:
        v_cur = max_neg_val
      else:
        v_cur = value[y-1, x]
      if x == 0:
        if y == 0:
          v_prev = 0.
        else:
          v_prev = max_neg_val
      else:
        v_prev = value[y-1, x-1]
      value[y, x] += max(v_prev, v_cur)

  for y in range(t_y - 1, -1, -1):
    path[y, index] = 1
    if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):
      index = index - 1


@cython.boundscheck(False)
@cython.wraparound(False)
cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) noexcept nogil:
  cdef int b = paths.shape[0]
  cdef int i
  for i in prange(b, nogil=True):
    maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i])

Preparare il Tuo Dataset (Esempio Dataset Italiano)

A. File Audio (.wav)

Registra te stesso mentre parli in una stanza silenziosa (senza eco/rumore).
Salva i file come WAV.
Idealmente, convertili in 22050 Hz, 16-bit, Mono (Piper può processarne altri, ma questo è il formato target).
Mettili tutti in una cartella, es. /home/user/my-voice-dataset/wavs/.

B. I Metadati (metadata.csv)

Crea un file chiamato metadata.csv. Deve usare il simbolo pipe | come separatore.

Formato: nomefile.wav|Testo italiano qui

C. Esempio di Dataset

(Vedi la sezione originale per l’elenco delle frasi in italiano, sono già perfette).

Consigli di Registrazione per la Migliore Qualità:

Coerenza: Cerca di registrare tutto in un’unica sessione in modo che il tono della voce e la distanza dal microfono rimangano gli stessi.
Silenzio: Lascia 0,5 secondi di silenzio all’inizio e alla fine di ogni registrazione.
Formato: Se possibile, imposta il tuo software di registrazione (come Audacity) per salvare come Mono, 22050Hz, 16-bit WAV.
Performance: Leggi in modo naturale! Se leggi come un robot, l’AI suonerà come un robot. Se leggi con emozione, l’AI imparerà quell’emozione.

Scaricare un Checkpoint Base

La documentazione raccomanda vivamente di usare un checkpoint esistente (“finetuning”) piuttosto che addestrare da zero. Questo rende il processo molto più veloce e richiede meno dati (15-30 minuti di audio sono spesso sufficienti per un risultato decente).

Vai alla pagina Hugging Face dei Checkpoint di Piper.
Scarica un checkpoint di qualità medium (*.ckpt).
- Suggerimento: Se riesci a trovare un checkpoint italiano (come it_IT-riccardo-medium.ckpt), è l’ideale.
- Se no, uno inglese (come en_US-sam-medium.ckpt) funzionerà comunque; il modello “imparerà” l’accento italiano dai tuoi dati.
Posizionalo in un luogo accessibile, es. /home/user/piper-checkpoints/epoch=2000.ckpt.

Consiglio non richiesto: Scegliete preferibilmente modelli più recenti rispetto a quelli più vecchi, se non volete avere problemi con la configurazione.

Workaround Versioni vecchie di Piper

In accordo alla documentazione ufficiale Only medium quality checkpoints are supported without tweaking other settings., significa che solo i checkpoints Medium quality funzionano con l’ultima versione di Piper. Infatti molti checkpoints presenti nel repository huggingface non funzioneranno con l’attuale versione di piper e richiedono questa configurazione https://github.com/rhasspy/piper/blob/9b1c6397698b1da11ad6cca2b318026b628328ec/src/python/piper_train/vits/config.py#L20

Eseguire il Comando di Training

Questo è il comando personalizzato per la tua voce Italiana.

--data.espeak_voice "it": Questo dice al sistema di pronunciare il testo usando le regole italiane.
Percorsi: Aggiorna i segnaposto /path/to/... con le posizioni reali dei tuoi file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
python3 -m piper.train fit \
  --data.voice_name "my_italian_voice" \
  --data.csv_path /home/user/my-voice-dataset/metadata.csv \
  --data.audio_dir /home/user/my-voice-dataset/wavs/ \
  --model.sample_rate 22050 \
  --data.espeak_voice "it" \
  --data.cache_dir /home/user/my-voice-dataset/cache/ \
  --data.config_path /home/user/my-voice-dataset/config.json \
  --data.batch_size 32 \
  --ckpt_path /home/user/piper-checkpoints/epoch=2000.ckpt

Workaround

Hardware Warning

Hardware Warning: Se hai una GPU con meno di 24GB di VRAM (come una RTX 3060 o 4070), potresti ricevere un errore “Out of Memory”. Se succede, abbassa la dimensione del batch: Cambia --data.batch_size 32 in 16 o 8.

ImportError: cannot import name ’espeakbridge

Significa che manca il file compilato espeakbridge.so

1
2
sudo apt update
sudo apt install espeak-ng libespeak-ng-dev

Compila il modulo mancante:

1
2
3
4
5
# Install missing module 
python3 setup.py build_ext --inplace

# Test it
ls -l src/piper/espeakbridge*.so

Monitorare l’avanzamento:

Apri un altro terminale linux, attiva l’ambiente (venv di python nel piper folder) e lancia TensorBoard:

1
tensorboard --logdir tensorboard --logdir /mnt/d/Projects/piper/piper1-gpl/lightning_logs

Apri il browser su Windows e vai all’indirizzo che appare (di solito localhost:6006) per vedere i grafici e ascoltare le anteprime audio.

Esportare il modello finale (.onnx):

Una volta soddisfatto (quando la “loss” nel grafico smette di scendere e l’audio suona bene), devi convertire il checkpoint .ckpt in un file .onnx utilizzabile.

Trova il file .ckpt più recente in /mnt/c/piper_training/output_model/lightning_logs/version_0/checkpoints/.

1
2
3
python3 -m piper_train.export_onnx \
    /mnt/c/piper_training/output_model/lightning_logs/version_0/checkpoints/epoch=XXXX.ckpt \
    /mnt/c/piper_training/final_model.onnx

Questo creerà final_model.onnx e final_model.onnx.json pronti per essere usati con Piper TTS.

Esportare la Tua Voce

Una volta terminato l’addestramento (o quando lo fermi perché la “loss” è abbastanza bassa), esporta il modello in formato ONNX per utilizzarlo.

1
2
3
python3 -m piper.train.export_onnx \
  --checkpoint /home/user/my-voice-dataset/logs/lightning_logs/version_0/checkpoints/last.ckpt \
  --output-file /home/user/my_italian_voice.onnx

Passaggi Finali:

Rinomina il tuo file config: cp /home/user/my-voice-dataset/config.json my_italian_voice.onnx.json
Ora hai la coppia necessaria per usare la voce:
- my_italian_voice.onnx
- my_italian_voice.onnx.json