palette
קורס פרמיום · גישה מלאה

Stable Diffusion & ComfyUI Pro

schedule15+ שעות rocket_launch8 פרויקטים downloadWorkflows להורדה updateעדכון אחרון: אפריל 2026
01
מודול ראשון

סביבת עבודה

1.1

התקנה על Windows (NVIDIA GPU)

כדי להפעיל Stable Diffusion ו-ComfyUI מקומית על Windows, תצטרך את הרכיבים הבאים:

דרישות חומרה
  • NVIDIA GPU עם 8GB VRAM לפחות (RTX 3060 ומעלה מומלץ)
  • 20GB+ שטח דיסק פנוי (SSD מומלץ)
  • 16GB RAM לפחות
דרישות תוכנה
  • Python 3.10.x בלבד — לא 3.11 ולא 3.12
  • Git for Windows
  • NVIDIA CUDA Toolkit 12.1+
warning חשוב מאוד

השתמש ב-Python 3.10.x בלבד. גרסאות חדשות יותר שוברות תאימות עם מספר ספריות ליבה של PyTorch ו-ComfyUI.

שלב 1 — התקנת Python 3.10

הורד מ-python.org/downloads/release/python-31011/ וסמן "Add Python to PATH" בזמן ההתקנה — זה קריטי.

שלב 2 — התקנת Git

הורד מ-git-scm.com/download/win והשאר את כל ההגדרות על Default.

שלב 3 — שכפול ComfyUI והתקנת Dependencies
Command Prompt (כ-Administrator)
# שכפל את ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI

# התקן PyTorch עם CUDA 12.1
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# התקן dependencies נוספים
pip install -r requirements.txt
שלב 4 — הורדת מודל SDXL
bash / powershell
# הורד ל-models/checkpoints/
# מ-HuggingFace:
# https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0
# קובץ: sd_xl_base_1.0.safetensors (~6.5GB)
שלב 5 — הפעלה ראשונה
Command Prompt
python main.py --listen 0.0.0.0
# פתח דפדפן: http://127.0.0.1:8188

טיפ: צור קיצור דרך על שולחן העבודה לקובץ ה-bat כדי להפעיל ComfyUI בלחיצה אחת.

1.2

התקנה על Mac (Apple Silicon)

macOS עם M1/M2/M3 תומך ב-Metal Performance Shaders (MPS) — מאיץ ה-GPU הפנימי של Apple. הביצועים נמוכים יותר מ-NVIDIA RTX, אבל עדיין שמישים מאוד ל-M2 Pro ומעלה.

Terminal (macOS)
# התקן Homebrew אם עדיין אין
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# התקן Python ו-Git
brew install python@3.10 git

# שכפל ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI

# התקן PyTorch לMac (MPS)
pip3.10 install torch torchvision torchaudio

# התקן dependencies
pip3.10 install -r requirements.txt

# הפעל עם MPS ו-FP16
python3.10 main.py --force-fp16
M1 / M1 Pro
8–16GB — בסיסי, generation איטי
M2 Pro / M3
16GB+ — טוב לשימוש שוטף
M3 Max / M4 Pro
36GB+ — ביצועים מעולים

הערה לגבי ControlNet על Mac: חלק מ-ControlNet preprocessors אינם נתמכים ב-MPS. במקרה כזה, הוסף --cpu-vae להפעלה, או השתמש ב-CPU fallback ב-ComfyUI Manager.

1.3

Google Colab Setup (ללא GPU מקומי)

Google Colab מעמידה לרשותך NVIDIA T4 בחינם — מספיק ל-SDXL generation באיכות סבירה. Colab Pro (כ-10$ לחודש) נותן גישה ל-A100 ו-V100 לביצועים מקצועיים.

