Self-hosted AI image generator: totoong specs

Ang tunay na kailangan ng isang self-hosted AI image generator

Ang isang self-hosted AI image generator ay binubuo ng isang web app at isang model file. Ang app ay ComfyUI, at tumatakbo ito sa anumang Linux box. Ang model ang nagtatakda ng hardware na kailangan mo. Ang isang SDXL-class checkpoint ay isang file na 6.94 GB, at kailangang mailagay ito sa GPU memory. Ito ang pangunahing batayan ng buong budget, kaya basahin muna ang hardware ladder sa ibaba bago mag-rent ng server.

Ang tapat na buod: kayang i-install at i-serve ng isang CPU-only VPS ang software, at kaya nitong gumawa ng mga image sa 512x512 gamit ang mas lumang Stable Diffusion 1.5 model sa loob ng isa o dalawang minuto bawat image. Ang parehong box na nagpapatakbo ng SDXL sa 1024x1024 ay nangangailangan ng sampu hanggang dalawampung minuto bawat image. Hindi ito nangangahulugang may sira ang setup. Bunga ito ng mga limitasyon sa computation, at ipinapaliwanag ito ng gabay na ito.

Bakit ang laki ng model ang nagtatakda ng machine

Gumagawa ng image ang isang denoising loop. Sa isang 30-step render, ipinapadaan ang buong model sa image nang 30 beses, at binabasa ng bawat pass ang lahat ng weight. Humigit-kumulang 6.9 GB ng weights ang SDXL kapag half precision, kaya tinatayang 200 GB ang dumadaan sa memory bago ka makakita ng image.

Ang GPU na may 24 GB ng video memory (VRAM, ang memory na naka-solder katabi ng graphics chip) ay bumabasa sa bilis na daan-daang gigabyte bawat segundo, at kayang panatilihin nang sabay-sabay ang buong 6.9 GB. Ang CPU VPS ay bumabasa ng system RAM sa bilis na sampu-sampung gigabyte bawat segundo, at wala itong matrix hardware para sa mga convolution. Dahil dito, umaabot nang isa hanggang dalawang order of magnitude na mas mabagal ang parehong loop. Ito rin ang memory-bandwidth argument na namamahala sa mga text model, at mainam itong basahin kasabay ng kung kailan sulit ang gastos sa VPS na may GPU.

May isang mahalagang pagkakaiba ang image generation sa text generation. Nag-i-stream ng mga token ang chat model, kaya magagamit pa rin ang mabagal na machine dahil lumalabas ang mga salita habang nagbabasa ka. Lumalabas lamang ang image kapag natapos ang huling step. Kapag mabagal, tititig ka sa progress bar.

Ang hardware ladder, na may aktuwal na mga numero

Nasa block sa ibaba ang karaniwang mga sukat para sa isang SDXL image na 1024x1024, 30 steps, at Euler sampler, noong July 2026. Gamitin ang mga ito bilang pagtatantya sa order of magnitude. Maaaring magbago ang mga ito depende sa sampler, bilang ng steps, at resolution.

[
  {
    "label": "8 vCPU VPS, no GPU",
    "seconds_per_image": 780
  },
  {
    "label": "8GB VRAM GPU",
    "seconds_per_image": 32
  },
  {
    "label": "12GB VRAM GPU",
    "seconds_per_image": 18
  },
  {
    "label": "24GB VRAM GPU",
    "seconds_per_image": 9
  }
]

Ang CPU row ay 780 segundo, o humigit-kumulang labintatlong minuto. Ang 24 GB card ay 9 segundo. Iyan ang pagitan ng performance na binabayaran mo.

Ganito basahin ang ladder. Kapag mas mababa sa 8 GB ang VRAM, tumatakbo pa rin ang SDXL dahil awtomatikong nag-o-offload ang ComfyUI ng mga layer sa system RAM at kaya nitong gumamit ng card na may 1 GB lamang. Nakadaragdag ng oras ang offloading sa bawat step, kaya ang 6 GB card ay mas malapit sa isang minuto bawat image kaysa sa 30 segundo. Sa 8 GB, kasya ang base model at maayos ang rendering. Sa 12 GB, maaari kang gumamit ng isang ControlNet o dalawang ControlNet kasabay ng checkpoint nang walang offloading. Sa 24 GB, maaari mong patakbuhin ang SDXL, refiner, at upscaling sa iisang workflow, at maaari ka nang magsimulang mag-train ng LoRA adapters, na nangangailangan ng mas malaking memory kaysa sa image generation.

