Elastic GPU Service:Install and use ComfyUI with DeepGPU

Comparação de desempenho

Em comparação com uma configuração sem os nós de aceleração ComfyUI+DeepGPU, a inclusão desses nós em uma instância gpu aumenta significativamente o desempenho. Recomenda-se usar a instância de placa única gn8is instance). Com essa configuração, o desempenho do modelo flux1-dev aumenta em aproximadamente 30% nas precisões bf16 e fp8. A tabela a seguir compara o desempenho de aceleração de text-to-image para modelos selecionados.

Pré-requisitos

• crie uma instância gpu que atenda aos seguintes requisitos:

  • O sistema operacional deve ser o Ubuntu 20.04 ou o Ubuntu 22.04.

  • O driver NVIDIA e o CUDA devem estar instalados e atender aos requisitos de versão.

    Nota

    Ao crie uma instância gpu, recomendamos selecione a opção Install GPU Driver após escolher uma imagem e, em seguida, selecione as versões do CUDA, Driver e cuDNN.

  • A instância deve ter um endereço IP público fixo ou estar associada a um endereço IP elástico (EIP). Para mais informações, consulte ative public network access.

• Configure as regras do grupo de segurança.

  A porta 22 para conexões remotas é aberta por padrão. O servidor do ComfyUI requer uma porta (como a 7860) para sua interface web. Certifique-se de que as regras de entrada para as portas 22 e 7860 estejam configuradas no seu grupo de segurança. Caso contrário, add security group rules manualmente.

instale o componente de aceleração ComfyUI+DeepGPU

O ComfyUI é um projeto de código aberto. instale-o por conta própria e, em seguida, siga este tópico para instale o componente de aceleração DeepGPU. Para obter informações sobre os tipos de nós do DeepGPU e fluxos de trabalho integrados ao ComfyUI, consulte Node and workflow overview.

1. Configure o ComfyUI por conta própria.

   Nota

   O ComfyUI é um projeto de código aberto e deve ser instalado por conta própria. Para obter informações sobre nós relacionados e exemplos de fluxos de trabalho no ComfyUI, consulte Node and workflow overview.

   Se você carregar um modelo LoRA nativo no ComfyUI (usando LoraLoaderModelOnly) e acelerá-lo com o deepgpu-torch, modifique uma linha no source do ComfyUI.

   • Para o ComfyUI v0.3.6 e versões anteriores

     Em ComfyUI/comfy/sd.py, adicione o parâmetro weight_inplace_update=True à seguinte linha. O código modificado fica assim:

     

     Código modificado:

     return comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=offload_device, weight_inplace_update=True)

   • Para o ComfyUI v0.3.7 e versões posteriores

     Em ComfyUI/comfy/sd.py, adicione o parâmetro weight_inplace_update=True à seguinte linha. O código modificado fica assim:

     

     O código modificado fica assim:

     model_patcher = comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device(), weight_inplace_update=True)

2. instale o componente de aceleração DeepGPU.

   1. Connect to the GPU instance by using Workbench.

   2. verifique a versão do Python para garantir que atenda aos requisitos de dependência do deepgpu-torch.

      O componente de aceleração deepgpu-torch requer um ambiente Python 3.10.

      Ubuntu 22.04

      execute python3 -V para verifique a versão do Python. O Ubuntu 22.04 traz o Python 3.10.12 instalado por padrão, o que atende ao requisito.

      

      Ubuntu 20.04

      execute python3 -V para verifique a versão do Python. O Ubuntu 20.04 traz o Python 3.8.10 instalado por padrão, o que não atende ao requisito.

      

      instale o Miniconda para configurar um ambiente Python 3.10 isolado ou use outro método de sua preferência.

      1. execute o comando a seguir para baixe o script de instalação do Miniconda.

         wget https://repo.anaconda.com/miniconda/Miniconda3-py310_24.1.2-0-Linux-x86_64.sh

      2. execute os comandos a seguir para instale o Miniconda e ativar o ambiente.

         bash ./Miniconda3-py310_24.1.2-0-Linux-x86_64.sh -b -p /workspace/miniconda
         source /workspace/miniconda/bin/activate

      3. execute python3 -V novamente para verifique a versão do Python.

         

         Nota

         Ao entrar novamente no sistema, execute source /workspace/miniconda/bin/activate para alternar para o ambiente virtual Python 3.10.

   3. execute o comando a seguir para instale o torch.

      O componente de aceleração deepgpu-torch requer o torch 2.5.x+cu124 (a versão padrão do CUDA para o torch 2.5.x). Este exemplo instala o torch 2.5.0. Substitua o número da versão para instalar uma versão diferente.

      pip install torch==2.5.0

      execute python3 -c "import torch; print(torch.__version__)" para confirme que o torch 2.5.0+cu124 está instalado.

      

   4. execute os comandos a seguir para instale o deepgpu-torch.

      apt-get install which curl iputils-ping -y
      pip install deepgpu-torch==0.0.15+torch2.5.0cu124 -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/deepytorch/index.html

      execute pip list | grep deepgpu-torch para visualize a versão instalada do deepgpu-torch.

      

   5. execute os comandos a seguir para baixe e instale o plug-in do componente de aceleração DeepGPU para o ComfyUI.

      baixe o plug-in e extraia-o no diretório ComfyUI/custom_nodes/.

      cd ComfyUI/custom_nodes/
      wget https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/flux/20250102/ComfyUI-deepgpu.tar.gz
      tar zxf ComfyUI-deepgpu.tar.gz
      cd ../..
      
      pip install deepgpu-comfyui==1.0.8 -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/index.html

      execute pip list | grep deepgpu-comfyui para verifique se o plug-in está instalado.

      