Google Colab — תא 1: התקנה
!git clone https://github.com/comfyanonymous/ComfyUI
%cd ComfyUI
!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 -q
!pip install -r requirements.txt -q
תא 2: הורדת מודל SDXL Turbo
!wget -q -O models/checkpoints/sdxl-turbo.safetensors \
  "https://huggingface.co/stabilityai/sdxl-turbo/resolve/main/sd_xl_turbo_1.0_fp16.safetensors"
תא 3: הפעלה עם Cloudflare Tunnel
!pip install cloudflared -q

import subprocess, threading, time

def run_comfyui():
    subprocess.run(['python', 'main.py', '--listen', '0.0.0.0', '--port', '8188'])

thread = threading.Thread(target=run_comfyui)
thread.daemon = True
thread.start()
time.sleep(5)

# צור tunnel — הקישור יופיע בפלט
!cloudflared tunnel --url http://localhost:8188

טיפ: Colab Pro מומלץ לשימוש רציף. ה-T4 החינמי מנתק חיבור אחרי 90 דקות של אי-פעילות. שמור את המודלים ב-Google Drive כדי לא להוריד אותם שוב בכל session.

1.4

ComfyUI Basics: מבנה ו-Nodes

ComfyUI פועל על ארכיטקטורת Graph-based — כל פעולה היא Node ו-Wires (חוטים) מחברים ביניהם את זרימת הנתונים. זה שונה לחלוטין מ-Automatic1111, אבל גמיש פי כמה.

Nodes בסיסיים
Node תפקיד
Load Checkpointטוענת מודל (SDXL, Flux, Realistic Vision)
CLIP Text Encodeממיר Prompt לוקטור semanti
KSamplerמבצע את תהליך ה-Denoising
VAE Decodeממיר Latent לתמונה גלויה
Empty Latent Imageמגדיר גודל ה-Canvas
Save Imageשומר את הפלט לדיסק
Workflow בסיסי — Text to Image
תרשים זרימה
[Load Checkpoint] ──model──► [KSampler]
                  ──clip──►  [CLIP Text Encode (+)] ──conditioning──► [KSampler]
                  ──clip──►  [CLIP Text Encode (-)] ──conditioning──► [KSampler]
                  ──vae──►   (stored for decode)

[Empty Latent Image] ──latent──► [KSampler]
[KSampler] ──latent──► [VAE Decode] ──image──► [Save Image]
הגדרות KSampler — מדריך מהיר
פרמטר ערך מומלץ הסבר
steps20–30לאיכות. 4–8 למודלי Turbo
cfg7.0Guidance. 1.0–2.0 ל-Flux
samplerdpm_2_ancestralלאיכות. euler ל-LCM/Turbo
schedulerkarrasלרוב המקרים. sgm_uniform ל-SDXL Turbo
seed-1 (random)קבע seed לרפרודוקטיביות

טיפ: התחל תמיד מה-Default Workflow המובנה בComfyUI (Queue Prompt הראשון אחרי ההתקנה). הבן את המבנה הזה לפני שתעבור ל-Workflows מורכבים.

🎯
פרויקט מודול 1

סביבה מלאה — 20 תמונות ראשונות

מטרה: הקם את סביבת העבודה שלך וצור 20 תמונות מגוונות כדי להוכיח שהכל עובד.

5 תמונות
Portrait
5 תמונות
Landscape
5 תמונות
Product Photo
5 תמונות
Abstract

שמור את כל ה-Workflows כקבצי JSON ב-ComfyUI/user/default/workflows/

02
מודול שני

SDXL ו-Flux Mastery

2.1

הבדלים בין המודלים

מודל מהירות איכות VRAM מתאים ל
SDXL Baseבינוניתגבוהה8GB+שימוש כללי
SDXL Turboמהיר מאודבינונית8GBDrafts, real-time
Flux Schnellמהירגבוהה16GB+Creative work
Flux Devאיטימעולה24GB+Production
Realistic Visionבינוניתריאליסטי6GBפורטרטים
2.2

Prompt Anatomy ל-SDXL

