DiffSynth-Engine : Moteur Open Source pour le déploiement de FLUX à faible niveau d'exigence, Wan 2.1

Dernières ressources sur l'IAPosté il y a 5 mois Cercle de partage de l'IA

11.8K 00

Introduction générale

DiffSynth-Engine est un projet open source de ModelScope, hébergé sur GitHub, qui est basé sur la technologie de modélisation de la diffusion et se concentre sur la génération efficace d'images et de vidéos pour les développeurs afin de déployer des modèles d'IA dans des environnements de production. Le projet a évolué à partir de DiffSynth-Studio, après une transformation complète de l'ingénierie, optimisant l'efficacité de calcul et la facilité de déploiement. Il prend en charge plusieurs modèles (par exemple, FLUX, Wan2.1) et fournit une structure de code claire et une gestion flexible de la mémoire. Depuis mars 2025, le projet est continuellement mis à jour et a reçu une grande attention de la part de la communauté open source, dans le but de promouvoir l'aspect pratique de la création d'IA.

Liste des fonctions

Il permet de générer efficacement des images et des vidéos, couvrant ainsi un large éventail de besoins, des images statiques aux contenus dynamiques.
Fournir un code clair et lisible sans dépendre de bibliothèques tierces, ce qui permet aux développeurs de le modifier et de l'étendre facilement.
Compatible avec une variété de modèles de base (par exemple FLUX, Wan2.1) et de modèles LoRA pour s'adapter à différents scénarios.
Gestion flexible de la mémoire intégrée, prise en charge des modes FP8, INT8 et autres modes de quantification, et possibilité d'exécution sur des dispositifs à faible mémoire graphique.
Optimiser la vitesse d'inférence et prendre en charge le calcul parallèle en tenseur pour accélérer les tâches génératives à grande échelle.
Il offre une prise en charge multiplateforme et est compatible avec Windows, macOS (y compris Apple Silicon) et Linux.
Prise en charge de la conversion de texte en image, de texte en vidéo et du style vidéo, parmi de nombreuses autres fonctionnalités.

Utiliser l'aide

Processus d'installation

L'installation de DiffSynth-Engine est simple et peut se faire en quelques étapes.

Installation des paquets de base
Installer via pip3 en entrant la commande suivante dans le terminal :

pip3 install diffsynth-engine

Assurez-vous que la version de Python est 3.8 ou supérieure. Il est recommandé d'utiliser un environnement virtuel pour éviter les conflits de dépendance.

Télécharger les fichiers modèles
Le projet n'inclut pas de fichiers modèles, qui doivent être téléchargés manuellement ou via le code. Par exemple, l'obtention du fichier FLUX Modèles :

from diffsynth_engine import fetch_model
model_path = fetch_model("muse/flux-with-vae", revision="20240902173035", path="flux1-dev-with-vae.safetensors")

Après le téléchargement, les fichiers du modèle sont généralement placés localement dans un répertoire spécifique pour que les scripts puissent les appeler.

Vérifier l'installation
Une fois l'installation terminée, exécutez un script de test simple pour confirmer que l'environnement fonctionne :
```
from diffsynth_engine import __version__
print(__version__)
```
L'affichage du numéro de version signifie que l'installation a réussi.

Principales fonctions

1) Générer des images (exemple : FLUX)

procédure
Utilisez le code suivant pour générer une image :

from diffsynth_engine.pipelines import FluxImagePipeline, FluxModelConfig
from diffsynth_engine import fetch_model
model_path = fetch_model("muse/flux-with-vae", revision="20240902173035", path="flux1-dev-with-vae.safetensors")
config = FluxModelConfig(dit_path=model_path)
pipe = FluxImagePipeline.from_pretrained(config, offload_mode="cpu_offload").eval()
image = pipe(
prompt="月球上的宇航员骑马，黑白摄影风格，颗粒感强，对比度高",
width=1024,
height=1024,
num_inference_steps=30,
seed=42,
)
image.save("flux_txt2img.png")

Description détaillée
Par défaut, 23 Go de mémoire vidéo sont nécessaires. Si vous n'avez pas assez de mémoire, vous pouvez ajuster le paramètre offload_mode="sequential_cpu_offload"Le processus de quantification peut être exécuté avec seulement 4 Go de RAM, mais le temps de génération est plus long (par exemple 91 secondes). Prend en charge plusieurs précisions de quantification (par exemple q8_0, q6_k) et les besoins en mémoire peuvent être réduits à 7-12 Go.

