Seed-VC : permet la conversion en temps réel de la parole et de la chanson avec moins d'échantillons

Introduction générale

Seed-VC est un projet open source sur GitHub, développé par Plachtaa. Il peut utiliser de 1 à 30 secondes d'audio de référence pour réaliser rapidement une conversion de voix ou de chanson, sans formation supplémentaire. Le projet prend en charge la conversion vocale en temps réel, avec une latence aussi faible que 400 millisecondes environ, ce qui convient aux réunions en ligne, aux jeux ou à l'utilisation en direct. Seed-VC propose trois modes : la conversion vocale (VC), la conversion de chansons (SVC) et la conversion en temps réel. Il utilise Chuchotement et BigVGAN et d'autres technologies pour garantir un son clair. Le code est gratuit et ouvert au public, et les utilisateurs peuvent le télécharger et le construire localement. Mises à jour officielles, documentation détaillée et soutien actif de la communauté.

Liste des fonctions

• Prise en charge de la conversion zéro-échantillon : imitation de la voix ou de la chanson cible à l'aide de courtes séquences audio.
• Traitement de la voix en temps réel : la voix se transforme instantanément en tonalité cible après l'entrée du microphone.
• Conversion de chansons : Convertissez n'importe quelle chanson à la voix du chanteur spécifié.
• Ajustement de la longueur audio : accélère ou ralentit la parole pour contrôler le tempo.
• Ajustement de la hauteur : Ajustement automatique ou manuel de la hauteur pour s'adapter à la tonalité cible.
• Interface web : fournit une interface graphique simple pour faciliter l'utilisation.
• Prise en charge de la formation personnalisée : optimiser des sons spécifiques avec une petite quantité de données.
• Code source ouvert : caractéristiques modifiables ou évolutives par l'utilisateur.

Utiliser l'aide

Processus d'installation

Pour utiliser Seed-VC localement, vous devez d'abord installer l'environnement. Vous trouverez ci-dessous les étapes détaillées pour Windows, Mac (avec les puces de la série M) ou Linux.

1. Préparation de l'environnement
   • Installez Python 3.10, en le téléchargeant sur le site officiel.
   • Pour installer Git, recherchez "Git for Windows" pour les utilisateurs de Windows, ou brew install git pour Mac.
   • Les utilisateurs de GPU doivent installer CUDA 12.4 et les pilotes correspondants. Le CPU peut également fonctionner, mais plus lentement.
   • Pour installer FFmpeg pour le traitement audio, téléchargez-le depuis le site officiel pour Windows, installez ffmpeg avec brew pour Mac, et installez-le avec un gestionnaire de paquets pour Linux.
2. Télécharger le code
   • Ouvrez une ligne de commande (CMD ou Anaconda Prompt pour Windows, Terminal pour Mac/Linux).
   • Tapez git clone https://github.com/Plachtaa/seed-vc.git pour télécharger le projet.
   • Allez dans le répertoire : cd seed-vc .
3. Mise en place d'un environnement virtuel
   • Tapez python -m venv venv pour créer un environnement autonome.
   • Activer l'environnement :
     • Windows : venv\Scripts\activate
     • Mac/Linux : source venv/bin/activate
   • Voir (venv) pour le succès.
4. Installation des dépendances
   • Windows/Linux Entrer pip install -r requirements.txt.
   • Mac M series enter pip install -r requirements-mac.txt .
   • Ajouter un miroir pour les problèmes de réseau : HF_ENDPOINT=https://hf-mirror.com pip install -r requirements.txt .
5. programme de course
   • Conversion vocale : python app_vc.py
   • Conversion des chansons : python app_svc.py
   • Conversion en temps réel : python real-time-gui.py
   • Une fois lancé, le navigateur se rend sur le site http://localhost:7860 pour utiliser l'interface.

Principales fonctions

1. la conversion vocale (VC)

• déplacer: :
  1. Exécutez python app_vc.py et ouvrez votre navigateur à http://localhost:7860.
  2. Téléchargez l'audio original (Source Audio) et l'audio de référence (Reference Audio, 1-30 secondes).
  3. Régler les pas de diffusion, 25 par défaut, 30-50 pour une meilleure qualité sonore.
  4. Longueur Ajuster, moins de 1 accélère, plus de 1 ralentit.
  5. Cliquez sur Soumettre, attendez quelques secondes et téléchargez le résultat de la conversion.
