Paradis-TTS 0.1.4 — progression du téléchargement et logs

Paradis-TTS 0.1.4

La bibliothèque indique désormais ce qu'elle fait dès ParadisTTS() :
téléchargement Hugging Face avec progression, vérification SHA256, extraction,
utilisation du cache, chargement CPU et confirmation que le modèle est prêt.

Les messages sont activés par défaut et envoyés sur stderr. Ils peuvent être
désactivés avec ParadisTTS(verbose=False), download_model(verbose=False) ou
paradis-tts synthesize --quiet. La synthèse n'ajoute pas de logs par phrase et
le rapport JSON de la CLI reste exploitable sur stdout.

Les poids, le post-traitement et le cache des modèles v0.1.3 sont conservés.
Une mise à jour du package ne retélécharge pas un modèle déjà en cache.
Les archives de modèles restent disponibles dans la
release v0.1.3.

Validation : dix tests d'API, dont la progression au premier téléchargement,
la réutilisation du cache, le mode silencieux avec transfert Hugging Face de
secours et les erreurs de chargement. La publication vérifie aussi un vrai
téléchargement et une synthèse CPU depuis le wheel installé.

Paradis-TTS v0.1.3 — faster CPU postprocessing

Paradis-TTS 0.1.3

La 0.1.3 réduit le coût du post-traitement CPU. L'adoucissement dynamique à
1 dB est désactivé après comparaison d'écoute et validation par l'auteur.
Phase 97, présence jusqu'à 2,5 dB et adoucissement des aigus à 1,5 dB restent
actifs par défaut, avec compensation de niveau. Attaques, syllabes et lissage
restent à zéro. Le filtre dynamique reste accessible par réglage explicite.

Les optimisations réutilisent les spectres, les fenêtres et les courbes de
gain, limitent les calculs aux bandes utiles et reconstruisent le signal
par blocs NumPy. Le calcul audio ne dépend que de NumPy et ONNX Runtime.
Le client officiel Hugging Face est ajouté pour récupérer une archive si le
téléchargement HTTP direct arrive incomplet ; les SHA256 restent vérifiés.

Les poids FP32 et INT8, EMA et bruts, sont identiques à la 0.1.2 : modèle texte
à 8 000 étapes et décodeur final à 10 000 étapes de continuation GAN.
Les archives sont renouvelées pour inclure le code, les réglages et les WAV
de démonstration à jour ; les anciennes releases et leurs hashes sont conservés.

python -m pip install --upgrade paradis-tts

from paradis_tts import ParadisTTS

tts = ParadisTTS()  # EMA FP32, post-traitement actif sans adoucissement dynamique
audio = tts("Bonjour tout le monde.")
tts.save(audio, "bonjour.wav")

Le premier appel du constructeur télécharge les poids depuis une révision
Hugging Face figée et vérifie les SHA256. model_folder=... charge un dossier
local sans téléchargement. Les anciens dossiers de modèles utilisent aussi
le nouveau défaut à 0 dB avec ce runtime ; un objet PostProcessing explicite
conserve tous ses réglages.

La comparaison CPU française porte sur 40 phrases × quatre passages par moteur,
avec deux threads sur un Ryzen 7 5800H. Générer 10 secondes de voix demande
0,695 s pour Paradis FP32/INT8, 0,570 s pour Piper fr_FR-siwis-medium et
5,924 s pour Kokoro ff_siwis. Phonémisation et post-traitements inclus ;
chargement exclu. Voir les mesures et limites dans evaluation/speed_20261016/.
Les résultats ne constituent pas un classement de qualité. Le benchmark utilise
le candidat de la release ; seuls la version et les liens de distribution ont
changé depuis la mesure, pas les calculs audio ni les poids.

Les scores WER/DNSMOS historiques de v0 ne sont pas recalculés et ne doivent
pas être attribués aux poids EMA actuels. La naturalité reste à juger à l'écoute.

