DiffSynth-Engine: Mecanismo de código aberto para baixa implantação existente do FLUX, Wan 2.1

Introdução geral

O DiffSynth-Engine é um projeto de código aberto da ModelScope, hospedado no GitHub, que se baseia na tecnologia de modelagem de difusão e se concentra na geração eficiente de imagens e vídeos para que os desenvolvedores implantem modelos de IA em ambientes de produção. O projeto evoluiu do DiffSynth-Studio, após uma transformação abrangente de engenharia, otimizando a eficiência computacional e a facilidade de implantação. Ele oferece suporte a vários modelos (por exemplo, FLUX, Wan2.1) e fornece uma estrutura de código clara e gerenciamento de memória flexível. Desde março de 2025, o projeto é atualizado continuamente e tem recebido muita atenção da comunidade de código aberto, com o objetivo de promover a praticidade da criação de IA.

Lista de funções

• Oferece suporte à geração eficiente de imagens e vídeos, abrangendo uma ampla gama de necessidades, desde imagens estáticas até conteúdo dinâmico.
• Fornecer código claro e legível sem depender de bibliotecas de terceiros, facilitando a modificação e a extensão para os desenvolvedores.
• Compatível com uma variedade de modelos básicos (por exemplo, FLUX, Wan2.1) e modelos LoRA para se adaptar a diferentes cenários.
• Gerenciamento de memória flexível incorporado, suporte a FP8, INT8 e outros modos de quantização, e pode ser executado em dispositivos de memória gráfica baixa.
• Otimize a velocidade de inferência e ofereça suporte à computação paralela de tensores para acelerar tarefas generativas em grande escala.
• Oferece suporte a várias plataformas e é compatível com Windows, macOS (incluindo Apple Silicon) e Linux.
• Oferece suporte a texto para imagem, texto para vídeo e estilo de vídeo, entre muitos outros recursos.

Usando a Ajuda

Processo de instalação

A instalação do DiffSynth-Engine é simples e pode ser feita em algumas etapas.

1. Instalação de pacotes principais
   Instale via pip3 digitando o seguinte comando no terminal:

pip3 install diffsynth-engine

Certifique-se de que a versão do Python seja 3.8 ou superior. Recomenda-se usar um ambiente virtual para evitar conflitos de dependência.

2. Baixar arquivos de modelo
   O projeto não inclui arquivos de modelo, que precisam ser baixados manualmente ou por meio de código. Por exemplo, obter o arquivo FLUXO Modelos:

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

Após o download, os arquivos de modelo geralmente são colocados localmente em um diretório específico para que os scripts sejam chamados.

3. Verificar a instalação
   Após a conclusão da instalação, execute um script de teste simples para confirmar que o ambiente funciona:

   from diffsynth_engine import __version__
   print(__version__)
   

   A saída do número da versão significa que a instalação foi bem-sucedida.

Funções principais

1. geração de imagens (FLUX como exemplo)

• procedimento
  Use o código a seguir para gerar uma imagem:

  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")
  

• Descrição em destaque
  Por padrão, são necessários 23 GB de memória de vídeo. Se você não tiver memória suficiente, poderá ajustar a offload_mode="sequential_cpu_offload"O processo de quantificação pode ser executado com apenas 4 GB de RAM, mas o tempo de geração é estendido (por exemplo, 91 segundos). Oferece suporte a várias precisões de quantificação (por exemplo, q8_0, q6_k) e os requisitos de memória podem ser reduzidos para 7-12 GB.

2. geração de vídeo (Wan 2.1 como exemplo)

• procedimento
  Use o código a seguir para gerar um vídeo:

  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)
  

• Descrição em destaque
  São necessários 358 segundos para gerar 2 segundos de vídeo em uma única placa. Se você usar 4 GPUs A100 e ativar o paralelismo de tensor (parallelism=4, use_cfg_parallel=True），时间缩短至 114 秒，加速比达 3.14 倍。

3. otimização da memória reduzida

• procedimento
  No exemplo do FLUX, o offload_mode mudar para sequential_cpu_offload::

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

• Descrição em destaque
  Os requisitos de memória gráfica foram reduzidos de 23 GB para 3,52 GB para dispositivos médios. Os modos de quantificação (como o q4_k_s) equilibram ainda mais a velocidade e a qualidade, gerando resultados ligeiramente reduzidos, mas ainda úteis.

4. raciocínio paralelo com vários cartões

• procedimento
  No exemplo do Wan2.1, adicione o parâmetro paralelo:

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

• Descrição em destaque
  Suporta computação paralela multi-GPU. 2 GPUs aceleram 1,97x, 4 GPUs aceleram 3,14x para implementações de nível industrial.

advertência

• Requisitos de hardwareMemória de vídeo: Recomenda-se 8 GB de memória de vídeo para geração de imagens, 24 GB para geração de vídeo ou configurações com várias placas.
• caminho do modeloPara garantir que fetch_model O caminho baixado está correto; caso contrário, você precisará especificá-lo manualmente.
• referência de documentaçãoConsulte a página oficial do GitHub para obter mais informações sobre o uso. <https://github.com/modelscope/DiffSynth-Engine>.

cenário do aplicativo

1. criação pessoal
   Os usuários podem gerar imagens artísticas com o FLUX ou criar vídeos curtos com o Wan2.1, adequados para compartilhamento em mídias sociais.
2. Implementação industrial
   As empresas podem usar o raciocínio paralelo de vários cartões para gerar rapidamente conteúdo de vídeo de alta qualidade para publicidade ou produção de filmes.
3. Estudos técnicos
   Os desenvolvedores podem modificar o código, testar diferentes modelos e estratégias quantitativas e promover a otimização da tecnologia de IA.
4. Educação e treinamento
   Os alunos podem aprender a aplicação prática da modelagem de difusão e explorar os princípios da geração de IA por meio de uma instalação simples.

QA

1. E se a instalação falhar?
   Verifique a versão do Python e a conexão de rede. Certifique-se de que o pip esteja atualizado (pip install --upgrade pip) ou baixe as dependências manualmente.
2. Quais são os modelos suportados?
   Oferece suporte a modelos básicos, como FLUX, Wan2.1 e modelos ajustados compatíveis com LoRA, abrangendo a geração de imagens e vídeos.
3. Um computador de perfil baixo funcionará?
   Can. Ajustes offload_mode Após os parâmetros de quantificação, o FLUX pode ser executado com 4 GB de RAM.
4. Como faço para configurar o paralelismo de vários cartões?
   Adicionado durante a inicialização do pipeline parallelism verifique se o número de GPUs corresponde.