Self-hosted AI Image Generator: Specs at Gastos

Ano talaga ang 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 kailangan mong hardware. Isang file na 6.94 GB ang isang SDXL-class checkpoint, at kailangan nitong manatili sa GPU memory. Dahil dito nakabatay ang buong budget, kaya basahin muna ang hardware ladder sa ibaba bago mag-rent ng anuman.

Ang tapat na buod: maaaring mag-install at mag-serve ng software ang isang CPU-only VPS, at maaari itong mag-generate 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 ibig sabihin nito na may sira ang setup. Usapin ito ng computation, at ipinapaliwanag ito ng gabay na ito.

Bakit ang laki ng model ang nagtatakda sa makina

Gumagana ang image generation sa pamamagitan ng denoising loop. Sa isang 30-step render, ipinapadaan ang buong model sa image nang 30 beses, at binabasa ng bawat pass ang lahat ng weights. Ang SDXL sa half precision ay may humigit-kumulang 6.9 GB na weights, kaya sa isang 30-step render, 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 nakakabit sa tabi ng graphics chip) ay bumabasa nang daan-daang gigabytes bawat segundo, at kayang ilagay ang buong 6.9 GB nang sabay-sabay. Ang CPU VPS ay bumabasa sa system RAM nang sampu-sampung gigabytes bawat segundo, at wala itong matrix hardware para sa mga convolution. Dahil dito, ang parehong loop ay tumatakbo nang isa hanggang dalawang order of magnitude na mas mabagal. Ito rin ang memory-bandwidth argument na nakaaapekto sa mga text model, at mainam itong basahin kasabay ng kung kailan sulit gastusan ang VPS na may GPU.

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

Ang hardware ladder, gamit ang aktuwal na mga numero

Ang block sa ibaba ay naglalaman ng mga karaniwang figure para sa isang SDXL image na 1024x1024, 30 steps, at Euler sampler, noong July 2026. Ituring ang mga ito bilang order of magnitude lamang. Nagbabago 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 performance gap na binabayaran mo.

Ganito basahin ang ladder. Sa mas mababa sa 8 GB ng 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. May dagdag na oras ang offloading sa bawat step, kaya ang 6 GB card ay mas malapit sa isang minuto bawat image kaysa sa tatlumpung segundo. Sa 8 GB, kasya ang base model at maayos ang rendering. Sa 12 GB, maaari kang maglagay ng isang ControlNet o dalawang ControlNet kasabay ng checkpoint nang hindi nag-o-offload. Sa 24 GB, maaari mong patakbuhin ang SDXL, refiner, at upscaling sa iisang workflow, at maaari ka nang mag-train ng LoRA adapters, na nangangailangan ng mas maraming memory kaysa sa image generation.

Ano ang kaya at hindi kayang gawin ng CPU VPS

Mas marami itong kayang gawin kaysa sa inaakala ng marami, pero mas kaunti kaysa sa ipinapahiwatig ng marketing. Tukuyin nang malinaw ang limitasyon.

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

Hindi kayang magbigay ng interactive na workflow ang CPU VPS. Ang prompt iteration ay maaaring mangailangan ng 20 render sa loob ng isang oras, pero kung 13 minuto ang bawat isa, 4 lang ang matatapos. Hindi rin ito angkop para sa training. Ang LoRA fine-tuning sa CPU ay inaabot ng mga araw, hindi mga oras, kaya ituring itong hindi available.

Iba ang memory rule para sa CPU-only kaysa sa GPU rule. Naglo-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. Magsisimula ang ComfyUI sa isang 4 GB na machine, pero papatayin ito ng out-of-memory killer sa kalagitnaan ng unang render. Makikita ito kapag biglang nawawala ang process na may Killed sa dmesg at walang Python traceback.

Mag-install ng ComfyUI sa isang GPU machine

Ito ang mga upstream command. Magsimula sa malinis na Ubuntu 24.04 installation na may naka-install nang NVIDIA driver. Kumpirmahin muna ang driver, dahil pare-pareho ang hitsura ng bawat susunod na failure kapag hindi isinagawa ang check na ito.

nvidia-smi

Dapat itong mag-print ng table na may iyong card at isang CUDA version. Ibig sabihin ng command not found o NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver na nawawala ang driver o hindi na-load ang kernel module matapos ang upgrade. Ayusin muna ito bago magpatuloy, dahil tahimik na magfa-fallback ang ComfyUI sa CPU at mapagkakamalan mong software ang problema.

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 optional na payo ang virtual environment. Kumukuha ang PyTorch ng malaking dependency tree, at ang pag-install nito sa buong system sa isang box na nagpapatakbo ng iba pang software ang dahilan kung bakit nasisira ang 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. Ibig sabihin ng False na hindi tugma ang wheel na na-install mo sa driver, karaniwan dahil naka-cache na ang isang CPU-only torch wheel. Mag-install muli gamit ang index URL sa itaas.

