From b09b6ad05c4cdc746f261345e4adb659852fae8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?ns=CA=87n=C9=BE=20=CA=87=C7=9D=C9=B9=C9=94=C7=9Ds?= <92639080+SECRET-GUEST@users.noreply.github.com> Date: Mon, 4 Sep 2023 04:00:53 +0200 Subject: [PATCH] Added french FAQ (#1185) --- README.md | 2 +- docs/fr/Changelog_FR.md | 102 ++++++++++++++++++++++ docs/fr/README.fr.md | 146 +++++++++++++++++++++++++++++++ docs/fr/faiss_tips_fr.md | 105 ++++++++++++++++++++++ docs/fr/faq_fr.md | 169 ++++++++++++++++++++++++++++++++++++ docs/fr/training_tips_fr.md | 65 ++++++++++++++ 6 files changed, 588 insertions(+), 1 deletion(-) create mode 100644 docs/fr/Changelog_FR.md create mode 100644 docs/fr/README.fr.md create mode 100644 docs/fr/faiss_tips_fr.md create mode 100644 docs/fr/faq_fr.md create mode 100644 docs/fr/training_tips_fr.md diff --git a/README.md b/README.md index 795a8bb..f221877 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ ------ -[**English**](./docs/en/README.en.md) | [**中文简体**](./README.md) | [**日本語**](./docs/jp/README.ja.md) | [**한국어**](./docs/kr/README.ko.md) ([**韓國語**](./docs/kr/README.ko.han.md)) | [**Türkçe**](./docs/tr/README.tr.md) +[**English**](./docs/en/README.en.md) | [**中文简体**](./README.md) | [**日本語**](./docs/jp/README.ja.md) | [**한국어**](./docs/kr/README.ko.md) ([**韓國語**](./docs/kr/README.ko.han.md)) | [**Français**](./docs/fr/README.fr.md)| [**Türkçe**](./docs/tr/README.tr.md) 点此查看我们的[演示视频](https://www.bilibili.com/video/BV1pm4y1z7Gm/) ! diff --git a/docs/fr/Changelog_FR.md b/docs/fr/Changelog_FR.md new file mode 100644 index 0000000..a0b4e07 --- /dev/null +++ b/docs/fr/Changelog_FR.md @@ -0,0 +1,102 @@ +### 2023-08-13 +1-Corrections régulières de bugs +- Modification du nombre total d'époques minimum à 1 et changement du nombre total d'époques minimum à 2 +- Correction des erreurs d'entraînement sans utiliser de modèles pré-entraînés +- Après la séparation des voix d'accompagnement, libération de la mémoire graphique +- Changement du chemin absolu d'enregistrement de faiss en chemin relatif +- Prise en charge des chemins contenant des espaces (le chemin du jeu de données d'entraînement et le nom de l'expérience sont pris en charge, et aucune erreur ne sera signalée) +- La liste de fichiers annule l'encodage utf8 obligatoire +- Résolution du problème de consommation de CPU causé par la recherche faiss lors des changements de voix en temps réel + +2-Mises à jour clés +- Entraînement du modèle d'extraction de hauteur vocale open-source le plus puissant actuel, RMVPE, et utilisation pour l'entraînement, l'inférence hors ligne/en temps réel de RVC, supportant PyTorch/Onnx/DirectML +- Prise en charge des cartes graphiques AMD et Intel via Pytorch_DML + +(1) Changement de voix en temps réel (2) Inférence (3) Séparation de l'accompagnement vocal (4) L'entraînement n'est pas actuellement pris en charge, passera à l'entraînement CPU; prend en charge l'inférence RMVPE de la GPU par Onnx_Dml + +### 2023-06-18 +- Nouveaux modèles pré-entraînés v2 : 32k et 48k +- Correction des erreurs d'inférence du modèle non-f0 +- Pour un jeu de données d'entraînement dépassant 1 heure, réalisation automatique de minibatch-kmeans pour réduire la forme des caractéristiques, afin que l'entraînement, l'ajout et la recherche d'index soient beaucoup plus rapides. +- Fourniture d'un espace huggingface vocal2guitar jouet +- Suppression automatique des audios de jeu de données d'entraînement court-circuitant les valeurs aberrantes +- Onglet d'exportation Onnx + +Expériences échouées: +- ~~Récupération de caractéristiques : ajout de la récupération de caractéristiques temporelles : non efficace~~ +- ~~Récupération de caractéristiques : ajout de la réduction de dimensionnalité PCAR : la recherche est encore plus lente~~ +- ~~Augmentation aléatoire des données lors de l'entraînement : non efficace~~ + +Liste de tâches: +- ~~Vocos-RVC (vocodeur minuscule) : non efficace~~ +- ~~Support de Crepe pour l'entraînement : remplacé par RMVPE~~ +- ~~Inférence de précision à moitié crepe : remplacée par RMVPE. Et difficile à réaliser.~~ +- Support de l'éditeur F0 + +### 2023-05-28 +- Ajout d'un cahier v2, changelog coréen, correction de certaines exigences environnementales +- Ajout d'un mode de protection des consonnes muettes et de la respiration +- Support de la détection de hauteur crepe-full +- Séparation vocale UVR5 : support des modèles de déréverbération et de désécho +- Ajout du nom de l'expérience et de la version sur le nom de l'index +- Support pour les utilisateurs de sélectionner manuellement le format d'exportation des audios de sortie lors du traitement de conversion vocale en lots et de la séparation vocale UVR5 +- L'entraînement du modèle v1 32k n'est plus pris en charge + +### 2023-05-13 +- Nettoyage des codes redondants de l'ancienne version du runtime dans le package en un clic : lib.infer_pack et uvr5_pack +- Correction du bug de multiprocessus pseudo dans la préparation du jeu de données d'entraînement +- Ajout de l'ajustement du rayon de filtrage médian pour l'algorithme de reconnaissance de hauteur de récolte +- Prise en charge du rééchantillonnage post-traitement pour l'exportation audio +- Réglage de multi-traitement "n_cpu" pour l'entraînement est passé de "extraction f0" à "prétraitement des données et extraction f0" +- Détection automatique des chemins d'index sous le dossier de logs et fourniture d'une fonction de liste déroulante +- Ajout de "Questions fréquemment posées et réponses" sur la page d'onglet (vous pouvez également consulter le wiki github RVC) +- Lors de l'inférence, la hauteur de la récolte est mise en cache lors de l'utilisation du même chemin d'accès audio d'entrée (objectif : en utilisant l'extraction de + + la hauteur de la récolte, l'ensemble du pipeline passera par un long processus d'extraction de la hauteur répétitif. Si la mise en cache n'est pas utilisée, les utilisateurs qui expérimentent différents timbres, index, et réglages de rayon de filtrage médian de hauteur connaîtront un processus d'attente très douloureux après la première inférence) + +### 2023-05-14 +- Utilisation de l'enveloppe de volume de l'entrée pour mixer ou remplacer l'enveloppe de volume de la sortie (peut atténuer le problème du "muet en entrée et bruit de faible amplitude en sortie". Si le bruit de fond de l'audio d'entrée est élevé, il n'est pas recommandé de l'activer, et il n'est pas activé par défaut (1 peut être considéré comme n'étant pas activé) +- Prise en charge de la sauvegarde des modèles extraits à une fréquence spécifiée (si vous voulez voir les performances sous différentes époques, mais que vous ne voulez pas sauvegarder tous les grands points de contrôle et extraire manuellement les petits modèles par ckpt-processing à chaque fois, cette fonctionnalité sera très pratique) +- Résolution du problème des "erreurs de connexion" causées par le proxy global du serveur en définissant des variables d'environnement +- Prise en charge des modèles pré-entraînés v2 (actuellement, seule la version 40k est disponible au public pour les tests, et les deux autres taux d'échantillonnage n'ont pas encore été entièrement entraînés) +- Limite le volume excessif dépassant 1 avant l'inférence +- Réglages légèrement ajustés de la préparation du jeu de données d'entraînement + +####################### + +Historique des changelogs: + +### 2023-04-09 +- Correction des paramètres d'entraînement pour améliorer le taux d'utilisation du GPU : A100 est passé de 25% à environ 90%, V100 : de 50% à environ 90%, 2060S : de 60% à environ 85%, P40 : de 25% à environ 95% ; amélioration significative de la vitesse d'entraînement +- Changement de paramètre : la taille de batch_size totale est maintenant la taille de batch_size par GPU +- Changement de total_epoch : la limite maximale est passée de 100 à 1000 ; la valeur par défaut est passée de 10 à 20 +- Correction du problème d'extraction de ckpt reconnaissant la hauteur de manière incorrecte, causant une inférence anormale +- Correction du problème d'entraînement distribué sauvegardant ckpt pour chaque rang +- Application du filtrage des caractéristiques nan pour l'extraction des caractéristiques +- Correction du problème d'entrée/sortie silencieuse produisant des consonnes aléatoires ou du bruit (les anciens modèles doivent être réentraînés avec un nouveau jeu de données) + +### 2023-04-16 Mise à jour +- Ajout d'une mini-interface graphique pour le changement de voix en temps réel, démarrage par double-clic sur go-realtime-gui.bat +- Application d'un filtrage pour les bandes de fréquences inférieures à 50Hz pendant l'entraînement et l'inférence +- Abaissement de l'extraction de hauteur minimale de pyworld du défaut 80 à 50 pour l'entraînement et l'inférence, permettant aux voix masculines graves entre 50-80Hz de ne pas être mises en sourdine +- WebUI prend en charge le changement de langue en fonction des paramètres régionaux du système (prise en charge actuelle de en_US, ja_JP, zh_CN, zh_HK, zh_SG, zh_TW ; défaut à en_US si non pris en charge) +- Correction de la reconnaissance de certains GPU (par exemple, échec de reconnaissance V100-16G, échec de reconnaissance P4) + +### 2023-04-28 Mise à jour +- Mise à niveau des paramètres d'index de faiss pour une vitesse plus rapide et une meilleure qualité +- Suppression de la dépendance à total_npy ; le partage futur de modèles ne nécessitera pas d'entrée total + +_npy +- Levée des restrictions pour les GPU de la série 16, fournissant des paramètres d'inférence de 4 Go pour les GPU VRAM de 4 Go +- Correction d'un bug dans la séparation vocale d'accompagnement UVR5 pour certains formats audio +- La mini-interface de changement de voix en temps réel prend maintenant en charge les modèles de hauteur non-40k et non-lazy + +### Plans futurs : +Fonctionnalités : +- Ajouter une option : extraire de petits modèles pour chaque sauvegarde d'époque +- Ajouter une option : exporter un mp3 supplémentaire vers le chemin spécifié pendant l'inférence +- Prise en charge de l'onglet d'entraînement multi-personnes (jusqu'à 4 personnes) + +Modèle de base : +- Collecter des fichiers wav de respiration pour les ajouter au jeu de données d'entraînement pour résoudre le problème des sons de respiration déformés +- Nous entraînons actuellement un modèle de base avec un jeu de données de chant étendu, qui sera publié à l'avenir diff --git a/docs/fr/README.fr.md b/docs/fr/README.fr.md new file mode 100644 index 0000000..54f00e0 --- /dev/null +++ b/docs/fr/README.fr.md @@ -0,0 +1,146 @@ +
+ +

Retrieval-based-Voice-Conversion-WebUI

+Un framework simple et facile à utiliser pour la conversion vocale (modificateur de voix) basé sur VITS

+ +[![madewithlove](https://img.shields.io/badge/made_with-%E2%9D%A4-red?style=for-the-badge&labelColor=orange +)](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI) + +
+ +[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb) +[![Licence](https://img.shields.io/badge/LICENSE-MIT-green.svg?style=for-the-badge)](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/blob/main/LICENSE) +[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-yellow.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/) + +[![Discord](https://img.shields.io/badge/RVC%20Developers-Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/HcsmBBGyVk) + +[**Journal de mise à jour**](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/blob/main/docs/Changelog_CN.md) | [**FAQ**](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98%E8%A7%A3%E7%AD%94) | [**AutoDL·Formation d'un chanteur AI pour 5 centimes**](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/wiki/Autodl%E8%AE%AD%E7%BB%83RVC%C2%B7AI%E6%AD%8C%E6%89%8B%E6%95%99%E7%A8%8B) | [**Enregistrement des expériences comparatives**](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/wiki/%E5%AF%B9%E7%85%A7%E5%AE%9E%E9%AA%8C%C2%B7%E5%AE%9E%E9%AA%8C%E8%AE%B0%E5%BD%95)) | [**Démonstration en ligne**](https://huggingface.co/spaces/Ricecake123/RVC-demo) + +
+ +------ + +[**English**](./docs/en/README.en.md) |[ **中文简体**](./docs/cn/README.md) | [**日本語**](./docs/jp/README.ja.md) | [**한국어**](./docs/kr/README.ko.md) ([**韓國語**](./docs/kr/README.ko.han.md)) | [**Turc**](./docs/tr/README.tr.md) + +Cliquez ici pour voir notre [vidéo de démonstration](https://www.bilibili.com/video/BV1pm4y1z7Gm/) ! + +> Conversion vocale en temps réel avec RVC : [w-okada/voice-changer](https://github.com/w-okada/voice-changer) + +> Le modèle de base est formé avec près de 50 heures de données VCTK de haute qualité et open source. Aucun souci concernant les droits d'auteur, n'hésitez pas à l'utiliser. + +> Attendez-vous au modèle de base RVCv3 : plus de paramètres, plus de données, de meilleurs résultats, une vitesse d'inférence presque identique, et nécessite moins de données pour la formation. + +## Introduction +Ce dépôt a les caractéristiques suivantes : ++ Utilise le top1 pour remplacer les caractéristiques de la source d'entrée par les caractéristiques de l'ensemble d'entraînement pour éliminer les fuites de timbre vocal. ++ Peut être formé rapidement même sur une carte graphique relativement moins performante. ++ Obtient de bons résultats même avec peu de données pour la formation (il est recommandé de collecter au moins 10 minutes de données vocales avec un faible bruit de fond). ++ Peut changer le timbre vocal en fusionnant des modèles (avec l'aide de l'onglet ckpt-merge). ++ Interface web simple et facile à utiliser. ++ Peut appeler le modèle UVR5 pour séparer rapidement la voix et l'accompagnement. ++ Utilise l'algorithme de pitch vocal le plus avancé [InterSpeech2023-RMVPE](#projets-référencés) pour éliminer les problèmes de voix muette. Meilleurs résultats, plus rapide que crepe_full, et moins gourmand en ressources. ++ Support d'accélération pour les cartes A et I. + +## Configuration de l'environnement +Exécutez les commandes suivantes dans un environnement Python de version supérieure à 3.8. + +(Windows/Linux) +Installez d'abord les dépendances principales via pip : +```bash +# Installez Pytorch et ses dépendances essentielles, sautez si déjà installé. +# Voir : https://pytorch.org/get-started/locally/ +pip install torch torchvision torchaudio + +# Pour les utilisateurs de Windows avec une architecture Nvidia Ampere (RTX30xx), en se basant sur l'expérience #21, spécifiez la version CUDA correspondante pour Pytorch. +# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117 +``` + +Vous pouvez utiliser poetry pour installer les dépendances : +```bash +# Installez l'outil de gestion des dépendances Poetry, sautez si déjà installé. +# Voir : https://python-poetry.org/docs/#installation +curl -sSL https://install.python-poetry.org | python3 - + +# Installez les dépendances avec poetry. +poetry install +``` + +Ou vous pouvez utiliser pip pour installer les dépendances : +```bash +Cartes Nvidia : + +pip install -r requirements.txt + +Cartes AMD/Intel : +pip install - + +r requirements-dml.txt + +``` + +------ +Les utilisateurs de Mac peuvent exécuter `run.sh` pour installer les dépendances : +```bash +sh ./run.sh +``` + +## Préparation d'autres modèles pré-entraînés +RVC nécessite d'autres modèles pré-entraînés pour l'inférence et la formation. + +Vous pouvez télécharger ces modèles depuis notre [espace Hugging Face](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/). + +Voici une liste des modèles et autres fichiers requis par RVC : +```bash +./assets/hubert/hubert_base.pt + +./assets/pretrained + +./assets/uvr5_weights + +Pour tester la version v2 du modèle, téléchargez également : + +./assets/pretrained_v2 + +Si vous utilisez Windows, vous pourriez avoir besoin de ces fichiers pour ffmpeg et ffprobe, sautez cette étape si vous avez déjà installé ffmpeg et ffprobe. Les utilisateurs d'ubuntu/debian peuvent installer ces deux bibliothèques avec apt install ffmpeg. Les utilisateurs de Mac peuvent les installer avec brew install ffmpeg (prérequis : avoir installé brew). + +./ffmpeg + +https://huggingface.co/lj1995/VoiceConversionWebUI/blob/main/ffmpeg.exe + +./ffprobe + +https://huggingface.co/lj1995/VoiceConversionWebUI/blob/main/ffprobe.exe + +Si vous souhaitez utiliser le dernier algorithme RMVPE de pitch vocal, téléchargez les paramètres du modèle de pitch et placez-les dans le répertoire racine de RVC. + +https://huggingface.co/lj1995/VoiceConversionWebUI/blob/main/rmvpe.pt + + Les utilisateurs de cartes AMD/Intel nécessitant l'environnement DML doivent télécharger : + + https://huggingface.co/lj1995/VoiceConversionWebUI/blob/main/rmvpe.onnx + +``` +Ensuite, exécutez la commande suivante pour démarrer WebUI : +```bash +python infer-web.py +``` + +Si vous utilisez Windows ou macOS, vous pouvez télécharger et extraire `RVC-beta.7z`. Les utilisateurs de Windows peuvent exécuter `go-web.bat` pour démarrer WebUI, tandis que les utilisateurs de macOS peuvent exécuter `sh ./run.sh`. + +Il y a également un `Guide facile pour les débutants.doc` inclus pour référence. + +## Crédits ++ [ContentVec](https://github.com/auspicious3000/contentvec/) ++ [VITS](https://github.com/jaywalnut310/vits) ++ [HIFIGAN](https://github.com/jik876/hifi-gan) ++ [Gradio](https://github.com/gradio-app/gradio) ++ [FFmpeg](https://github.com/FFmpeg/FFmpeg) ++ [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui) ++ [audio-slicer](https://github.com/openvpi/audio-slicer) ++ [Extraction de la hauteur vocale : RMVPE](https://github.com/Dream-High/RMVPE) + + Le modèle pré-entraîné a été formé et testé par [yxlllc](https://github.com/yxlllc/RMVPE) et [RVC-Boss](https://github.com/RVC-Boss). + +## Remerciements à tous les contributeurs pour leurs efforts + + + diff --git a/docs/fr/faiss_tips_fr.md b/docs/fr/faiss_tips_fr.md new file mode 100644 index 0000000..7fde76a --- /dev/null +++ b/docs/fr/faiss_tips_fr.md @@ -0,0 +1,105 @@ +Conseils de réglage pour faiss +================== +# À propos de faiss +faiss est une bibliothèque de recherches de voisins pour les vecteurs denses, développée par Facebook Research, qui implémente efficacement de nombreuses méthodes de recherche de voisins approximatifs. +La recherche de voisins approximatifs trouve rapidement des vecteurs similaires tout en sacrifiant une certaine précision. + +## faiss dans RVC +Dans RVC, pour l'incorporation des caractéristiques converties par HuBERT, nous recherchons des incorporations similaires à l'incorporation générée à partir des données d'entraînement et les mixons pour obtenir une conversion plus proche de la parole originale. Cependant, cette recherche serait longue si elle était effectuée de manière naïve, donc une conversion à haute vitesse est réalisée en utilisant une recherche de voisinage approximatif. + +# Vue d'ensemble de la mise en œuvre +Dans '/logs/votre-expérience/3_feature256' où le modèle est situé, les caractéristiques extraites par HuBERT de chaque donnée vocale sont situées. +À partir de là, nous lisons les fichiers npy dans un ordre trié par nom de fichier et concaténons les vecteurs pour créer big_npy. (Ce vecteur a la forme [N, 256].) +Après avoir sauvegardé big_npy comme /logs/votre-expérience/total_fea.npy, nous l'entraînons avec faiss. + +Dans cet article, j'expliquerai la signification de ces paramètres. + +# Explication de la méthode +## Usine d'index +Une usine d'index est une notation unique de faiss qui exprime un pipeline qui relie plusieurs méthodes de recherche de voisinage approximatif sous forme de chaîne. +Cela vous permet d'essayer diverses méthodes de recherche de voisinage approximatif simplement en changeant la chaîne de l'usine d'index. +Dans RVC, elle est utilisée comme ceci : + +```python +index = faiss.index_factory(256, "IVF%s,Flat" % n_ivf) +``` + +Parmi les arguments de index_factory, le premier est le nombre de dimensions du vecteur, le second est la chaîne de l'usine d'index, et le troisième est la distance à utiliser. + +Pour une notation plus détaillée : +https://github.com/facebookresearch/faiss/wiki/The-index-factory + +## Index pour la distance +Il existe deux index typiques utilisés comme similarité de l'incorporation comme suit : + +- Distance euclidienne (METRIC_L2) +- Produit intérieur (METRIC_INNER_PRODUCT) + +La distance euclidienne prend la différence au carré dans chaque dimension, somme les différences dans toutes les dimensions, puis prend la racine carrée. C'est la même chose que la distance en 2D et 3D que nous utilisons au quotidien. +Le produit intérieur n'est pas utilisé comme index de similarité tel quel, et la similarité cosinus qui prend le produit intérieur après avoir été normalisé par la norme L2 est généralement utilisée. + +Lequel est le mieux dépend du cas, mais la similarité cosinus est souvent utilisée dans l'incorporation obtenue par word2vec et des modèles de récupération d'images similaires appris par ArcFace. Si vous voulez faire une normalisation l2 sur le vecteur X avec numpy, vous pouvez le faire avec le code suivant avec eps suffisamment petit pour éviter une division par 0. + +```python +X_normed = X / np.maximum(eps, np.linalg.norm(X, ord=2, axis=-1, keepdims=True)) +``` + +De plus, pour l'usine d'index, vous pouvez changer l'index de distance utilisé pour le calcul en choisissant la valeur à passer comme troisième argument. + +```python +index = faiss.index_factory(dimention, texte, faiss.METRIC_INNER_PRODUCT) +``` + +## IVF +IVF (Inverted file indexes) est un algorithme similaire à l'index inversé dans la recherche en texte intégral. +Lors de l'apprentissage, la cible de recherche est regroupée avec kmeans, et une partition de Voronoi est effectuée en utilisant le centre du cluster. Chaque point de données est attribué à un cluster, nous créons donc un dictionnaire qui permet de rechercher les points de données à partir des clusters. + +Par exemple, si des clusters sont attribués comme suit : +|index|Cluster| +|-----|-------| +|1|A| +|2|B| +|3|A| +|4|C| +|5|B| + +L'index inversé résultant ressemble à ceci : + +|cluster|index| +|-------|-----| +|A|1, 3| +|B|2, 5| +|C|4| + +Lors de la recherche, nous recherchons d'abord n_probe clusters parmi les clusters, puis nous calculons les distances pour les points de données appartenant à chaque cluster. + +# Recommandation de paramètre +Il existe des directives officielles sur la façon de choisir un index, je vais donc expliquer en conséquence. +https://github.com/facebookresearch/faiss/wiki/Guidelines-to-choose-an-index + +Pour les ensembles de données inférieurs à 1M, 4bit-PQ est la méthode la plus efficace disponible dans faiss en avril 2023. +En combinant cela avec IVF, en réduisant les candidats avec 4bit-PQ, et enfin en recalculant la distance avec un index précis, on peut le décrire en utilisant l'usine d'index suivante. + +```python +index = faiss.index_factory(256, "IVF1024,PQ128x4fs,RFlat") +``` + +## Paramètres recommandés pour IVF +Considérez le cas de trop d'IVF. Par exemple, si une quantification grossière par IVF est effectuée pour le nombre de données, cela revient à une recherche exhaustive naïve et est inefficace. +Pour 1M ou moins, les valeurs IVF sont recommandées entre 4*sqrt(N) ~ 16*sqrt(N) pour N nombre de points de données. + +Comme le temps de calcul augmente proportionnellement au nombre de n_probes, veuillez consulter la précision et choisir de manière appropriée. Personnellement, je ne pense pas que RVC ait besoin de tant de précision, donc n_probe = 1 est bien. + +## FastScan +FastScan est une méthode qui permet d'approximer rapidement les distances par quantification de produit cartésien en les effectuant dans les registres. +La quantification du produit cartésien effectue un regroupement indépendamment + + pour chaque dimension d (généralement d = 2) pendant l'apprentissage, calcule la distance entre les clusters à l'avance, et crée une table de recherche. Au moment de la prédiction, la distance de chaque dimension peut être calculée en O(1) en consultant la table de recherche. +Le nombre que vous spécifiez après PQ spécifie généralement la moitié de la dimension du vecteur. + +Pour une description plus détaillée de FastScan, veuillez consulter la documentation officielle. +https://github.com/facebookresearch/faiss/wiki/Fast-accumulation-of-PQ-and-AQ-codes-(FastScan) + +## RFlat +RFlat est une instruction pour recalculer la distance approximative calculée par FastScan avec la distance exacte spécifiée par le troisième argument de l'usine d'index. +Lors de l'obtention de k voisins, k*k_factor points sont recalculés. diff --git a/docs/fr/faq_fr.md b/docs/fr/faq_fr.md new file mode 100644 index 0000000..52ebafc --- /dev/null +++ b/docs/fr/faq_fr.md @@ -0,0 +1,169 @@ +## Q1: Erreur ffmpeg/erreur utf8. +Il s'agit très probablement non pas d'un problème lié à FFmpeg, mais d'un problème lié au chemin de l'audio ; + +FFmpeg peut rencontrer une erreur lors de la lecture de chemins contenant des caractères spéciaux tels que des espaces et (), ce qui peut provoquer une erreur FFmpeg ; et lorsque l'audio du jeu d'entraînement contient des chemins en chinois, l'écrire dans filelist.txt peut provoquer une erreur utf8.
+ +## Q2: Impossible de trouver le fichier index après "Entraînement en un clic". +Si l'affichage indique "L'entraînement est terminé. Le programme est fermé", alors le modèle a été formé avec succès, et les erreurs subséquentes sont fausses ; + +L'absence d'un fichier index 'ajouté' après un entraînement en un clic peut être due au fait que le jeu d'entraînement est trop grand, ce qui bloque l'ajout de l'index ; cela a été résolu en utilisant un traitement par lots pour ajouter l'index, ce qui résout le problème de surcharge de mémoire lors de l'ajout de l'index. Comme solution temporaire, essayez de cliquer à nouveau sur le bouton "Entraîner l'index".
+ +## Q3: Impossible de trouver le modèle dans “Inférence du timbre” après l'entraînement +Cliquez sur “Actualiser la liste des timbres” et vérifiez à nouveau ; si vous ne le voyez toujours pas, vérifiez s'il y a des erreurs pendant l'entraînement et envoyez des captures d'écran de la console, de l'interface utilisateur web, et des logs/nom_de_l'expérience/*.log aux développeurs pour une analyse plus approfondie.
+ +## Q4: Comment partager un modèle/Comment utiliser les modèles d'autres personnes ? +Les fichiers pth stockés dans rvc_root/logs/nom_de_l'expérience ne sont pas destinés à être partagés ou inférés, mais à stocker les points de contrôle de l'expérience pour la reproductibilité et l'entraînement ultérieur. Le modèle à partager doit être le fichier pth de 60+MB dans le dossier des poids ; + +À l'avenir, les poids/nom_de_l'expérience.pth et les logs/nom_de_l'expérience/ajouté_xxx.index seront fusionnés en un seul fichier poids/nom_de_l'expérience.zip pour éliminer le besoin d'une entrée d'index manuelle ; partagez donc le fichier zip, et non le fichier pth, sauf si vous souhaitez continuer l'entraînement sur une machine différente ; + +Copier/partager les fichiers pth de plusieurs centaines de Mo du dossier des logs au dossier des poids pour une inférence forcée peut entraîner des erreurs telles que des f0, tgt_sr, ou d'autres clés manquantes. Vous devez utiliser l'onglet ckpt en bas pour sélectionner manuellement ou automatiquement (si l'information se trouve dans les logs/nom_de_l'expérience), si vous souhaitez inclure les informations sur la hauteur et les options de taux d'échantillonnage audio cible, puis extraire le modèle plus petit. Après extraction, il y aura un fichier pth de 60+ MB dans le dossier des poids, et vous pouvez actualiser les voix pour l'utiliser.
+ +## Q5: Erreur de connexion. +Il se peut que vous ayez fermé la console (fenêtre de ligne de commande noire).
+ +## Q6: WebUI affiche 'Expecting value: line 1 column 1 (char 0)'. +Veuillez désactiver le proxy système LAN/proxy global puis rafraîchir.
+ +## Q7: Comment s'entraîner et déduire sans le WebUI ? +Script d'entraînement :
+Vous pouvez d'abord lancer l'entraînement dans WebUI, et les versions en ligne de commande de la préparation du jeu de données et de l'entraînement seront affichées dans la fenêtre de message.
+ +Script d'inférence :
+https://huggingface.co/lj1995/VoiceConversionWebUI/blob/main/myinfer.py
+ +Par exemple :
+ +runtime\python.exe myinfer.py 0 "E:\codes\py39\RVC-beta\todo-songs\1111.wav" "E:\codes\py39\logs\mi-test\added_IVF677_Flat_nprobe_7.index" récolte "test.wav" "weights/mi-test.pth" 0.6 cuda:0 True
+ +f0up_key=sys.argv[1]
+input_path=sys.argv[2]
+index_path=sys.argv[3]
+f0method=sys.argv[4]#récolte ou pm
+opt_path=sys.argv[5]
+model_path=sys.argv[6]
+index_rate=float(sys.argv[7])
+device=sys.argv[8]
+is_half=bool(sys.argv[9])
+ +### Explication des arguments : + +1. **Numéro de voix cible** : `0` (dans cet exemple) +2. **Chemin du fichier audio d'entrée** : `"C:\ YOUR PATH FOR THE ROOT (RVC0813Nvidia)\INPUTS_VOCAL\vocal.wav"` +3. **Chemin du fichier index** : `"C:\ YOUR PATH FOR THE ROOT (RVC0813Nvidia)\logs\Hagrid.index"` +4. **Méthode pour l'extraction du pitch (F0)** : `harvest` (dans cet exemple) +5. **Chemin de sortie pour le fichier audio traité** : `"C:\ YOUR PATH FOR THE ROOT (RVC0813Nvidia)\INPUTS_VOCAL\test.wav"` +6. **Chemin du modèle** : `"C:\ YOUR PATH FOR THE ROOT (RVC0813Nvidia)\weights\HagridFR.pth"` +7. **Taux d'index** : `0.6` (dans cet exemple) +8. **Périphérique pour l'exécution (GPU/CPU)** : `cuda:0` pour une carte NVIDIA, par exemple. +9. **Protection des droits d'auteur (True/False)**. + + + +## Q8: Erreur Cuda/Mémoire Cuda épuisée. +Il y a une faible chance qu'il y ait un problème avec la configuration CUDA ou que le dispositif ne soit pas pris en charge ; plus probablement, il n'y a pas assez de mémoire (manque de mémoire).
+ +Pour l'entraînement, réduisez la taille du lot (si la réduction à 1 n'est toujours pas suffisante, vous devrez peut-être changer la carte graphique) ; pour l'inférence, ajustez les paramètres x_pad, x_query, x_center, et x_max dans le fichier config.py selon les besoins. Les cartes mémoire de 4 Go ou moins (par exemple 1060(3G) et diverses cartes de 2 Go) peuvent être abandonnées, tandis que les cartes mémoire de 4 Go ont encore une chance.
+ +## Q9: Combien de total_epoch sont optimaux ? +Si la qualité audio du jeu d'entraînement est médiocre et que le niveau de bruit est élevé, 20-30 époques sont suffisantes. Le fixer trop haut n'améliorera pas la qualité audio de votre jeu d'entraînement de faible qualité.
+ +Si la qualité audio du jeu d'entraînement est élevée, le niveau de bruit est faible, et la durée est suffisante, vous pouvez l'augmenter. 200 est acceptable (puisque l'entraînement est rapide, et si vous êtes capable de préparer un jeu d'entraînement de haute qualité, votre GPU peut probablement gérer une durée d'entraînement plus longue sans problème).
+ +## Q10: Quelle durée de jeu d'entraînement est nécessaire ? +Un jeu d'environ 10 min à 50 min est recommandé.
+ +Avec une garantie de haute qualité sonore et de faible bruit de fond, plus peut être ajouté si le timbre du jeu est uniforme.
+ +Pour un jeu d'entraînement de haut niveau (ton maigre + ton distinctif), 5 min à 10 min sont suffisantes.
+ +Il y a des personnes qui ont réussi à s'entraîner avec des données de 1 min à 2 min, mais le succès n'est pas reproductible par d'autres et n'est pas très informatif.
Cela nécessite que le jeu d'entraînement ait un timbre très distinctif (par exemple, un son de fille d'anime aérien à haute fréquence) et que la qualité de l'audio soit élevée ; +Aucune tentative réussie n'a été faite jusqu'à présent avec des données de moins de 1 min. Cela n'est pas recommandé.
+ +## Q11: À quoi sert le taux d'index et comment l'ajuster ? +Si la qualité tonale du modèle pré-entraîné et de la source d'inférence est supérieure à celle du jeu d'entraînement, ils peuvent améliorer la qualité tonale du résultat d'inférence, mais au prix d'un possible biais tonal vers le ton du modèle sous-jacent/source d'inférence plutôt que le ton du jeu d'entraînement, ce qui est généralement appelé "fuite de ton".
+ +Le taux d'index est utilisé pour réduire/résoudre le problème de la fuite de timbre. Si le taux d'index est fixé à 1, théoriquement il n'y a pas de fuite de timbre de la source d'inférence et la qualité du timbre est plus biaisée vers le jeu d'entraînement. Si le jeu d'entraînement a une qualité sonore inférieure à celle de la source d'inférence, alors un taux d'index plus élevé peut réduire la qualité sonore. Le réduire à 0 n'a pas l'effet d'utiliser le mélange de récupération pour protéger les tons du jeu d'entraînement.
+ +Si le jeu d'entraînement a une bonne qualité audio et une longue durée, augmentez le total_epoch, lorsque le modèle lui-même est moins susceptible de se référer à la source déduite et au modèle sous-jacent pré-entraîné, et qu'il y a peu de "fuite de ton", le taux d'index n'est pas important et vous pouvez même ne pas créer/partager le fichier index.
+ +## Q12: Comment choisir le gpu lors de l'inférence ? +Dans le fichier config.py, sélectionnez le numéro de carte après "device cuda:".
+ +La correspondance entre le numéro de carte et la carte graphique peut être vue dans la section d'information de la carte graphique de l'onglet d'entraînement.
+ +## Q13: Comment utiliser le modèle sauvegardé au milieu de l'entraînement ? +Sauvegardez via l'extraction de modèle en bas de l'onglet de traitement ckpt. + +## Q14: Erreur de fichier/erreur de mémoire (lors de l'entraînement) ? +Il y a trop de processus et votre mémoire n'est pas suffisante. Vous pouvez le corriger en : + +1. Diminuer l'entrée dans le champ "Threads of CPU". + +2. Pré-découper le jeu d'entraînement en fichiers audio plus courts. + +## Q15: Comment poursuivre l'entraînement avec plus de données + +étape 1 : mettre toutes les données wav dans path2. + +étape 2 : exp_name2+path2 -> traiter le jeu de données et extraire la caractéristique. + +étape 3 : copier les derniers fichiers G et D de exp_name1 (votre expérience précédente) dans le dossier exp_name2. + +étape 4 : cliquez sur "entraîner le modèle", et il continuera l'entraînement depuis le début de votre époque de modèle exp précédente. + +## Q16: erreur à propos de llvmlite.dll + +OSError: Impossible de charger le fichier objet partagé : llvmlite.dll + +FileNotFoundError: Impossible de trouver le module lib\site-packages\llvmlite\binding\llvmlite.dll (ou l'une de ses dépendances). Essayez d'utiliser la syntaxe complète du constructeur. + +Le problème se produira sous Windows, installez https://aka.ms/vs/17/release/vc_redist.x64.exe et il sera corrigé. + +## Q17: RuntimeError: La taille étendue du tensor (17280) doit correspondre à la taille existante (0) à la dimension non-singleton 1. Tailles cibles : [1, 17280]. Tailles des tensors : [0] + +Supprimez les fichiers wav dont la taille est nettement inférieure à celle des autres, et cela ne se reproduira plus. Ensuite, cliquez sur "entraîner le modèle" et "entraîner l'index". + +## Q18: RuntimeError: La taille du tensor a (24) doit correspondre à la taille du tensor b (16) à la dimension non-singleton 2 + +Ne changez pas le taux d'échantillonnage puis continuez l'entraînement. S'il est nécessaire de changer, le nom de l'expérience doit être modifié et le modèle sera formé à partir de zéro. Vous pouvez également copier les hauteurs et caractéristiques (dossiers 0/1/2/2b) extraites la dernière fois pour accélérer le processus d'entraînement. + diff --git a/docs/fr/training_tips_fr.md b/docs/fr/training_tips_fr.md new file mode 100644 index 0000000..836b450 --- /dev/null +++ b/docs/fr/training_tips_fr.md @@ -0,0 +1,65 @@ +Instructions et conseils pour la formation RVC +====================================== +Ces conseils expliquent comment se déroule la formation des données. + +# Flux de formation +Je vais expliquer selon les étapes de l'onglet de formation de l'interface graphique. + +## étape 1 +Définissez ici le nom de l'expérience. + +Vous pouvez également définir ici si le modèle doit prendre en compte le pitch. +Si le modèle ne considère pas le pitch, le modèle sera plus léger, mais pas adapté au chant. + +Les données de chaque expérience sont placées dans `/logs/nom-de-votre-experience/`. + +## étape 2a +Charge et pré-traite l'audio. + +### charger l'audio +Si vous spécifiez un dossier avec de l'audio, les fichiers audio de ce dossier seront lus automatiquement. +Par exemple, si vous spécifiez `C:Users\hoge\voices`, `C:Users\hoge\voices\voice.mp3` sera chargé, mais `C:Users\hoge\voices\dir\voice.mp3` ne sera pas chargé. + +Comme ffmpeg est utilisé en interne pour lire l'audio, si l'extension est prise en charge par ffmpeg, elle sera lue automatiquement. +Après la conversion en int16 avec ffmpeg, convertir en float32 et normaliser entre -1 et 1. + +### débruitage +L'audio est lissé par filtfilt de scipy. + +### Séparation audio +Tout d'abord, l'audio d'entrée est divisé en détectant des parties de silence qui durent plus d'une certaine période (max_sil_kept = 5 secondes ?). Après avoir séparé l'audio sur le silence, séparez l'audio toutes les 4 secondes avec un chevauchement de 0,3 seconde. Pour l'audio séparé en 4 secondes, après normalisation du volume, convertir le fichier wav en `/logs/nom-de-votre-experience/0_gt_wavs` puis le convertir à un taux d'échantillonnage de 16k dans `/logs/nom-de-votre-experience/1_16k_wavs` sous forme de fichier wav. + +## étape 2b +### Extraire le pitch +Extrait les informations de pitch des fichiers wav. Extraire les informations de pitch (=f0) en utilisant la méthode intégrée dans parselmouth ou pyworld et les sauvegarder dans `/logs/nom-de-votre-experience/2a_f0`. Convertissez ensuite logarithmiquement les informations de pitch en un entier entre 1 et 255 et sauvegardez-le dans `/logs/nom-de-votre-experience/2b-f0nsf`. + +### Extraire l'empreinte de caractéristique +Convertissez le fichier wav en incorporation à l'avance en utilisant HuBERT. Lisez le fichier wav sauvegardé dans `/logs/nom-de-votre-experience/1_16k_wavs`, convertissez le fichier wav en caractéristiques de dimension 256 avec HuBERT, et sauvegardez au format npy dans `/logs/nom-de-votre-experience/3_feature256`. + +## étape 3 +former le modèle. +### Glossaire pour les débutants +Dans l'apprentissage profond, l'ensemble de données est divisé et l'apprentissage progresse petit à petit. Dans une mise à jour de modèle (étape), les données de batch_size sont récupérées et des prédictions et corrections d'erreur sont effectuées. Faire cela une fois pour un ensemble de données compte comme une époque. + +Par conséquent, le temps d'apprentissage est le temps d'apprentissage par étape x (le nombre de données dans l'ensemble de données / taille du lot) x le nombre d'époques. En général, plus la taille du lot est grande, plus l'apprentissage devient stable (temps d'apprentissage par étape ÷ taille du lot) devient plus petit, mais il utilise plus de mémoire GPU. La RAM GPU peut être vérifiée avec la commande nvidia-smi. L'apprentissage peut être effectué en peu de temps en augmentant la taille du lot autant que possible selon la machine de l'environnement d'exécution. + +### Spécifier le modèle pré-entraîné +RVC commence à former le modèle à partir de poids pré-entraînés plutôt que de zéro, il peut donc être formé avec un petit ensemble de données. + +Par défaut : + +- Si vous considérez le pitch, il charge `rvc-location/pretrained/f0G40k.pth` et `rvc-location/pretrained/f0D40k.pth`. +- Si vous ne considérez pas le pitch, il charge `rvc-location/pretrained/f0G40k.pth` et `rvc-location/pretrained/f0D40k.pth`. + +Lors de l'apprentissage, les paramètres du modèle sont sauvegardés dans `logs/nom-de-votre-experience/G_{}.pth` et `logs/nom-de-votre-experience/D_{}.pth` pour chaque save_every_epoch, mais en spécifiant ce chemin, vous pouvez démarrer l'apprentissage. Vous pouvez redémarrer ou commencer à former à partir de poids de modèle appris lors d'une expérience différente. + +### Index d'apprentissage +RVC sauvegarde les valeurs de caractéristique HuBERT utilisées lors de la formation, et pendant l'inférence, recherche les valeurs de caractéristique qui sont similaires aux valeurs de caractéristique utilisées lors de l'apprentissage pour effectuer l'inférence. Afin d'effectuer cette recherche à haute vitesse, l'index est appris à l'avance. +Pour l'apprentissage d'index, nous utilisons la bibliothèque de recherche de voisinage approximatif faiss. Lisez la valeur de caractéristique de `logs/nom-de-votre-experience/3_feature256` et utilisez-la pour apprendre l'index, et sauvegardez-la sous `logs/nom-de-votre-experience/add_XXX.index`. + +(À partir de la version de mise à jour 20230428, elle est lue à partir de l'index, et la sauvegarde / spécification n'est plus nécessaire.) + +### Description du bouton +- Former le modèle : après avoir exécuté l'étape 2b, appuyez sur ce bouton pour former le modèle. +- Former l'index de caractéristique : après avoir formé le modèle, effectuez un apprentissage d'index. +- Formation en un clic : étape 2b, formation du modèle et formation de l'index de caractéristique tout d'un coup.```