2. la génération de vidéos (exemple : Wan 2.1)

procédure
Utilisez le code suivant pour générer une vidéo :

from diffsynth_engine.pipelines import WanVideoPipeline, WanModelConfig
from diffsynth_engine.utils.download import fetch_model
from diffsynth_engine.utils.video import save_video
config = WanModelConfig(
model_path=fetch_model("muse/wan2.1-14b-bf16", path="dit.safetensors"),
t5_path=fetch_model("muse/wan2.1-umt5", path="umt5.safetensors"),
vae_path=fetch_model("muse/wan2.1-vae", path="vae.safetensors"),
)
pipe = WanVideoPipeline.from_pretrained(config)
video = pipe(
prompt="小狗在草地上奔跑，阳光照耀，背景有野花和蓝天",
num_frames=41,
width=848,
height=480,
seed=42,
)
save_video(video, "wan_t2v.mp4", fps=15)

Description détaillée
Il faut 358 secondes pour générer 2 secondes de vidéo sur une seule carte. Si vous utilisez 4 GPU A100 et activez le parallélisme tensoriel (parallelism=4, use_cfg_parallel=True），时间缩短至 114 秒，加速比达 3.14 倍。

3. optimisation de la mémoire faible

procédure
Dans l'exemple de FLUX, le offload_mode se transformer en sequential_cpu_offload: :

pipe = FluxImagePipeline.from_pretrained(config, offload_mode="sequential_cpu_offload").eval()

Description détaillée
Les besoins en mémoire graphique ont été réduits de 23 Go à 3,52 Go pour les appareils moyens. Les modes de quantification (tels que q4_k_s) équilibrent davantage la vitesse et la qualité, générant des résultats légèrement réduits mais toujours utiles.

4. raisonnement parallèle multicartes

procédure
Dans l'exemple Wan2.1, ajoutez le paramètre parallèle :

pipe = WanVideoPipeline.from_pretrained(config, parallelism=4, use_cfg_parallel=True)

Description détaillée
Prise en charge du calcul parallèle multi-GPU. 2 GPU accélèrent 1,97x et 4 GPU accélèrent 3,14x pour les déploiements de niveau industriel.

mise en garde

exigences en matière de matérielMémoire vidéo : 8 Go de mémoire vidéo sont recommandés pour la génération d'images, 24 Go pour la génération de vidéos ou les configurations multi-cartes.
chemin du modèleLe programme d'action de l'Union européenne (UE) : Veiller à ce que fetch_model Le chemin téléchargé est correct, sinon vous devez le spécifier manuellement.
référence de la documentationLes utilisateurs sont invités à consulter la page officielle de GitHub pour plus d'informations sur l'utilisation de ce service. <https://github.com/modelscope/DiffSynth-Engine>.

scénario d'application

création personnelle
Les utilisateurs peuvent générer des images artistiques avec FLUX ou créer de courtes vidéos avec Wan2.1, adaptées au partage sur les médias sociaux.
Déploiement industriel
Les entreprises peuvent utiliser le raisonnement parallèle multicarte pour générer rapidement du contenu vidéo de haute qualité pour la publicité ou la production de films.
Études techniques
Les développeurs peuvent modifier le code, tester différents modèles et stratégies quantitatives, et optimiser la technologie de l'IA.
Éducation et formation
Les étudiants peuvent apprendre l'application pratique de la modélisation de la diffusion et explorer les principes de la génération d'IA par le biais d'une installation simple.

QA

Que se passe-t-il si l'installation échoue ?
Vérifiez la version de Python et la connexion réseau. Assurez-vous que pip est à jour (pip install --upgrade pip), ou téléchargez les dépendances manuellement.
Quels sont les modèles pris en charge ?
Prend en charge les modèles de base tels que FLUX, Wan2.1, et les modèles affinés compatibles LoRA couvrant la génération d'images et de vidéos.
Un ordinateur à profil bas peut-il fonctionner ?
Can. Ajustements offload_mode Une fois les paramètres de quantification définis, FLUX peut être exécuté avec 4 Go de RAM.
Comment mettre en place le parallélisme multicarte ?
Ajouté lors de l'initialisation du pipeline parallelism assurez-vous que le nombre de GPU correspond.