Use o ComfyUI+DeepGPU para acelerar a inferência de text-to-image

Este exemplo usa uma instância gn7ix com o Ubuntu 22.04 e o componente de aceleração DeepGPU instalado para demonstrar a aceleração de text-to-image para um modelo FLUX com o ComfyUI+DeepGPU.

1. instale o ambiente base (torch, dependências do ComfyUI e o componente de aceleração DeepGPU).

   1. Connect to the GPU instance by using Workbench.

   2. execute python3 -V para verifique se a versão do Python é a 3.10.

      O Ubuntu 22.04 traz o Python 3.10.12 instalado por padrão, o que atende ao requisito de dependência do deepgpu-torch. Se você usar uma instância gpu com o Ubuntu 20.04, configure um ambiente Python 3.10 isolado. Para mais informações, consulte Ubuntu 20.04.

   3. execute o comando a seguir para instale o torch.

      # This example installs torch 2.5.0. Replace the version number to install a different version.
      pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0

      execute python3 -c "import torch; print(torch.__version__)" para visualize a versão instalada do torch.

      

   4. execute o comando a seguir para instale as dependências do ComfyUI.

      pip install PyYAML safetensors numpy Pillow einops psutil transformers scipy torchsde aiohttp comfyui-frontend-package==1.11.8 kornia spandrel av

   5. execute os comandos a seguir para instale o componente de aceleração DeepGPU.

      apt-get install which curl iputils-ping -y
      pip install deepgpu-torch==0.0.15+torch2.5.0cu124 -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/deepytorch/index.html
      pip install deepgpu-comfyui==1.0.8 -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/index.html

      execute pip list | grep deepgpu-torch ou pip list | grep deepgpu-comfyui para verifique as versões instaladas do componente de aceleração DeepGPU.

      

2. execute os comandos a seguir para baixe o source do ComfyUI.

   Este exemplo baixe o source oficial do ComfyUI. Você pode usar seu próprio código personalizado do ComfyUI.

   Ubuntu 22.04

   git clone -b v0.3.26 https://github.com/comfyanonymous/ComfyUI
   sed -i "s|comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device())|comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device(), weight_inplace_update=True)|g" ComfyUI/comfy/sd.py

   Ubuntu 20.04

   apt install git
   git clone -b v0.3.26 https://github.com/comfyanonymous/ComfyUI
   sed -i "s|comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device())|comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device(), weight_inplace_update=True)|g" ComfyUI/comfy/sd.py

3. execute os comandos a seguir para baixe o plug-in do componente de aceleração DeepGPU.

   cd ComfyUI/custom_nodes/
   wget https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/flux/20250102/ComfyUI-deepgpu.tar.gz
   tar zxf ComfyUI-deepgpu.tar.gz
   ls
   cd ../..

4. execute os comandos a seguir para baixe o modelo FLUX.

   Este exemplo baixe o modelo FLUX oficial. Você pode usar seus próprios modelos treinados.

   cd ComfyUI
   wget -P models/unet https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/flux/models/flux1-dev.safetensors
   wget -P models/clip https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/flux/models/t5xxl_fp16.safetensors
   wget -P models/clip https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/flux/models/clip_l.safetensors
   wget -P models/vae https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/flux/models/ae.safetensors

   Nota

   O download dos modelos pode levar algum tempo. Aguarde a conclusão do download.

5. execute o comando a seguir para iniciar o service do ComfyUI.

   python3 main.py --listen 0.0.0.0 --port 7860

6. Em um navegador, acesse http://IP:7860 para acesse o service do ComfyUI.

   IP é o endereço IP público da sua instância gpu.

7. Na interface do ComfyUI, escolha Workflow > Open, selecione o arquivo JSON dos example workflows e clique em Queue Prompt.

   Importante

   Se você testar primeiro um fluxo de trabalho com aceleração DeepGPU e depois testar um sem ela (ou vice-versa), reinicie o service do ComfyUI sempre que alternar.

   • Sem aceleração DeepGPU: Selecione o arquivo JSON base flux-dev (workflow_flux.JSON). A figura a seguir mostra a execução do fluxo de trabalho.

     

   • Com aceleração DeepGPU: Selecione o arquivo JSON acelerado flux-dev DeepyTorch (workflow_flux_deepytorch.JSON). A figura a seguir mostra a execução do fluxo de trabalho.

     

   Após a execução, verifique o tempo de execução de text-to-image na página de conexão remota da GPU. Para isso, visualize o tempo após o campo Prompt executed in (conforme mostrado abaixo). O desempenho é significativamente melhor com os nós de aceleração ComfyUI+DeepGPU. Para comparações detalhadas, consulte Performance comparison.

   

Visão geral de nós e fluxos de trabalho