מדריך ComfyUI המלא
Workflows, ControlNet, IP-Adapter, AnimateDiff ו-Python API

מה זה ComfyUI?

ComfyUI הוא ממשק גרפי מבוסס-נודים (nodes) עבור מודלי Stable Diffusion, שפותח על ידי comfyanonymous ב-2023 ופורסם כקוד פתוח ב-GitHub. בניגוד לממשקים מסורתיים כמו AUTOMATIC1111 שמציגים לך טאבים ופרמטרים מוכנים, ComfyUI חושף את כל ה-pipeline של יצירת תמונה כגרף של נודים מחוברים — כל נוד הוא פונקציה, וכל חיבור בין נודים הוא זרימת נתונים.

הגישה הזו מעניקה שקיפות ושליטה מלאות: אתה רואה בדיוק מה קורה בכל שלב של תהליך הדנוייזינג, מי מקבל את מה, ואפשר לשנות כל חיבור בלחיצה. זה גם הופך את ComfyUI למהיר יותר מהמתחרים — ניהול הזיכרון (VRAM) שלו יעיל בהרבה, ואפשר להריץ מודלים כבדים על GPU עם פחות VRAM.

מעבר לכך, ComfyUI הפך לסטנדרט דה-פקטו בקהילה המקצועית. כשמישהו מפרסם Workflow חדש — בין אם זה ControlNet מתקדם, IP-Adapter, או AnimateDiff — הוא מפרסם אותו בפורמט JSON של ComfyUI. גרירת תמונה שנוצרה ב-ComfyUI לממשק שלו תטעין את כל ה-Workflow אוטומטית, כולל כל הפרמטרים.

השוואה: ComfyUI vs AUTOMATIC1111 vs Forge

מפת דרכים לשליטה ב-ComfyUI

להלן מסלול למידה מובנה — מהתקנה ראשונה ועד בניית Pipeline ייצור מלא עם Python API. כל שלב בנוי על הקודם, ואפשר לעצור בכל נקודה ולעבוד עם מה שלמדת.

התקנה

יש שתי דרכים עיקריות להתקין ComfyUI — הדרך הגרפית הקלה, והדרך הידנית שנותנת שליטה מלאה.

שיטה 1: ComfyUI Desktop (מומלץ למתחילים)

ComfyUI Desktop הוא אפליקציה ייעודית ל-Windows ו-Mac עם התקנה בלחיצה אחת. היא כוללת Python מובנה, CUDA drivers, ומנהל מודלים גרפי. אפשר להוריד אותה מ-comfy.org ישירות.

שיטה 2: Git Clone (מומלץ למפתחים)

git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt
python main.py --listen

הדגל --listen מאפשר גישה מרשת מקומית (לא רק localhost). אם יש לך GPU של Nvidia, ComfyUI ישתמש בו אוטומטית. לאפל Silicon (M1/M2/M3) הוסף --force-fp16.

מבנה התיקיות

לאחר ההתקנה, תצטרך להכניס מודלים לתיקיות הנכונות:

• models/checkpoints/ — מודלים ראשיים (SDXL, SD1.5, Flux)
• models/loras/ — קבצי LoRA
• models/controlnet/ — מודלי ControlNet
• models/vae/ — מודלי VAE חיצוניים
• models/ipadapter/ — מודלי IP-Adapter
• custom_nodes/ — הרחבות קהילתיות

נודים ו-Workflows — הפרדיגמה הבסיסית

ב-ComfyUI, כל נוד מייצג פונקציה אחת — טעינת מודל, קידוד פרומפט, יצירת latent space, דנוייזינג, פענוח. הקווים המחברים ביניהם (edges) מייצגים זרימת נתונים — הפלט של נוד אחד נכנס לקלט של הבא. כך אפשר לראות בדיוק מה קורה בכל שלב, ולשנות כל חיבור בנפרד.

נודי הליבה של כל Workflow