Ano ang kaya at hindi kayang gawin ng CPU VPS

Mas marami itong kayang gawin kaysa sa inaasahan ng ilan, ngunit mas kaunti kaysa sa ipinahihiwatig ng marketing. Tukuyin nang malinaw ang limitasyon.

Maaaring mag-install ang CPU VPS ng ComfyUI, maghatid ng web interface, mag-imbak ng iyong model library, magpatakbo ng queue, at bumuo ng mga image kahit walang GPU. Sa Stable Diffusion 1.5 sa 512x512 at 20 steps, asahan ang humigit-kumulang 60 hanggang 150 segundo bawat image sa 8 modernong vCPU na may 16 GB RAM. Para sa batch job na tumatakbo magdamag, o low-volume image endpoint na nasa likod ng queue, sapat talaga ito.

Hindi kayang magbigay ng interactive na workflow ang CPU VPS. Ang prompt iteration ay nangangailangan ng 20 render sa loob ng isang oras, ngunit kung 13 minuto ang bawat isa, 4 lang ang makukuha mo. Hindi rin ito kayang gamitin sa training. Ang LoRA fine-tuning sa CPU ay tumatagal ng ilang araw, hindi ilang oras, kaya ituring itong hindi praktikal.

Iba ang memory rule para sa CPU-only kumpara sa GPU rule. Nilo-load ang weights sa system RAM, kaya kailangan mo ang laki ng model kasama ang working space: humigit-kumulang 16 GB RAM para sa SDXL, at humigit-kumulang 8 GB para sa SD 1.5. Mag-uumpisa ang ComfyUI sa isang 4 GB na machine, ngunit papatayin ito ng out-of-memory killer sa kalagitnaan ng unang render. Makikita ito bilang biglang pagkawala ng process na may Killed sa dmesg at walang Python traceback.

I-install ang ComfyUI sa isang GPU machine

Ito ang mga command mula sa upstream. Magsimula sa malinis na Ubuntu 24.04 installation na mayroon nang NVIDIA driver. Kumpirmahin muna ang driver, dahil pare-pareho ang hitsura ng lahat ng susunod na failure kapag hindi ito nasuri.

nvidia-smi

Dapat itong mag-print ng table na naglalaman ng iyong card at bersyon ng CUDA. Ang command not found o NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver ay nangangahulugang nawawala ang driver o hindi nag-load ang kernel module pagkatapos ng upgrade. Ayusin muna ito bago magpatuloy, dahil tahimik na lilipat ang ComfyUI sa CPU at masisisi mo ang software.

sudo apt update
sudo apt install -y git python3-venv python3-pip wget
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
. venv/bin/activate
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txt

Hindi opsyonal na payo ang virtual environment. Kumukuha ang PyTorch ng malaking dependency tree, at ang pag-install nito system-wide sa isang machine na nagpapatakbo ng iba pang software ang nagiging sanhi ng pagkasira ng ibang software. I-verify na nakikita ng PyTorch ang card bago magpatuloy.

python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"

Ang True kasama ang pangalan ng iyong card ay nangangahulugang gumagana ang stack. Ang False ay nangangahulugang hindi tugma ang wheel na na-install mo sa driver, karaniwan dahil naka-cache na ang CPU-only torch wheel. Mag-install muli gamit ang index URL sa itaas.

Kumuha ng model, at magplano para sa disk

Walang kasamang weights ang ComfyUI. Ilagay ang mga checkpoint sa models/checkpoints, ang mga VAE file sa models/vae, at ang mga LoRA adapter sa models/loras.

cd ~/ComfyUI/models/checkpoints
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

Palaging piliin ang .safetensors kaysa sa .ckpt. Ang .ckpt file ay isang pickled Python object, at ang pag-load dito ay nagpapatakbo ng code mula sa gumawa nito. Mga tensor lamang ang nilalaman ng safetensors format, kaya walang mapapatakbong code ang isang mapanganib na file.

