Parallel Tacotron2

Tacotron parallèle2

Pytorch Implémentation du Tacotron parallèle de Google 2: un modèle TTS neuronal non autorégressif avec modélisation de durée différenciable

Mises à jour

• 2021.05.25: Only the soft-DTW remains the last hurdle! Suite aux conseils de l'auteur sur la mise en œuvre, j'ai passé plusieurs tests sur chaque module un par un sous un signal de durée supervisé avec L1 Loss (FastSpeech2). Jusqu'à présent, je peux confirmer que tous les modules sauf Soft-DTW fonctionnent bien comme suit (spectrogramme synthétisé, spectrogramme GT, alignement résiduel et W de l'échantillonnage d'apprentissage de haut en bas).

  

  Pour les détails, veuillez consulter le dernier journal de validation et la section des problèmes d'implémentation mis à jour. En outre, vous pouvez trouver les expériences en cours sur https://github.com/keonlee9420/fastSpeech2/commits/ptaco2.

• 2021.05.15: Implémentation effectuée. Vérification de la santé mentale sur la formation et l'inférence. Mais le modèle ne peut toujours pas converger.

  I'm waiting for your contribution! Veuillez m'informer si vous trouvez des erreurs dans ma mise en œuvre ou des conseils précieux pour former le modèle avec succès. Voir la section des problèmes de mise en œuvre.

Entraînement

Exigences

• Vous pouvez installer les dépendances Python avec

  pip3 install -r requirements.txt

• Installez Fairseq (document officiel, GitHub) pour utiliser LConvBlock . Veuillez vérifier le n ° 5 pour résoudre tout problème lors de l'installation.

Ensembles de données

Les ensembles de données pris en charge:

• LJSPEECH: Un ensemble de données anglais à un seul haut-parleur se compose de 13100 clips audio courts d'une conférencière de lecture féminine de 7 livres non-fiction, environ 24 heures au total.
• (sera ajouté plus)

Prétraitement

Après avoir téléchargé les ensembles de données, définissez le corpus_path dans preprocess.yaml et exécutez le script de préparation:

 python3 prepare_data.py config/LJSpeech/preprocess.yaml

Ensuite, exécutez le script de prétraitement:

 python3 preprocess.py config/LJSpeech/preprocess.yaml

Entraînement

Former votre modèle avec

 python3 train.py -p config/LJSpeech/preprocess.yaml -m config/LJSpeech/model.yaml -t config/LJSpeech/train.yaml

Le modèle ne peut pas encore converger. Je débogage mais ce serait stimulé si votre contribution impressionnante est prête!

Inférence

Inférence

Pour une seule inférence, courez

 python3 synthesize.py --text "YOUR_DESIRED_TEXT" --restore_step 900000 --mode single -p config/LJSpeech/preprocess.yaml -m config/LJSpeech/model.yaml -t config/LJSpeech/train.yaml

Les énoncés générés seront enregistrés en output/result/ .

Inférence par lots

L'inférence par lots est également prise en charge, essayez

 python3 synthesize.py --source preprocessed_data/LJSpeech/val.txt --restore_step 900000 --mode batch -p config/LJSpeech/preprocess.yaml -m config/LJSpeech/model.yaml -t config/LJSpeech/train.yaml

Pour synthétiser toutes les énoncés dans preprocessed_data/LJSpeech/val.txt .

Tensorboard

Utiliser

 tensorboard --logdir output/log/LJSpeech

pour servir Tensorboard sur votre hôte local.

Problèmes de mise en œuvre

Dans l'ensemble, la normalisation ou l'activation, qui n'est pas suggérée dans l'article d'origine, est correctement organisée pour empêcher la valeur NAN (gradient) sur les calculs avant et arrière. (Nan indique que quelque chose ne va pas dans le réseau)

Encodeur de texte

1. Utilisez le FFTBlock de FASTSPEECH2 pour le bloc transformateur de l'encodeur de texte.
2. Utilisez Dropout 0.2 pour le ConvBlock de l'encodeur de texte.
3. Pour restaurer le "moteur de normalisation propriétaire",
   • Appliquez la même normalisation du texte que dans FastSpeech2.
   • Implémentez la fonction grapheme_to_phoneme . (Voir ./text/ init ).

Encodeur résiduel

1. Utilisez 80 channels MEL-Spectrogrom au lieu de 128-bin .
2. L'intégration régulière de positionnel sinusoïdal est utilisée au niveau du cadre au lieu de combinaisons de trois incorporations de position dans le tacotron parallèle. Comme le modèle dépend entièrement de l'apprentissage non supervisé pour le poste, ce choix peut être une raison des échecs sur le modèle de converge.

Durée Prédictrice et échantillonnage appris

1. Utilisez nn.SiLU() pour l'activation de swish.
2. Lors de l'obtention W et C , le fonctionnement de la concaténation est appliqué entre S , E et V après le domaine trame (domaine T) de V

Décodeur

1. Utilisez LConvBlock et l'intégration régulière de la position sinusoïdale.
2. Le spectrogramme itératif de la MEL est projeté par une couche linéaire.
3. Appliquer nn.Tanh() à chaque sortie LConvBLock (suivant le modèle d'activation de la partie du décodeur dans FastSpeech2).

Perte

1. Utilisez l'optimisation et le planificateur de FastSpeech2 (qui est de l'attention est tout ce dont vous avez besoin comme décrit dans l'article d'origine).
2. Base sur Pytorch-Softdtw-Cuda (Post) pour le soft-dtw.
   1. Implémentez Soft-DTW personnalisé dans model/soft_dtw_cuda.py , reflétant la récursivité suggérée dans l'article d'origine.
   2. Dans le Soft-DTW d'origine, la perte finale n'est pas supposée et donc seul E est calculé. Mais employé comme fonction de perte, le produit jacobien est ajouté pour renvoyer la cible dérivée de l'entrée R WRT X .
   3. Actuellement, la taille maximale du lot est 8 en GPU 24GIB (TITAN RTX) en raison du problème de complexité de l'espace dans la perte Soft-DTW.
      • Dans l'article d'origine, une opération de bande diagonale différenciable personnalisée a été mise en œuvre et utilisée pour résoudre la complexité d'O (t ^ 2), mais cette partie n'a pas encore été explorée dans l'implémentation actuelle.

Citation

 @misc{lee2021parallel_tacotron2,
  author = {Lee, Keon},
  title = {Parallel-Tacotron2},
  year = {2021},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {url{https://github.com/keonlee9420/Parallel-Tacotron2}}
}

Références

• FastSpeech2 de Ming024 (plus tard que 2021.02.26 ver.)
• Tacotron parallèle: TTS non autorégressif et contrôlable
• Tacotron parallèle 2: un modèle TTS neural non autorégressif avec modélisation de durée différenable