Stable Diffusion & ComfyUI Pro
סביבת עבודה
התקנה על 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+
השתמש ב-Python 3.10.x בלבד. גרסאות חדשות יותר שוברות תאימות עם מספר ספריות ליבה של PyTorch ו-ComfyUI.
הורד מ-python.org/downloads/release/python-31011/ וסמן "Add Python to PATH" בזמן ההתקנה — זה קריטי.
הורד מ-git-scm.com/download/win והשאר את כל ההגדרות על Default.
# שכפל את 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
# הורד ל-models/checkpoints/
# מ-HuggingFace:
# https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0
# קובץ: sd_xl_base_1.0.safetensors (~6.5GB)
python main.py --listen 0.0.0.0
# פתח דפדפן: http://127.0.0.1:8188
טיפ: צור קיצור דרך על שולחן העבודה לקובץ ה-bat כדי להפעיל ComfyUI בלחיצה אחת.
התקנה על Mac (Apple Silicon)
macOS עם M1/M2/M3 תומך ב-Metal Performance Shaders (MPS) — מאיץ ה-GPU הפנימי של Apple. הביצועים נמוכים יותר מ-NVIDIA RTX, אבל עדיין שמישים מאוד ל-M2 Pro ומעלה.
# התקן 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
הערה לגבי ControlNet על Mac: חלק מ-ControlNet preprocessors אינם נתמכים ב-MPS. במקרה כזה, הוסף --cpu-vae להפעלה, או השתמש ב-CPU fallback ב-ComfyUI Manager.
Google Colab Setup (ללא GPU מקומי)
Google Colab מעמידה לרשותך NVIDIA T4 בחינם — מספיק ל-SDXL generation באיכות סבירה. Colab Pro (כ-10$ לחודש) נותן גישה ל-A100 ו-V100 לביצועים מקצועיים.
!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
!wget -q -O models/checkpoints/sdxl-turbo.safetensors \
"https://huggingface.co/stabilityai/sdxl-turbo/resolve/main/sd_xl_turbo_1.0_fp16.safetensors"
!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.
ComfyUI Basics: מבנה ו-Nodes
ComfyUI פועל על ארכיטקטורת Graph-based — כל פעולה היא Node ו-Wires (חוטים) מחברים ביניהם את זרימת הנתונים. זה שונה לחלוטין מ-Automatic1111, אבל גמיש פי כמה.
| Node | תפקיד |
|---|---|
| Load Checkpoint | טוענת מודל (SDXL, Flux, Realistic Vision) |
| CLIP Text Encode | ממיר Prompt לוקטור semanti |
| KSampler | מבצע את תהליך ה-Denoising |
| VAE Decode | ממיר Latent לתמונה גלויה |
| Empty Latent Image | מגדיר גודל ה-Canvas |
| Save 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]
| פרמטר | ערך מומלץ | הסבר |
|---|---|---|
| steps | 20–30 | לאיכות. 4–8 למודלי Turbo |
| cfg | 7.0 | Guidance. 1.0–2.0 ל-Flux |
| sampler | dpm_2_ancestral | לאיכות. euler ל-LCM/Turbo |
| scheduler | karras | לרוב המקרים. sgm_uniform ל-SDXL Turbo |
| seed | -1 (random) | קבע seed לרפרודוקטיביות |
טיפ: התחל תמיד מה-Default Workflow המובנה בComfyUI (Queue Prompt הראשון אחרי ההתקנה). הבן את המבנה הזה לפני שתעבור ל-Workflows מורכבים.
סביבה מלאה — 20 תמונות ראשונות
מטרה: הקם את סביבת העבודה שלך וצור 20 תמונות מגוונות כדי להוכיח שהכל עובד.
שמור את כל ה-Workflows כקבצי JSON ב-ComfyUI/user/default/workflows/
SDXL ו-Flux Mastery
הבדלים בין המודלים
| מודל | מהירות | איכות | VRAM | מתאים ל |
|---|---|---|---|---|
| SDXL Base | בינונית | גבוהה | 8GB+ | שימוש כללי |
| SDXL Turbo | מהיר מאוד | בינונית | 8GB | Drafts, real-time |
| Flux Schnell | מהיר | גבוהה | 16GB+ | Creative work |
| Flux Dev | איטי | מעולה | 24GB+ | Production |
| Realistic Vision | בינונית | ריאליסטי | 6GB | פורטרטים |
Prompt Anatomy ל-SDXL
מבנה Prompt אופטימלי ל-SDXL שמניב תוצאות עקביות:
[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"
"ugly, blurry, low quality, distorted, watermark, text,
extra limbs, bad anatomy, bad hands, deformed,
lowres, worst quality, normal quality, jpeg artifacts"
CFG, Steps ו-Sampler Guide
| שימוש | Steps | CFG | Sampler | Scheduler |
|---|---|---|---|---|
| דראפט מהיר | 8 | 7.0 | euler | normal |
| איכות סטנדרט | 25 | 7.5 | dpm_2_a | karras |
| איכות גבוהה | 40 | 8.0 | dpm_3m_sde | karras |
| Flux Schnell | 4 | 1.0 | euler | simple |
| Flux Dev | 25 | 3.5 | euler | beta |
Seed Management ו-ComfyUI API
שמירת Seed מאפשרת רפרודוקטיביות — אותה תמונה בדיוק בכל הפעלה. הנה פונקציה שמשלבת זאת עם ה-API של ComfyUI:
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)
Workflow: High-Quality Portrait
ComfyUI Workflow מלא לפורטרט איכותי עם RealVisXL:
- 1Load Checkpoint: realvisXL_v5.safetensors
- 2CLIP Text Encode (+): "professional headshot, business portrait, woman 30s, sharp focus, studio lighting, 8k uhd"
- 3CLIP Text Encode (-): negative prompt אוניברסלי
- 4Empty Latent Image: 1024×1024
- 5KSampler: steps=35, cfg=7.5, sampler=dpm_2_ancestral, karras
- 6VAE Decode → Save Image
20 תמונות בסגנון עקבי
בחר נושא אחד (מוצר / אדם / נוף) וצור 20 וריאציות בסגנון אחיד לחלוטין. התמקד ב: עקביות תאורה, טיפול ב-CLIP Skip, שמירת Workflow + Seed לכל תמונה.
שמור את כל 20 ה-Seeds — זה ה-Dataset שלך לשיעורים הבאים.
ControlNet — שליטה מלאה בקומפוזיציה
OpenPose — שליטה בפוזה
OpenPose מאפשר לך להגדיר פוזת גוף מדויקת על ידי מסירת תמונת reference. ComfyUI מחלץ ממנה Pose Skeleton ומחיל אותו על ה-generation.
# פתח 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/
[Load Image (pose ref)] → [DWPose Estimator] → [Apply ControlNet]
[Load Checkpoint] ──model──► [Apply ControlNet] ──model──► [KSampler]
[CLIP Text Encode] ──cond──► [Apply ControlNet] ──cond──► [KSampler]
| פרמטר | ערך מומלץ | הסבר |
|---|---|---|
| strength | 0.7–0.85 | כמה חזק ControlNet משפיע |
| start_percent | 0.0 | התחל מהצעד הראשון |
| end_percent | 0.7 | הפסק ב-70% — מאפשר יצירתיות בפרטים |
Depth Map — קומפוזיציה תלת-ממדית
Depth Map מגדיר את המרחב בתמונה — מה קרוב ומה רחוק. שימושי במיוחד ל-Interior Design, Architecture ו-Product placement בסביבות שונות.
[Load Image] → [Depth Anything V2] → [Apply ControlNet (depth, strength=0.6)]
טיפ: strength=0.6 לעומת OpenPose — Depth Map "מנחה" יותר מאשר "כופה". זה נותן למודל חופש בפרטים תוך שמירה על המבנה התלת-ממדי.
Canny Edge — ייצוב קומפוזיציה
Canny Edge Detection משמר קווים ומבנה בסיסי. מושלם להמרת Sketch לתמונה מלאה, שמירה על מבנה ארכיטקטוני, ולוגו לאדם/עצם.
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 פשוטים.
IP-Adapter — Reference Style
IP-Adapter מאפשר לדגום "סגנון ויזואלי" מתמונה קיימת ולהחיל אותו על generation חדש — בלי להגדיר סגנון בפרומפט.
# https://huggingface.co/h94/IP-Adapter
# ip-adapter_xl.bin → models/ipadapter/
- 1Load IP-Adapter Model
- 2Load Reference Image (התמונה שממנה אתה לוקח סגנון)
- 3Apply IP-Adapter (weight=0.6)
- 4שלב עם ControlNet לתוצאה מוחלטת
שילוב חזק: IP-Adapter (סגנון) + Depth ControlNet (מבנה) + Prompt (תוכן) = שליטה מלאה על כל ממד של התמונה.
Product Photography Pipeline
מטרה: צור 10 תמונות מוצר מקצועיות מתמונת מוצר רגילה.
- 1.הפק Depth Map מהמוצר המקורי
- 2.השתמש ב-ControlNet Depth לשמירת צורת המוצר
- 3.שנה רקע לסטודיו / טבע / לייפסטייל
- 4.IP-Adapter לעקביות סגנות בין התמונות
LoRA Training — אמן מודל משלך
Dataset Preparation
- ✓ תמונות מגוונות — זוויות, תאורה, רקעים שונים
- ✓ רזולוציה 512×512 עד 1024×1024
- ✓ Caption לכל תמונה (BLIP auto-captioning)
- ✕ יותר מ-30% תמונות דומות מדי
- ✕ Watermarks, טקסט, לוגו בתמונות
- ✕ תמונות מטושטשות או באיכות נמוכה
Kohya SS על Google Colab
!git clone https://github.com/kohya-ss/sd-scripts
%cd sd-scripts
!pip install -r requirements.txt -q
!pip install xformers -q
!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}")
LoRA Training Script
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_dim | 32 | איזון גמישות/גודל. עלה ל-64 לסגנונות מורכבים |
| max_train_steps | 800–3000 | Character=800–1500, Style=1500–3000 |
| learning_rate | 1e-4 | הורד ל-5e-5 אם תוצאות Overfit |
| save_every_n_steps | 200 | בדוק כל checkpoint לבחירת הטוב ביותר |
בדיקה ו-Fine-tuning
# הגדרות 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"
הפחת max_train_steps ב-20%, הגדל dataset גיוון
הגדל steps ב-30% או הגדל learning_rate ל-2e-4
Character, Style ו-Face LoRA
| סוג | Trigger Word | Dataset | Steps | Network Dim |
|---|---|---|---|---|
| Face | "person_name" | 15–25 פנים | 800–1200 | 32 |
| Character | "char_name" | 20–40 תמונות | 1000–1500 | 64 |
| Style | "art_style" | 60–100 | 2000–3000 | 128 |
| Object | "obj_name" | 20–30 | 600–1000 | 32 |
LoRA לפנים + סגנון
- 1.אסוף 20 תמונות (פנים / אדם / דמות לבחירתך)
- 2.הכן Dataset עם BLIP Captions
- 3.אמן Face LoRA + Style LoRA בנפרד
- 4.צור 5 תמונות שמשלבות שניהם ב-ComfyUI
ComfyUI Pro — Nodes, API ו-Batch
Custom Nodes
התקנת ComfyUI-Manager, ניהול Custom Nodes, חיפוש Node לפי פונקציה, עדכונים ותחזוקה. הכרת הנוד-ספרייה המרכזית של הקהילה.
Advanced Workflows
Hires Fix, Img2Img, Inpainting/Outpainting, Face Restoration עם CodeFormer, Upscaling עם Real-ESRGAN. בניית Workflow שלם מאפס לגיוון מרבי.
ComfyUI API — Batch Generation
אוטומציה מלאה של generation — שלח רשימת Prompts, המתן לתוצאות ושמור לדיסק. שימושי לייצור תוכן בקנה מידה:
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")
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 עתידי
AI Art Pipeline אוטומטי
בנה Pipeline מלא שמקבל רשימת נושאים, מייצר תמונות ב-3 סגנונות שונים עם LoRA שלך, ושומר הכל לתיקייה מאורגנת עם metadata.
זהו הפרויקט הגדול — שתף אותו בקהילת Discord לקבלת Feedback מחברי הקורס.
מזל טוב!
השלמת את קורס Stable Diffusion & ComfyUI Pro. אתה עכשיו מוכן לעבוד כ-AI Artist מקצועי — עם ידע עמוק ב-SDXL, Flux, ControlNet, LoRA Training ו-ComfyUI API.
גישה מלאה לכל החומרים — לצמיתות
שתף את הפרויקטים שלך, שאל שאלות על workflows, וקבל Feedback מ-AI Artists מנוסים. הקהילה פעילה ואתה חלק ממנה.
הצטרף לקהילה arrow_back