Ang storage ay gastos na madalas makalimutan. Ang isang SDXL base checkpoint ay 6.94 GB. May dagdag na 6 GB ang refiner. Kumokonsumo ang isang ControlNet model ng 1.4 hanggang 2.5 GB, ang isang upscaler ng 60 hanggang 350 MB, at ang isang LoRA ng 20 hanggang 400 MB. Sa loob ng isang linggo, karaniwang nagda-download ng pangalawa at pangatlong base model ang mga regular na gumagamit nito. Maglaan ng 100 GB na disk para sa gumaganang installation, at subaybayan din ang outputs directory: ang mga PNG file na 1024x1024 ay may sukat na 1 hanggang 2 MB bawat isa, at mabilis na mapupuno ng isang batch na walang monitoring ang maliit na disk. Ilagay ang models/ at output/ sa volume na maaari mong palakihin, at i-back up ang iyong workflow JSON files gamit ang tulad ng encrypted incremental backups sa object storage. Maaaring i-download muli ang weights. Hindi maaaring ibalik ang mga workflow na inayos mo.

Patakbuhin ito at ligtas na i-access

cd ~/ComfyUI
. venv/bin/activate
python main.py --listen 127.0.0.1 --port 8188

Naghahain ang ComfyUI sa port 8188. Sa machine na CPU-only, idagdag ang --cpu. Pinipilit nito ang CPU path sa halip na mag-fail dahil walang CUDA device.

I-bind ito sa 127.0.0.1, hindi sa 0.0.0.0. Walang login screen at user accounts ang ComfyUI. Ang sinumang makakaabot sa port ay maaaring mag-queue ng mga job, magbasa ng lahat ng image na ginawa mo, at mag-install ng custom nodes. Nangangahulugan ito ng arbitrary code execution sa server mo. Sa halip, i-access ito sa pamamagitan ng SSH tunnel mula sa laptop mo.

ssh -N -L 8188:127.0.0.1:8188 you@your-server

Pagkatapos, buksan ang http://127.0.0.1:8188 nang lokal. Kung kailangan mo ng tunay na multi-user access, maglagay ng reverse proxy na may authentication sa harap nito at panatilihing naka-bind ang app sa localhost. Nalalapat din ang parehong prinsipyo sa anumang self-hosted service na walang authentication, at ito ang standard pattern sa Docker Compose deployment sa isang VPS.

Panatilihin itong tumatakbo sa ilalim ng systemd

Ang render queue na namamatay kapag nagsasara ang iyong SSH session ay hindi isang service. Isulat ang /etc/systemd/system/comfyui.service.

[Unit]
Description=ComfyUI
After=network-online.target

[Service]
User=comfy
WorkingDirectory=/home/comfy/ComfyUI
ExecStart=/home/comfy/ComfyUI/venv/bin/python main.py --listen 127.0.0.1 --port 8188
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now comfyui
systemctl status comfyui

Ang active (running) at isang log line na may To see the GUI go to: http://127.0.0.1:8188 ay nangangahulugang gumagana na ito. Tandaan na direktang tinutukoy ng ExecStart ang interpreter sa loob ng virtual environment, dahil hindi pinapatakbo ng systemd ang iyong shell profile at hindi kailanman nangyayari ang activate.

Praktikal na rekomendasyon ayon sa badyet

Kung gusto mong subukan ang image generation at mas mahalaga ang gastos kaysa bilis, kumuha ng CPU VPS na may 16 GB RAM, patakbuhin ang SD 1.5 sa 512x512, at tanggapin ang isa o dalawang minuto bawat image. Ito ang makatotohanang panimulang setup, at maliit na bahagi lang ng gastos nito kumpara sa anumang may kasamang GPU. Ito rin ang tamang lugar para i-host ang model library at mga workflow habang nagpapasya ka.