Paradis-TTS v0.1.2 - EMA finale

La moyenne EMA finale du décodeur A affiné, à 10 000 étapes de continuation GAN,
devient la version par défaut. Le modèle texte à 8 000 étapes et le post-traitement
restent identiques.

python -m pip install --upgrade paradis-tts==0.1.2

from paradis_tts import ParadisTTS

tts = ParadisTTS()                         # EMA finale, FP32
audio = tts("Bonjour tout le monde.")
tts.save(audio, "bonjour.wav")

tts = ParadisTTS(variant="int8")            # EMA finale, INT8
tts = ParadisTTS(weight_kind="raw")         # poids bruts finaux, FP32
tts = ParadisTTS(weight_kind="raw", variant="int8")

Les quatre archives jointes contiennent les vrais graphes ONNX, le runtime
Python, les profils de post-traitement et des exemples WAV. Les fichiers
paradis_tts_fp32.zip et paradis_tts_int8.zip utilisent l'EMA ; les archives
paradis_tts_raw_* utilisent les poids bruts finaux.

Téléchargement automatique depuis une révision Hugging Face épinglée,
vérification SHA256 et caches séparés par version/type de poids/précision.
model_folder=... reste disponible pour les fichiers locaux.

Validations : parité PyTorch/ONNX, excitation et post-traitement NumPy, quatre
archives hors ligne sans Torch/Kokoro, tests du wheel installé et des caches.
Les scores WER/DNSMOS historiques de la v0 n'ont pas été recalculés pour ces poids.

Modèles et écoutes Hugging Face ·
Documentation

Paradis-TTS v0

Première release publique de Paradis-TTS, synthèse vocale française mono-voix
sur CPU, distillée depuis Kokoro ff_siwis avec la méthode Paradee.

• 8 082 881 paramètres, audio mono 24 kHz.
• Archives ONNX FP32 et INT8, avec exemples WAV et code d'inférence.
• Post-traitement inclus et activé par défaut : phase 97, présence, adoucissement
  dynamique à 1 dB et haut du spectre à 1,5 dB.
• Package Python 0.1.0 : wheel et archive source, sans PyTorch ni Kokoro requis.
• Évaluation publiée sur 300 phrases inédites, avec Kokoro et Piper :
  WER, DNSMOS P.835, RTF, RAM et scores par phrase.

Installer

python -m pip install https://github.com/IvannP39/Paradis-TTS-release/releases/download/v0/paradis_tts-0.1.0-py3-none-any.whl

from paradis_tts import ParadisTTS

tts = ParadisTTS()
audio = tts("Bonjour tout le monde.")
tts.save(audio, "bonjour.wav")

post_traitement=False désactive les filtres. variant="int8" sélectionne les
poids compacts. Le modèle est téléchargé une fois, contrôlé par SHA256 et mis
en cache pour les utilisations hors ligne. Python 3.10–3.12.

Le wheel est installable directement depuis cette release. Il n'est pas
encore publié dans l'index PyPI ; les distributions et le workflow de
publication sont prêts pour le propriétaire du projet.

Modèle et limites

Snapshot figé au début de la préparation : texte à 8 000 étapes, décodeur A
affiné au last brut de la continuation GAN à 6 500 étapes, sans EMA.
Une seule voix, français uniquement ; un grain résiduel peut rester audible.
L'INT8 compresse les poids mais les calculs restent flottants. Les mesures CPU
proviennent d'un portable partagé avec d'autres tâches ; aucun classement de
vitesse en conditions isolées ni MOS humain n'est revendiqué.

Écouter sur Hugging Face ·
Protocole et résultats ·
Documentation Python

Les assets incluent SHA256SUMS, provenance.json et evaluation_report.json.
Code et poids Apache-2.0, textes CC BY-SA et G2P avec composants GPL : voir les
notices de licence et d'attribution. Le dépôt de travail et son historique
restent privés ; ce dépôt public contient la distribution et son code runtime.