• CheckpointLoaderSimple — טוען מודל SDXL / SD1.5 / Flux מתיקיית checkpoints
• CLIPTextEncode — מקודד פרומפט לrepresentation וקטורי (positive ו-negative בנפרד)
• EmptyLatentImage — יוצר latent space ריק בגודל הרצוי (width, height, batch_size)
• KSampler — לב תהליך הדנוייזינג — מריץ את האלגוריתם על ה-latent
• VAEDecode — מפענח latent space לתמונה פיקסלים רגילה
• SaveImage — שומר את התמונה לדיסק עם שם קובץ ותיקייה

הWorkflow הבסיסי — Text to Image

ה-Workflow הבסיסי ביותר מחבר 6 נודים בשרשרת: CheckpointLoaderSimple טוען את המודל ומוציא שלושה פלטים (model, clip, vae). ה-clip נכנס לשני נודי CLIPTextEncode — אחד לפרומפט החיובי ואחד לשלילי. EmptyLatentImage יוצר latent ריק. כל הקלטים מתאחדים ב-KSampler, שמוציא latent מעובד. VAEDecode מפענח אותו לתמונה, ו-SaveImage שומר אותה.

KSampler לעומק

ה-KSampler הוא הנוד החשוב ביותר ב-ComfyUI — הוא מריץ את אלגוריתם הדנוייזינג שהופך noise לתמונה. כל פרמטר שלו משפיע על התוצאה הסופית, וחשוב להבין מה כל אחד עושה.

כל הפרמטרים

• model — קלט מ-CheckpointLoaderSimple: מודל ה-diffusion עצמו
• positive — conditioning חיובי מ-CLIPTextEncode: מה שרוצים
• negative — conditioning שלילי: מה שלא רוצים
• latent_image — latent ריק (text2img) או מתמונה (img2img)
• seed — מספר שמגדיר את ה-noise הראשוני. אותו seed = אותה תמונה
• steps — מספר צעדי דנוייזינג (20–30 לאיכות, 4–8 ל-LCM)
• cfg — Classifier Free Guidance: עד כמה לדבוק בפרומפט
• sampler_name — האלגוריתם: euler, dpm++_2m, lcm ועוד
• scheduler — לוח הזמנים של הnoise: karras, normal, exponential
• denoise — 1.0 לתמונה חדשה, 0.5–0.8 ל-img2img

טבלת Samplers

Schedulers: השתמש ב-karras ברוב המקרים — הוא מתפלג הנoise בצורה שמייצרת תמונות חדות יותר. normal הוא ברירת המחדל, exponential מתאים ל-SDXL, ו-sgm_uniform ייעודי לFlux.

ControlNet — שליטה מלאה על המבנה

ControlNet הוא אחד החידושים החשובים ביותר בעולם Stable Diffusion. הוא מאפשר לשלוט על מרחב, פוזה, קצוות ועומק של התמונה הנוצרת — לא רק דרך הפרומפט, אלא דרך תמונת reference שמכווינה את תהליך הדנוייזינג.

סוגי ControlNet ומתי להשתמש בכל אחד

• Canny — מזהה קצוות חדות בתמונה. מתאים להעתקת מבנה ותבנית ממקור לתמונה חדשה עם סגנון שונה
• Depth — מפה תלת-ממדית של עומק הסצנה. שומר על פרספקטיבה ומרחב גם בסגנון חדש לגמרי
• OpenPose — מזהה פוזת גוף אנושית ועצמות. מאפשר לשכפל תנוחה מדויקת ממודל לתמונה חדשה
• Scribble — sketch גס → תמונה ריאליסטית. מצוין לרעיונות מהירים
• SoftEdge — קצוות רכים יותר מ-Canny. מתאים לסגנונות עדינים ואמנותיים
• Tile — שומר פרטים קיימים תוך Upscale. הדרך הטובה ביותר לשדרג רזולוציה

Workflow של ControlNet

ב-ComfyUI, ControlNet מוסיף שני נודים לWorkflow הרגיל: AuxPreprocessor (Canny/Depth/Pose) מעבד את תמונת ה-reference, ControlNetLoader טוען את מודל ה-ControlNet המתאים, ו-ControlNetApply מחבר את ה-conditioning לKSampler. הסדר הוא: LoadImage → AuxPreprocessor → ControlNetLoader → ControlNetApply (+ CLIPTextEncode outputs) → KSampler.