מבנה Prompt אופטימלי ל-SDXL שמניב תוצאות עקביות:

מבנה Prompt
[Subject] [Action/Pose] [Environment] [Lighting] [Style] [Quality Tags]

# דוגמה מעשית:
"a young woman sitting in a cafe, reading a book,
warm afternoon sunlight through window,
cinematic photography, shallow depth of field,
high detail, 8k, award winning photograph"
Negative Prompt אוניברסלי
"ugly, blurry, low quality, distorted, watermark, text,
extra limbs, bad anatomy, bad hands, deformed,
lowres, worst quality, normal quality, jpeg artifacts"
2.3

CFG, Steps ו-Sampler Guide

שימוש Steps CFG Sampler Scheduler
דראפט מהיר87.0eulernormal
איכות סטנדרט257.5dpm_2_akarras
איכות גבוהה408.0dpm_3m_sdekarras
Flux Schnell41.0eulersimple
Flux Dev253.5eulerbeta
2.4

Seed Management ו-ComfyUI API

שמירת Seed מאפשרת רפרודוקטיביות — אותה תמונה בדיוק בכל הפעלה. הנה פונקציה שמשלבת זאת עם ה-API של ComfyUI:

Python — Seed Management
import json
import urllib.request
import urllib.parse

def queue_prompt(prompt_workflow: dict, seed: int = -1) -> dict:
    """שלח workflow לComfyUI עם seed קבוע"""
    for node in prompt_workflow.values():
        if node.get('class_type') == 'KSampler':
            if seed == -1:
                import random
                node['inputs']['seed'] = random.randint(1, 2**32)
            else:
                node['inputs']['seed'] = seed

    data = json.dumps({"prompt": prompt_workflow}).encode('utf-8')
    req = urllib.request.Request("http://127.0.0.1:8188/prompt", data=data)
    return json.loads(urllib.request.urlopen(req).read())

# שימוש — אותה תמונה תמיד:
with open('my_workflow.json') as f:
    workflow = json.load(f)

result = queue_prompt(workflow, seed=42)
2.5

Workflow: High-Quality Portrait

ComfyUI Workflow מלא לפורטרט איכותי עם RealVisXL:

  1. 1Load Checkpoint: realvisXL_v5.safetensors
  2. 2CLIP Text Encode (+): "professional headshot, business portrait, woman 30s, sharp focus, studio lighting, 8k uhd"
  3. 3CLIP Text Encode (-): negative prompt אוניברסלי
  4. 4Empty Latent Image: 1024×1024
  5. 5KSampler: steps=35, cfg=7.5, sampler=dpm_2_ancestral, karras
  6. 6VAE Decode → Save Image
🎯
פרויקט מודול 2

20 תמונות בסגנון עקבי

בחר נושא אחד (מוצר / אדם / נוף) וצור 20 וריאציות בסגנון אחיד לחלוטין. התמקד ב: עקביות תאורה, טיפול ב-CLIP Skip, שמירת Workflow + Seed לכל תמונה.

שמור את כל 20 ה-Seeds — זה ה-Dataset שלך לשיעורים הבאים.

03
מודול שלישי

ControlNet — שליטה מלאה בקומפוזיציה

3.1

OpenPose — שליטה בפוזה

OpenPose מאפשר לך להגדיר פוזת גוף מדויקת על ידי מסירת תמונת reference. ComfyUI מחלץ ממנה Pose Skeleton ומחיל אותו על ה-generation.

bash — התקנה דרך ComfyUI-Manager
# פתח ComfyUI → Manager → Install Custom Nodes
# חפש: "ControlNet" → התקן: comfyui_controlnet_aux