Kung araw-araw kang nag-i-iterate sa prompts, mag-rent ng GPU na may hindi bababa sa 12 GB VRAM bawat oras mula sa isang GPU cloud, at i-shut down ito kapag tapos ka na. Bursty ang image generation, at ang idle GPU na buwanang sinisingil ang pinakakaraniwang dahilan kung bakit lumalaki nang sobra ang gastos dito. Itago ang mga checkpoint sa murang block storage at i-mount ang mga ito.

Kung magsisilbi ka sa ibang tao, o magsasanay ka ng mga LoRA adapter, kailangan mo ng 24 GB VRAM at machine na palagi mong pinananatiling naka-on. Sa puntong ito, karaniwang sulit nang gamitin ang parehong box para magpatakbo rin ng local language model, gaya ng setup na inilalarawan sa self-hosting ng LLM gamit ang Ollama.

Anumang antas ang piliin mo, sukatin muna ang sarili mong machine bago maniwala sa anumang inilathalang value. I-queue ang parehong prompt nang limang beses at basahin ang seconds-per-iteration na ipinapakita ng ComfyUI sa console nito. Ang numerong iyon ang tunay mong posisyon sa mga antas ng performance.

FAQ

Maaari ko bang patakbuhin ang Stable Diffusion nang walang GPU?

Oo. Tumatakbo ang ComfyUI gamit ang python main.py --cpu at nakakagawa ng aktuwal na mga image kahit walang graphics card. Asahan ang humigit-kumulang 60 hanggang 150 segundo bawat image para sa Stable Diffusion 1.5 sa 512x512, at 10 hanggang 20 minuto para sa SDXL sa 1024x1024, gamit ang 8 modernong vCPU. Sapat ito para sa overnight batch at mga endpoint na mababa ang volume. Hindi ito angkop para sa paulit-ulit na pag-adjust ng prompt, at hindi praktikal ang training.

Gaano karaming VRAM ang kailangan ko para sa SDXL?

Komportableng tumatakbo ang SDXL sa 1024x1024 gamit ang 8 GB. Kapag mas mababa rito, awtomatikong inililipat ng ComfyUI ang mga layer sa system RAM at gumagana pa rin ito hanggang humigit-kumulang 1 GB ng VRAM, ngunit bawat hakbang na inililipat ay nakadaragdag sa oras ng pagproseso. Sa 12 GB, maaari mong isabay ang isang ControlNet sa checkpoint. Sapat ang 24 GB para sa base, refiner, at upscaling sa iisang workflow, at ito ang praktikal na minimum para sa pag-training ng mga LoRA adapter.

Gaano karaming disk space ang kailangan ng mga model?

Ang SDXL base checkpoint lamang ay 6.94 GB, at nagdaragdag ang refiner ng humigit-kumulang 6 GB. Ang mga ControlNet model ay 1.4 hanggang 2.5 GB bawat isa, ang mga LoRA adapter ay 20 hanggang 400 MB, at ang mga upscaler ay hanggang 350 MB. Maglaan ng 100 GB para sa gumaganang installation na may ilang base model. I-monitor nang hiwalay ang output directory dahil umaabot sa 1 hanggang 2 MB bawat isa ang mga PNG file na 1024x1024.

Ligtas bang ilantad ang ComfyUI sa public internet?

Hindi. Walang anumang authentication ang ComfyUI, at nag-i-install at nagpapatakbo ang custom-node system nito ng Python code mula sa interface. Dahil dito, ang bukas na port ay nangangahulugang remote code execution sa server mo. I-bind ito sa 127.0.0.1, i-access ito sa pamamagitan ng SSH tunnel gamit ang ssh -N -L 8188:127.0.0.1:8188 you@your-server, at maglagay ng authenticating reverse proxy sa harap nito kung higit sa isang tao ang nangangailangan ng access.

Bakit pinatay ang render ko nang walang error message?

Kung mawala ang proseso kasabay ng Killed sa dmesg at walang Python traceback, Linux out-of-memory killer ito, hindi bug ng ComfyUI. Sa CPU-only server, nasa system RAM ang mga weight. Kaya kailangan ng SDXL ng humigit-kumulang 16 GB at ng SD 1.5 ng humigit-kumulang 8 GB, bukod pa sa working space. Magdagdag ng RAM, magdagdag ng swap, o gumamit ng mas maliit na model at mas mababang resolution.