פרמטרי ControlNet

• strength — עד כמה ControlNet שולט: 0.5–1.0 לרוב המקרים. גבוה מ-1.0 מאבד יצירתיות
• start_percent — באיזה שלב ControlNet מתחיל: 0.0 = מההתחלה
• end_percent — באיזה שלב ControlNet מסיים: 0.8 = מסיים לפני הסוף (מאפשר יצירתיות בשלבים הסופיים)

IP-Adapter — Style Transfer ללא אימון

IP-Adapter (Image Prompt Adapter) מאפשר להעביר style ו-identity מתמונת reference לתמונה חדשה — בלי לאמן LoRA, בלי לחכות שעות. פשוט מספקים תמונה, ומגדירים כמה משקל לתת לה.

גרסאות IP-Adapter

• IP-Adapter Standard — style transfer כללי: סגנון, צבעים, טקסטורות
• IP-Adapter Plus — שומר פרטים יותר מהמקור, מתאים לreference מורכב
• IP-Adapter FaceID — שמירת identity של פרצוף ספציפי — הפנים נשמרות גם בסצנות שונות
• IP-Adapter Plus Face — שילוב הטוב משניהם: FaceID עם Plus accuracy

Workflow בסיסי

הנודים הנוספים שנכנסים לWorkflow: LoadImage (תמונת reference) → IPAdapterModelLoader (טעינת מודל IP-Adapter) → IPAdapterApply (מחבר בין ה-reference לmodel ול-conditioning) → KSampler.

פרמטרים חשובים

• weight 0.5–1.0 — לrestyle מלא: style transfer עז
• weight 0.3–0.6 — לsubjective style: השפעה עדינה יותר, הפרומפט שולט
• start_at / end_at — מגדירים באיזה חלק מה-sampling IP-Adapter פעיל

AnimateDiff — מסרטון תמונות לוידאו קוהרנטי

AnimateDiff מוסיף temporal consistency — עקביות בין פריימים — לתהליך יצירת תמונות. במקום לייצר פריימים עצמאיים שנראים שונים זה מזה, AnimateDiff "יודע" שהפריימים צריכים להיות חלק מסדרה קוהרנטית ומייצר וידאו חלק.

נודי הליבה של AnimateDiff

• ADE_AnimateDiffLoaderWithContext — טוען את AnimateDiff v3 עם תמיכה ב-context window ארוך
• ADE_UseEvolvedSampling — עוטף את ה-KSampler הרגיל עם temporal attention
• VHS_VideoCombine — מאחד את כל הפריימים ל-GIF או MP4

פרמטרים עיקריים

• frame_rate — קצב פריימים: 8–16fps לאנימציה חלקה
• loop_count — 0 = לולאה אינסופית (לGIF), 1+ למספר לולאות
• context_length — כמה פריימים נוצרים ביחד: 16 = שניה ב-16fps

Motion LoRAs

Motion LoRAs הם קבצי LoRA מיוחדים שמוסיפים תנועה ספציפית לסרטון: zoom-in, zoom-out, pan-left, pan-right, tilt-up, roll. אפשר לשלב כמה Motion LoRAs עם משקלים שונים ליצירת תנועות מורכבות.

Python API — אוטומציה בסקייל

ComfyUI רץ כשרת HTTP על פורט 8188 עם WebSocket לעדכוני progress. זה מאפשר לשלוח Workflows בתכנות, להמתין לסיום, ולהוריד תמונות — כל זה ממקוד Python.

Client מלא עם WebSocket

import json
import urllib.request
import urllib.parse
import uuid
import websocket

SERVER_ADDRESS = "127.0.0.1:8188"
CLIENT_ID = str(uuid.uuid4())

def queue_prompt(prompt_workflow: dict) -> dict:
    """שליחת Workflow לתור"""
    data = json.dumps({
        "prompt": prompt_workflow,
        "client_id": CLIENT_ID
    }).encode("utf-8")
    req = urllib.request.Request(
        f"http://{SERVER_ADDRESS}/prompt",
        data=data,
        headers={"Content-Type": "application/json"}
    )
    return json.loads(urllib.request.urlopen(req).read())