# הורד ControlNet Models:
# https://huggingface.co/lllyasviel/sd_xl_controlnet
# sd_xl_controlnet_openpose.safetensors → models/controlnet/
Workflow עם OpenPose
ComfyUI Graph
[Load Image (pose ref)] → [DWPose Estimator] → [Apply ControlNet]
[Load Checkpoint] ──model──► [Apply ControlNet] ──model──► [KSampler]
[CLIP Text Encode] ──cond──► [Apply ControlNet] ──cond──►  [KSampler]
פרמטרערך מומלץהסבר
strength0.7–0.85כמה חזק ControlNet משפיע
start_percent0.0התחל מהצעד הראשון
end_percent0.7הפסק ב-70% — מאפשר יצירתיות בפרטים
3.2

Depth Map — קומפוזיציה תלת-ממדית

Depth Map מגדיר את המרחב בתמונה — מה קרוב ומה רחוק. שימושי במיוחד ל-Interior Design, Architecture ו-Product placement בסביבות שונות.

ComfyUI Depth Workflow
[Load Image] → [Depth Anything V2] → [Apply ControlNet (depth, strength=0.6)]

טיפ: strength=0.6 לעומת OpenPose — Depth Map "מנחה" יותר מאשר "כופה". זה נותן למודל חופש בפרטים תוך שמירה על המבנה התלת-ממדי.

3.3

Canny Edge — ייצוב קומפוזיציה

Canny Edge Detection משמר קווים ומבנה בסיסי. מושלם להמרת Sketch לתמונה מלאה, שמירה על מבנה ארכיטקטוני, ולוגו לאדם/עצם.

Python — Canny Preprocessing
import cv2
import numpy as np

def extract_canny(image_path: str, low: int = 100, high: int = 200) -> np.ndarray:
    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    img = cv2.GaussianBlur(img, (5, 5), 0)
    edges = cv2.Canny(img, low, high)
    return edges

שימוש: low/high threshold קובעים כמה קווים יחלצו. ערכים נמוכים יותר = יותר קווים (יותר שליטה אבל פחות חופש יצירתי). נסה low=50, high=150 ל-Sketches פשוטים.

3.4

IP-Adapter — Reference Style

IP-Adapter מאפשר לדגום "סגנון ויזואלי" מתמונה קיימת ולהחיל אותו על generation חדש — בלי להגדיר סגנון בפרומפט.

bash — הורדת מודל
# https://huggingface.co/h94/IP-Adapter
# ip-adapter_xl.bin → models/ipadapter/
  1. 1Load IP-Adapter Model
  2. 2Load Reference Image (התמונה שממנה אתה לוקח סגנון)
  3. 3Apply IP-Adapter (weight=0.6)
  4. 4שלב עם ControlNet לתוצאה מוחלטת

שילוב חזק: IP-Adapter (סגנון) + Depth ControlNet (מבנה) + Prompt (תוכן) = שליטה מלאה על כל ממד של התמונה.

🎯
פרויקט מודול 3

Product Photography Pipeline

מטרה: צור 10 תמונות מוצר מקצועיות מתמונת מוצר רגילה.

  1. 1.הפק Depth Map מהמוצר המקורי
  2. 2.השתמש ב-ControlNet Depth לשמירת צורת המוצר
  3. 3.שנה רקע לסטודיו / טבע / לייפסטייל
  4. 4.IP-Adapter לעקביות סגנות בין התמונות
04
מודול רביעי

LoRA Training — אמן מודל משלך

4.1

Dataset Preparation

Character LoRA
15–30 תמונות פנים / דמות
Style LoRA
50–100 תמונות בסגנון
Object LoRA
20–40 תמונות של העצם
כללים לDataset טוב
  • ✓ תמונות מגוונות — זוויות, תאורה, רקעים שונים
  • ✓ רזולוציה 512×512 עד 1024×1024
  • ✓ Caption לכל תמונה (BLIP auto-captioning)
מה להימנע ממנו
  • ✕ יותר מ-30% תמונות דומות מדי
  • ✕ Watermarks, טקסט, לוגו בתמונות
  • ✕ תמונות מטושטשות או באיכות נמוכה
4.2

Kohya SS על Google Colab