• prendre note: :
  • La première exécution téléchargera automatiquement le modèle seed-uvit-whisper-small-wavenet.
  • Le son de référence est coupé après 30 secondes.

2. la conversion vocale des chansons (SVC)

• déplacer: :
  1. Exécutez python app_svc.py pour ouvrir l'interface web.
  2. Téléchargez le fichier audio de la chanson et le fichier audio de référence du chanteur.
  3. Cochez la condition f0 pour maintenir la hauteur de la chanson.
  4. Option auto-f0-adjust Ajuste automatiquement la hauteur du son.
  5. Réglez le nombre d'étapes de diffusion sur 30-50 et cliquez sur Soumettre.
• finesse: :
  • Pour obtenir les meilleurs résultats, utilisez un son de référence clair et sans bruit de fond.
  • Les modèles téléchargent seed-uvit-whisper-base par défaut.

3. conversion en temps réel

• déplacer: :
  1. Exécutez python real-time-gui.py pour ouvrir l'interface.
  2. Téléchargez l'audio de référence et connectez le microphone.
  3. Paramètres de réglage : étapes de diffusion 4-10, temps de blocage 0,18 sec.
  4. Cliquez sur "Start" et la voix change en temps réel pendant que vous parlez.
  5. Utilisez VB-CABLE pour acheminer la sortie vers le microphone virtuel.
• demande: :
  • Recommandations GPU (par exemple RTX 3060) avec une latence d'environ 430 ms.
  • La latence d'exécution de l'unité centrale est plus élevée.

4. opérations en ligne de commande

• Exemple de conversion de discours: :

   python inference.py --source input.wav --target ref.wav --output ./out --diffusion-steps 25 --length-adjust 1.0 --fp16 True

• Exemple de conversion de chanson: :

   python inference.py --source song.wav --target singer.wav --output ./out --diffusion-steps 50 --f0-condition True --semi-tone-shift 0 --fp16 True
  

5. formation sur mesure

• déplacer: :
  1. Préparez un fichier audio de 1 à 30 secondes (.wav/.mp3, etc.) dans un dossier.
  2. Entraînement à la course à pied :

      python train.py --config configs/presets/config_dit_mel_seed_uvit_whisper_base_f0_44k.yml --dataset-dir ./data --run-name myrun --max-steps 1000
     

  3. Point de contrôle post-formation dans . /runs/myrun/ft_model.pth .
  4. Raisonner avec des modèles personnalisés :

      python app_svc.py --checkpoint ./runs/myrun/ft_model.pth --config configs/presets/config_dit_mel_seed_uvit_whisper_base_f0_44k.yml
     

• prendre note: au moins 1 échantillon audio pour l'entraînement, environ 2 minutes pour 100 étapes (T4 GPU).

note complémentaire

• Sélection du modèle: :
  • En temps réel avec seed-uvit-tat-xlsr-tiny (25M paramètres).
  • Voix hors ligne avec seed-uvit-whisper-small-wavenet (98M paramètres).
  • Pour les voix, utiliser seed-uvit-whisper-base (paramètres 200M, 44kHz).
• ajuster les composants pendant les essais: :
  • Signaler une erreur ModuleNotFoundError, vérifier la dépendance.
  • Les Macs peuvent avoir besoin de Python avec Tkinter installé pour exécuter des interfaces graphiques en temps réel.

scénario d'application

1. doublage de divertissement
   Transformez vos voix en personnages de dessins animés pour réaliser des vidéos amusantes.
2. production musicale
   Transforme les voix ordinaires en sonorités de chanteurs professionnels et génère des démos de chansons.
3. interaction en direct
   Le présentateur change de voix en temps réel pour rendre l'émission plus amusante.
4. l'apprentissage des langues
   Imiter le discours des locuteurs natifs et s'entraîner à la prononciation.

QA

1. Besoin d'un grand nombre de données ?
   Non. Un court clip audio est nécessaire pour la conversion et un seul échantillon est nécessaire pour la formation.
2. Prend-il en charge l'audio chinois ?
   Prise en charge. Tant que l'audio de référence est en chinois, la conversion est également claire.
3. Qu'en est-il des temps de latence élevés ?
   Utilisez le GPU et définissez un niveau de diffusion faible (4-10).
4. Qu'en est-il de la mauvaise qualité du son ?
   Augmentez le nombre de pas de diffusion à 50, ou utilisez un son de référence propre.