Kumuha ng model at maglaan ng sapat na disk space

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 .ckpt. Ang .ckpt file ay isang pickled Python object, at kapag ni-load ito, nag-e-execute ito ng code mula sa gumawa nito. Tensor lamang ang nilalaman ng safetensors format, kaya walang mae-execute ang isang malisyosong file.

Ang storage ang madalas nakakaligtaan sa pagkuwenta ng gastos. Ang isang SDXL base checkpoint ay 6.94 GB. May karagdagang 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. Karaniwang nagda-download ang mga gumagamit ng pangalawa at pangatlong base model sa loob ng isang linggo. Maglaan ng 100 GB na disk space para sa gumaganang installation, at bantayan din ang outputs directory: 1 hanggang 2 MB ang bawat 1024x1024 PNG file, at tahimik na mapupuno ng unattended batch 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 gaya ng encrypted incremental backups sa object storage. Maaaring i-download muli ang weights. Hindi na maibabalik 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

Nagseserve ang ComfyUI sa port 8188. Sa CPU-only na machine, 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. Sinumang makaka-access sa port ay maaaring mag-queue ng jobs, magbasa ng lahat ng image na nagawa mo, at mag-install ng custom nodes. Ang mga ito ay maaaring magpatupad ng arbitrary code 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 unahan nito at panatilihing naka-bind ang app sa localhost. Nalalapat din ang parehong prinsipyo sa anumang self-hosted service na walang authentication. Ito ang standard pattern sa Docker Compose deployment sa isang VPS.

Panatilihin itong tumatakbo sa ilalim ng systemd

Ang render queue na namamatay kapag nagsara 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

Ibig sabihin ng active (running) at ng log line na To see the GUI go to: http://127.0.0.1:8188 na tumatakbo 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 budget

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

Kung araw-araw kang nag-iiterate sa mga prompt, umarkila kada oras ng GPU na may hindi bababa sa 12 GB VRAM mula sa isang GPU cloud, at i-shut down ito kapag tapos ka na. Bursty ang image generation, at ang idle GPU na sinisingil buwan-buwan ang pinakakaraniwang dahilan kung bakit napapasobra ang gastos ng mga tao rito. Itago ang mga checkpoint sa murang block storage at i-mount ang mga ito.

Kung magseserve ka para sa ibang tao, o magte-train ka ng LoRA adapters, kailangan mo ng 24 GB VRAM at machine na patuloy mong pinananatiling naka-on. Sa puntong iyon, karaniwan ding sulit gamitin ang parehong box para magpatakbo ng local language model, na siyang setup na inilalarawan sa self-hosting ng LLM gamit ang Ollama.

Anuman ang rung na piliin mo, sukatin muna ang sarili mong machine bago maniwala sa anumang published figure. 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 ladder.

FAQ

Maaari ko bang patakbuhin ang Stable Diffusion nang walang GPU?

Oo. Tumatakbo ang ComfyUI gamit ang python main.py --cpu at nakakagawa ito 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. Angkop ito para sa overnight batch at low-volume endpoint. Hindi ito angkop para sa paulit-ulit na pag-aayos ng prompt, at hindi talaga praktikal ang training.

Gaano karaming VRAM ang kailangan ko para sa SDXL?

Komportable ang SDXL sa 1024x1024 gamit ang 8 GB. Kapag mas mababa rito, awtomatikong nag-o-offload ang ComfyUI ng mga layer sa system RAM at gumagana pa rin hanggang humigit-kumulang 1 GB ng VRAM, pero bawat offloaded step ay nagdaragdag ng oras. Sa 12 GB, maaari mong isabay ang isang ControlNet sa checkpoint. Sa 24 GB, sapat ang memory para sa base, refiner, at upscaling sa iisang workflow, at ito ang praktikal na minimum para sa pag-train ng mga LoRA adapter.

Gaano kalaking 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 umaabot sa 350 MB ang mga upscaler. Maglaan ng 100 GB para sa functional na install na may ilang base model. Bantayan nang hiwalay ang output directory, dahil umaabot sa 1 hanggang 2 MB ang bawat 1024x1024 PNG file.

Ligtas bang i-expose 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 open port ay nangangahulugang remote code execution sa server mo. I-bind ito sa 127.0.0.1, i-access sa SSH tunnel gamit ang ssh -N -L 8188:127.0.0.1:8188 you@your-server, at maglagay ng reverse proxy na may authentication sa harap nito kung higit sa isang tao ang kailangang gumamit nito.

Bakit pinatay ang render ko nang walang error message?

Kung nawawala ang process na may Killed sa dmesg at walang Python traceback, Linux out-of-memory killer ito, hindi bug ng ComfyUI. Sa CPU-only na server, nasa system RAM ang weights. 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.