Colab — תא 1: התקנה
!git clone https://github.com/kohya-ss/sd-scripts
%cd sd-scripts
!pip install -r requirements.txt -q
!pip install xformers -q
Colab — תא 2: יצירת Captions עם BLIP
!pip install transformers -q
from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import glob, os

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

for img_path in glob.glob("training_data/**/*.jpg", recursive=True):
    image = Image.open(img_path).convert('RGB')
    inputs = processor(image, return_tensors="pt")
    out = model.generate(**inputs, max_new_tokens=50)
    caption = processor.decode(out[0], skip_special_tokens=True)

    # הוסף trigger word
    caption = f"[trigger_word], {caption}"

    txt_path = img_path.replace('.jpg', '.txt')
    with open(txt_path, 'w') as f:
        f.write(caption)
    print(f"{os.path.basename(img_path)}: {caption}")
4.3

LoRA Training Script

bash — אימון LoRA ל-SDXL
accelerate launch train_network.py \
  --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
  --train_data_dir="./training_data" \
  --output_dir="./output_lora" \
  --output_name="my_lora_v1" \
  --network_module="networks.lora" \
  --network_dim=32 \
  --network_alpha=16 \
  --resolution="1024,1024" \
  --train_batch_size=1 \
  --learning_rate=1e-4 \
  --lr_scheduler="cosine_with_restarts" \
  --lr_warmup_steps=100 \
  --max_train_steps=1000 \
  --save_every_n_steps=200 \
  --mixed_precision="bf16" \
  --xformers
פרמטרערךהסבר
network_dim32איזון גמישות/גודל. עלה ל-64 לסגנונות מורכבים
max_train_steps800–3000Character=800–1500, Style=1500–3000
learning_rate1e-4הורד ל-5e-5 אם תוצאות Overfit
save_every_n_steps200בדוק כל checkpoint לבחירת הטוב ביותר
4.4

בדיקה ו-Fine-tuning

ComfyUI — Load LoRA Node
# הגדרות Load LoRA Node:
#   lora_name: my_lora_v1-000800.safetensors
#   strength_model: 0.8
#   strength_clip: 0.8

# Prompt לבדיקה:
# "[trigger_word], portrait photo, professional lighting"
תוצאות דומות מדי = Overfitting

הפחת max_train_steps ב-20%, הגדל dataset גיוון

LoRA לא נכנסת = Underfitting

הגדל steps ב-30% או הגדל learning_rate ל-2e-4

4.5

Character, Style ו-Face LoRA

סוגTrigger WordDatasetStepsNetwork Dim
Face"person_name"15–25 פנים800–120032
Character"char_name"20–40 תמונות1000–150064
Style"art_style"60–1002000–3000128
Object"obj_name"20–30600–100032
🎯
פרויקט מודול 4

LoRA לפנים + סגנון

  1. 1.אסוף 20 תמונות (פנים / אדם / דמות לבחירתך)
  2. 2.הכן Dataset עם BLIP Captions
  3. 3.אמן Face LoRA + Style LoRA בנפרד
  4. 4.צור 5 תמונות שמשלבות שניהם ב-ComfyUI
05
מודול חמישי

ComfyUI Pro — Nodes, API ו-Batch

5.1

Custom Nodes

התקנת ComfyUI-Manager, ניהול Custom Nodes, חיפוש Node לפי פונקציה, עדכונים ותחזוקה. הכרת הנוד-ספרייה המרכזית של הקהילה.

ComfyUI-Manager Impact Pack WAS Suite
5.2

Advanced Workflows

Hires Fix, Img2Img, Inpainting/Outpainting, Face Restoration עם CodeFormer, Upscaling עם Real-ESRGAN. בניית Workflow שלם מאפס לגיוון מרבי.

Hires Fix CodeFormer ESRGAN
5.3

ComfyUI API — Batch Generation

אוטומציה מלאה של generation — שלח רשימת Prompts, המתן לתוצאות ושמור לדיסק. שימושי לייצור תוכן בקנה מידה:

Python — ComfyUI API Batch Generation
import json
import urllib.request
import time
import os

COMFYUI_URL = "http://127.0.0.1:8188"

def load_workflow(path: str) -> dict:
    with open(path, 'r', encoding='utf-8') as f:
        return json.load(f)

def queue_prompt(workflow: dict, client_id: str = "batch_job") -> dict:
    p = {"prompt": workflow, "client_id": client_id}
    data = json.dumps(p).encode('utf-8')
    req = urllib.request.Request(f"{COMFYUI_URL}/prompt", data=data)
    return json.loads(urllib.request.urlopen(req).read())

def get_history(prompt_id: str) -> dict:
    url = f"{COMFYUI_URL}/history/{prompt_id}"
    return json.loads(urllib.request.urlopen(url).read())

def batch_generate(workflow_path: str, prompts: list, output_dir: str):
    """צור תמונות לכל prompt ברשימה"""
    os.makedirs(output_dir, exist_ok=True)
    workflow = load_workflow(workflow_path)

    for i, prompt_text in enumerate(prompts):
        # מצא ועדכן CLIP Text Encode node
        for node in workflow.values():
            if node.get('class_type') == 'CLIPTextEncode':
                if 'positive' in node.get('_meta', {}).get('title', '').lower():
                    node['inputs']['text'] = prompt_text

        # שלח ל-queue
        result = queue_prompt(workflow)
        prompt_id = result['prompt_id']
        print(f"[{i+1}/{len(prompts)}] Queued: {prompt_id[:8]}...")

        # המתן לסיום
        while True:
            history = get_history(prompt_id)
            if prompt_id in history:
                print(f"  Done: {prompt_text[:40]}...")
                break
            time.sleep(1)

    print(f"\nהושלם! {len(prompts)} תמונות נוצרו")

# שימוש:
prompts = [
    "a red sports car on mountain road, golden hour",
    "vintage blue bicycle in paris street, rainy day",
    "modern kitchen with marble countertops, natural light",
]

batch_generate("my_workflow.json", prompts, "./output/batch_001")
5.4

Batch Processing — אסטרטגיות וטיפים

ייצור תמונות בקנה מידה דורש תכנון מראש. הנה עקרונות מפתח:

  • Queue Management: ComfyUI תומך ב-Queue מרובת עבודות — שלח הכל ותן לו לעבוד ברקע
  • WebSocket Monitoring: חבר ל-ws://localhost:8188/ws לעדכוני התקדמות real-time
  • VRAM Management: הוסף delay של 2–3 שניות בין עבודות כדי לאפשר VRAM cleanup
  • שמירת Metadata: שמור prompt_id, seed ו-prompt_text לכל תמונה לreferencing עתידי
🎯
פרויקט מסיים — מודול 5

AI Art Pipeline אוטומטי

בנה Pipeline מלא שמקבל רשימת נושאים, מייצר תמונות ב-3 סגנונות שונים עם LoRA שלך, ושומר הכל לתיקייה מאורגנת עם metadata.

זהו הפרויקט הגדול — שתף אותו בקהילת Discord לקבלת Feedback מחברי הקורס.

workspace_premium
סיום קורס

מזל טוב!

השלמת את קורס Stable Diffusion & ComfyUI Pro. אתה עכשיו מוכן לעבוד כ-AI Artist מקצועי — עם ידע עמוק ב-SDXL, Flux, ControlNet, LoRA Training ו-ComfyUI API.

5
מודולים
22
שיעורים
8
פרויקטים
15+
שעות

גישה מלאה לכל החומרים — לצמיתות

קהילת Discord הפרטית של SD Pro

שתף את הפרויקטים שלך, שאל שאלות על workflows, וקבל Feedback מ-AI Artists מנוסים. הקהילה פעילה ואתה חלק ממנה.

הצטרף לקהילה arrow_back