def get_image(filename: str, subfolder: str, folder_type: str) -> bytes:
    """הורדת תמונה שנוצרה"""
    params = urllib.parse.urlencode({
        "filename": filename,
        "subfolder": subfolder,
        "type": folder_type
    })
    return urllib.request.urlopen(
        f"http://{SERVER_ADDRESS}/view?{params}"
    ).read()

def wait_for_completion(prompt_id: str) -> list:
    """המתנה לסיום ושליפת תמונות דרך WebSocket"""
    ws = websocket.WebSocket()
    ws.connect(f"ws://{SERVER_ADDRESS}/ws?clientId={CLIENT_ID}")
    images = []
    while True:
        msg = json.loads(ws.recv())
        if msg["type"] == "executing":
            if msg["data"]["node"] is None and \
               msg["data"]["prompt_id"] == prompt_id:
                break
        elif msg["type"] == "executed":
            for img_data in msg["data"].get("output", {}).get("images", []):
                images.append(get_image(
                    img_data["filename"],
                    img_data["subfolder"],
                    img_data["type"]
                ))
    ws.close()
    return images

# Workflow בסיסי text-to-image
WORKFLOW = {
    "4": {"class_type": "CheckpointLoaderSimple",
          "inputs": {"ckpt_name": "v1-5-pruned-emaonly.safetensors"}},
    "5": {"class_type": "EmptyLatentImage",
          "inputs": {"width": 512, "height": 512, "batch_size": 1}},
    "6": {"class_type": "CLIPTextEncode",
          "inputs": {"clip": ["4", 1],
                     "text": "a beautiful sunset over Tel Aviv beach, photorealistic"}},
    "7": {"class_type": "CLIPTextEncode",
          "inputs": {"clip": ["4", 1],
                     "text": "ugly, blurry, watermark, low quality"}},
    "3": {"class_type": "KSampler",
          "inputs": {"model": ["4", 0], "positive": ["6", 0],
                     "negative": ["7", 0], "latent_image": ["5", 0],
                     "seed": 42, "steps": 20, "cfg": 7.0,
                     "sampler_name": "euler_ancestral",
                     "scheduler": "karras", "denoise": 1.0}},
    "8": {"class_type": "VAEDecode",
          "inputs": {"samples": ["3", 0], "vae": ["4", 2]}},
    "9": {"class_type": "SaveImage",
          "inputs": {"images": ["8", 0], "filename_prefix": "TLV"}}
}

result = queue_prompt(WORKFLOW)
images = wait_for_completion(result["prompt_id"])
from pathlib import Path
for i, img in enumerate(images):
    Path(f"output_{i}.png").write_bytes(img)
    print(f"נשמר: output_{i}.png")

Batch Generation

import json
from pathlib import Path

def generate_batch(prompts: list, output_dir: str = "batch") -> None:
    """יצירת batch של תמונות ממספר פרומפטים"""
    Path(output_dir).mkdir(exist_ok=True)
    for idx, prompt_text in enumerate(prompts):
        wf = json.loads(json.dumps(WORKFLOW))
        wf["6"]["inputs"]["text"] = prompt_text
        wf["3"]["inputs"]["seed"] = idx
        result = queue_prompt(wf)
        imgs = wait_for_completion(result["prompt_id"])
        for img in imgs:
            out = Path(output_dir) / f"image_{idx:03d}.png"
            out.write_bytes(img)
            print(f"+ {out}")

# שימוש
generate_batch([
    "street art in Jerusalem old city, vibrant colors",
    "Negev desert at sunrise, dramatic lighting",
    "Tel Aviv skyline at night, long exposure",
    "Haifa bay from above, aerial photography",
])

5 פרויקטים מעשיים

להלן 5 פרויקטים מדורגים לפי רמת קושי — מ-Workflow בסיסי ועד Pipeline ייצור מלא עם Python.

גיליון עזר

קיצורי מקלדת

CFG לפי מודל

Samplers מומלצים

Custom Nodes חיוניים