ComfyUI में 1000+ छवियों को बैच प्रोसेस करें - संपूर्ण वर्कफ़्लो गाइड

ComfyUI की नोड-आधारित वर्कफ़्लो प्रणाली केवल इंटरैक्टिव प्रयोग के लिए नहीं है - यह एक शक्तिशाली बैच प्रोसेसिंग इंजन है जो सही सेटअप के साथ हजारों छवियों को संभाल सकता है। ComfyUI बैच प्रोसेसिंग आपके वर्कफ़्लो को एकल-छवि प्रयोगों से उत्पादन पाइपलाइनों में बदल देती है जो बड़े डेटासेट को संभालने में सक्षम हैं। चाहे आपको उत्पाद कैटलॉग को अपस्केल करने की आवश्यकता हो, डेटासेट भर में सुसंगत स्टाइल ट्रांसफर लागू करना हो, हजारों फ्रेम पर ऑब्जेक्ट डिटेक्शन चलाना हो, या इनपुट छवियों के फ़ोल्डर से वेरिएशन उत्पन्न करना हो, ComfyUI बैच प्रोसेसिंग ComfyUI को एक रचनात्मक उपकरण से उत्पादन पाइपलाइन में बदल देती है।

यह गाइड बुनियादी ComfyUI बैच प्रोसेसिंग वर्कफ़्लो डिज़ाइन से लेकर उन्नत स्वचालन तकनीकों तक सब कुछ कवर करती है जो आपको सोते समय बड़े छवि सेट प्रोसेस करने देती हैं। आप बैच लोडिंग नोड्स को प्रभावी ढंग से उपयोग करना, लंबे-चलने वाले क्यू को प्रबंधित करना, त्रुटियों को कुशलता से संभालना और अपनी हार्डवेयर क्षमताओं के अनुरूप प्रोसेसिंग को स्केल करना सीखेंगे। अंत तक, आपके पास विश्वसनीय ComfyUI बैच प्रोसेसिंग सिस्टम बनाने का ज्ञान होगा जो वास्तविक उत्पादन कार्यभार को संभालते हैं।

ComfyUI बैच प्रोसेसिंग आर्किटेक्चर को समझना

बैच वर्कफ़्लो बनाने से पहले, यह समझें कि ComfyUI बैच प्रोसेसिंग एकल-छवि प्रोसेसिंग से अलग तरीके से बैच ऑपरेशन को कैसे संभालती है। ComfyUI बैच प्रोसेसिंग आर्किटेक्चर को समझना कुशल वर्कफ़्लो बनाने के लिए आवश्यक है।

एकल-छवि मोड में, आप एक छवि लोड करते हैं, इसे अपने वर्कफ़्लो के माध्यम से प्रोसेस करते हैं, और परिणाम सहेजते हैं। प्रत्येक जनरेशन को मैन्युअल रूप से आरंभ किया जाता है। बैच प्रोसेसिंग के लिए, आपको स्वचालित पुनरावृत्ति की आवश्यकता है: छवि 1 लोड करें, प्रोसेस करें, परिणाम 1 सहेजें, फिर स्वचालित रूप से छवि 2 पर आगे बढ़ें, और सभी छवियों के प्रोसेस होने तक जारी रखें।

ComfyUI इसे विशेष बैच लोडिंग नोड्स के माध्यम से प्राप्त करता है जो छवि फ़ोल्डरों के माध्यम से पुनरावृत्ति करते हैं। जब आप बैच लोडर के साथ एक वर्कफ़्लो को क्यू करते हैं, तो ComfyUI केवल एक बार नहीं चलता - यह आपके स्रोत फ़ोल्डर में प्रत्येक छवि (या छवियों के समूह) के लिए एक बार, स्वचालित रूप से कई निष्पादन को क्यू करता है। बैच लोडर नोड यह ट्रैक करता है कि प्रत्येक निष्पादन के लिए कौन सी छवि लोड करनी है, आपके डेटासेट के माध्यम से बढ़ते हुए।

ComfyUI बैच प्रोसेसिंग में मुख्य अवधारणा प्रति-छवि क्यू मॉडल है। यदि आपके पास प्रोसेस करने के लिए 1000 छवियां हैं, तो ComfyUI 1000 वर्कफ़्लो निष्पादन को क्यू करता है। प्रत्येक निष्पादन बैच से अगली छवि लोड करता है, इसे प्रोसेस करता है, और परिणाम सहेजता है। यह बैचिंग दृष्टिकोणों से अलग है जो एक साथ कई छवियों को एक ही निष्पादन में लोड करते हैं - ComfyUI बैच प्रोसेसिंग प्रति निष्पादन एक छवि को संभालती है लेकिन आपके डेटासेट के माध्यम से पुनरावृत्ति को स्वचालित करती है।

इस आर्किटेक्चर के महत्वपूर्ण निहितार्थ हैं। प्रत्येक छवि स्वतंत्र रूप से पूर्ण वर्कफ़्लो के माध्यम से प्रोसेस होती है, जो अलगाव प्रदान करती है - एक विफल छवि अगली छवियों को प्रोसेस होने से नहीं रोकती। हालांकि, इसका अर्थ यह भी है कि प्रति निष्पादन कोई भी ओवरहेड (मॉडल लोडिंग, आदि) प्रत्येक छवि के लिए होता है जब तक कि ComfyUI उचित रूप से कैश नहीं करता।

ComfyUI बैच प्रोसेसिंग के लिए आवश्यक नोड्स

कई नोड प्रकार ComfyUI बैच प्रोसेसिंग वर्कफ़्लो को सक्षम करते हैं। क्या उपलब्ध है यह समझने से आपको ComfyUI बैच प्रोसेसिंग ऑपरेशंस के लिए प्रभावी पाइपलाइन डिज़ाइन करने में मदद मिलती है।

विभिन्न कस्टम नोड पैक से Load Image Batch नोड्स क्रमिक रूप से एक फ़ोल्डर से छवियां लोड करते हैं। मुख्य पैरामीटर में शामिल हैं:

• Directory path: आपकी स्रोत छवियों वाला फ़ोल्डर
• Index: फ़ोल्डर में कौन सी छवि लोड करनी है (0-आधारित)
• Pattern: वैकल्पिक फ़ाइल पैटर्न फ़िल्टरिंग (जैसे *.jpg, *.png)

जब आप वर्कफ़्लो को क्यू करते हैं, तो ComfyUI स्वचालित रूप से प्रत्येक क्यू किए गए निष्पादन के लिए इंडेक्स को बढ़ाता है। अपना प्रारंभिक इंडेक्स और प्रोसेस करने के लिए छवियों की संख्या सेट करें, और ComfyUI पुनरावृत्ति को संभालता है।

ComfyUI-Impact-Pack से Image Input नोड स्वचालित आउटपुट फ़ाइलनाम संरक्षण जैसी अतिरिक्त सुविधाओं के साथ बैच कार्यक्षमता प्रदान करता है। यह विशेष रूप से उपयोगी है जब आपको आउटपुट फ़ाइलों को इनपुट फ़ाइलनामों के अनुरूप होने की आवश्यकता होती है।

Video Helper Suite से VHS Load Images अच्छी फ़ाइलनाम हैंडलिंग के साथ बैच लोड छवियां कर सकता है और क्रम में छवि अनुक्रम लोड करने का समर्थन करता है।

Save Image नोड्स को बैच आउटपुट के लिए कॉन्फ़िगरेशन की आवश्यकता होती है। मुख्य बात फ़ाइलनाम टेम्प्लेटिंग है जो सुनिश्चित करती है कि प्रत्येक आउटपुट का एक अद्वितीय नाम है। विकल्प में शामिल हैं:

• क्रमिक संख्यांकन: output_0001.png, output_0002.png, आदि।
• इनपुट फ़ाइलनाम संरक्षण: यदि इनपुट photo_001.jpg है, तो आउटपुट photo_001_processed.png है
• आउटपुट व्यवस्थित करने के लिए उपसर्ग/प्रत्यय जोड़ना

अधिकांश कस्टम सेव नोड्स इन पैटर्न का समर्थन करते हैं। टेम्पलेट सिंटैक्स के लिए अपने विशिष्ट नोड के दस्तावेज़ से परामर्श करें।

एक बुनियादी ComfyUI बैच प्रोसेसिंग वर्कफ़्लो बनाना

आइए एक सामान्य कार्य के लिए एक पूर्ण ComfyUI बैच प्रोसेसिंग वर्कफ़्लो बनाने के माध्यम से चलें: छवियों के फ़ोल्डर को अपस्केल करना।

अपने इनपुट नोड से शुरू करें। एक Load Image Batch नोड रखें और इसे कॉन्फ़िगर करें:

Directory: /path/to/input_images
Index: 0
Pattern: *.jpg

इंडेक्स पहली छवि के लिए 0 से शुरू होता है। आप सभी छवियों को प्रोसेस करने के लिए कई निष्पादन को क्यू करेंगे।

लोड की गई छवि को अपनी प्रोसेसिंग पाइपलाइन से कनेक्ट करें। अपस्केलिंग के लिए, यह हो सकता है:

Load Image Batch -> Upscale Image (by Model) -> Save Image

या अधिक परिष्कृत अपस्केल के लिए:

Load Image Batch -> VAE Encode -> KSampler (tile upscale) -> VAE Decode -> Save Image

अपने Save Image नोड को बैच आउटपुट संभालने के लिए कॉन्फ़िगर करें। आउटपुट डायरेक्टरी और फ़ाइलनाम टेम्पलेट सेट करें:

Output Directory: /path/to/output_images
Filename Prefix: upscaled_

कुछ सेव नोड्स के साथ, आप मूल फ़ाइलनाम संरक्षित कर सकते हैं:

Filename Template: {original_name}_upscaled

अब निर्धारित करें कि कितनी छवियों को प्रोसेस करना है। जांचें कि आपके इनपुट फ़ोल्डर में कितनी छवियां हैं (जैसे 500 छवियां)। ComfyUI में, क्यू प्रॉम्प्ट काउंट को मैच करने के लिए सेट करें। जब आप "Extra options" दिखाते हुए 500 के साथ Queue Prompt पर क्लिक करते हैं, तो ComfyUI 500 वर्कफ़्लो निष्पादन को क्यू करता है। बैच लोडर स्वचालित रूप से प्रत्येक निष्पादन के लिए इंडेक्स को बढ़ाता है, छवि 0 से छवि 499 तक प्रोसेस करता है।

Queue पर क्लिक करें और प्रगति देखें। ComfyUI शेष क्यू काउंट दिखाता है, और आप अपने आउटपुट फ़ोल्डर में आउटपुट दिखाई देते हुए देख सकते हैं।

बड़े पैमाने पर ComfyUI बैच प्रोसेसिंग को संभालना (1000+ छवियां)

सैकड़ों या हजारों छवियों को प्रोसेस करना ऐसी चुनौतियां पेश करता है जिनका छोटे बैचों को सामना नहीं करना पड़ता। यहां बताया गया है कि बड़े पैमाने पर ComfyUI बैच प्रोसेसिंग को प्रभावी ढंग से कैसे संभालें।

बड़े बैचों को विभाजित करना प्रबंधनीयता के लिए आवश्यक है। एक बार में 5000 निष्पादन को क्यू करने के बजाय, 500-1000 के टुकड़ों में तोड़ें। यह कई लाभ प्रदान करता है:

• आसान प्रगति निगरानी (आप जानते हैं कि प्रत्येक टुकड़ा कब पूरा होता है)
• परिणामों की जांच करने के लिए टुकड़ों के बीच रुकने की क्षमता
• यदि बीच में कुछ गलत हो जाता है तो आसान रिकवरी
• बेहतर मेमोरी प्रबंधन (कुछ कैश टुकड़ों के बीच साफ़ हो सकते हैं)

टुकड़ों में प्रोसेस करने के लिए, अपने प्रारंभिक इंडेक्स और क्यू काउंट को समायोजित करें:

• टुकड़ा 1: Index 0, 500 छवियां क्यू करें
• टुकड़ा 2: Index 500, 500 छवियां क्यू करें
• टुकड़ा 3: Index 1000, 500 छवियां क्यू करें

आप इसे हाथ से मुक्त प्रोसेसिंग के लिए ComfyUI API के साथ स्क्रिप्ट कर सकते हैं।

मेमोरी प्रबंधन लंबे बैचों के लिए महत्वपूर्ण है। ComfyUI प्रदर्शन के लिए लोड किए गए मॉडल और मध्यवर्ती परिणामों को कैश करता है, लेकिन हजारों पुनरावृत्तियों में, मेमोरी जमा हो सकती है। यदि आप समय के साथ मेमोरी बढ़ते देखते हैं:

• UI के माध्यम से ComfyUI कैश को समय-समय पर साफ़ करें
• बहुत लंबे बैचों के लिए, उनके बीच ComfyUI रीस्टार्ट के साथ टुकड़ों को शेड्यूल करें
• यदि आवश्यक हो तो --cpu-vae या अन्य मेमोरी-बचत फ़्लैग का उपयोग करें

प्रगति निगरानी महत्वपूर्ण हो जाती है जब प्रोसेसिंग घंटों या दिनों तक चलती है। विकल्पों में शामिल हैं:

• UI में क्यू काउंटर देखें
• अपने आउटपुट फ़ोल्डर में दिखाई देने वाली आउटपुट फ़ाइलों की गणना करें
• प्रगति को प्रोग्रामेटिक रूप से ट्रैक करने के लिए API-आधारित निगरानी का उपयोग करें
• यदि आप स्क्रिप्टिंग कर रहे हैं तो प्रत्येक टुकड़े की पूर्णता को लॉग करें

त्रुटि हैंडलिंग महत्वपूर्ण है क्योंकि कुछ छवियां विफल होंगी। शायद एक फ़ाइल दूषित है, या एक छवि में असामान्य आयाम हैं जो आपके वर्कफ़्लो को तोड़ते हैं। डिफ़ॉल्ट ComfyUI व्यवहार त्रुटि पर रुक जाता है, जिसका अर्थ है कि आप अगली सुबह पता लगाते हैं कि 5000 की छवि 347 पर प्रोसेसिंग रुक गई।

बेहतर दृष्टिकोण:

• कुछ बैच नोड्स में स्किप-ऑन-एरर विकल्प होते हैं जो प्रोसेसिंग जारी रखते हैं
• कस्टम नोड्स का उपयोग करके अपने वर्कफ़्लो में त्रुटि हैंडलिंग लागू करें
• बैच को जारी रखने की अनुमति देते हुए बाद में जांच के लिए विफल छवियों को लॉग करें
• छोटे टुकड़ों में प्रोसेस करें ताकि त्रुटियां कम छवियों को प्रभावित करें

उन्नत ComfyUI बैच प्रोसेसिंग पैटर्न

बुनियादी पुनरावृत्ति से परे, कई पैटर्न अधिक परिष्कृत ComfyUI बैच प्रोसेसिंग वर्कफ़्लो को सक्षम करते हैं।

युग्मित इनपुट प्रोसेसिंग उन मामलों को संभालती है जहां प्रत्येक इनपुट छवि में संबंधित नियंत्रण छवि, मास्क या प्रॉम्प्ट फ़ाइल होती है। उदाहरण के लिए, प्रति-छवि मास्क के साथ इनपेंटिंग:

Load Image Batch (images) -> index 0, 1, 2...
Load Image Batch (masks) -> index 0, 1, 2... (समान इंडेक्सिंग)
Inpaint Node -> छवि और संबंधित मास्क प्राप्त करता है

दोनों बैच लोडर समान इंडेक्स का उपयोग करते हैं, इसलिए छवि 0 मास्क 0 के साथ युग्मित होती है।

टेक्स्ट फ़ाइल प्रॉम्प्ट प्रति-छवि प्रॉम्प्ट सक्षम करते हैं। अपने डेटा को इस प्रकार संरचित करें:

/images/image_000.jpg
/prompts/image_000.txt (image_000 के लिए प्रॉम्प्ट होता है)

प्रत्येक छवि के अनुरूप प्रॉम्प्ट टेक्स्ट फ़ाइल लोड करें और इसे अपने सैंपलर नोड के प्रॉम्प्ट इनपुट में पाइप करें।

सशर्त प्रोसेसिंग छवि गुणों के आधार पर विभिन्न प्रोसेसिंग लागू करती है। छवि विशेषताओं (आयाम, सामग्री, आदि) का पता लगाने वाले नोड्स का उपयोग करें और विभिन्न प्रोसेसिंग शाखाओं में रूट करें:

Load Image -> Detect Orientation -> If Portrait: Processing A, If space: Processing B

यह बैच प्रोसेसिंग वर्कफ़्लो को विविध इनपुट के अनुकूल होने में सक्षम बनाता है।

मल्टी-आउटपुट वर्कफ़्लो प्रति इनपुट कई आउटपुट उत्पन्न करते हैं। उदाहरण के लिए, प्रत्येक छवि के तीन वेरिएशन उत्पन्न करना:

Load Image -> Process with Seed 1 -> Save as {name}_var1
           -> Process with Seed 2 -> Save as {name}_var2
           -> Process with Seed 3 -> Save as {name}_var3

प्रत्येक क्यू किया गया निष्पादन एक इनपुट के लिए तीन आउटपुट उत्पन्न करता है।

API के माध्यम से प्रोग्रामेटिक ComfyUI बैच प्रोसेसिंग नियंत्रण

ComfyUI बैच प्रोसेसिंग पर अधिकतम नियंत्रण के लिए, UI के बजाय ComfyUI के API का उपयोग करें। API-आधारित ComfyUI बैच प्रोसेसिंग उत्पादन वातावरण के लिए सबसे अधिक लचीलापन प्रदान करती है।

ComfyUI एक WebSocket API प्रदान करता है जो वर्कफ़्लो JSON को स्वीकार करता है और निष्पादन को क्यू करता है। आप ऐसी स्क्रिप्ट लिख सकते हैं जो:

• अपना वर्कफ़्लो टेम्पलेट लोड करें
• प्रत्येक बैच आइटम के लिए पैरामीटर संशोधित करें (इनपुट पथ, आउटपुट पथ, प्रॉम्प्ट)
• API को सबमिट करें
• पूर्णता को ट्रैक करें
• परिणामों को संभालें

यहां API नियंत्रण के साथ बैच प्रोसेसिंग के लिए एक Python उदाहरण है:

import json
import requests
import time
from pathlib import Path

COMFYUI_URL = "http://127.0.0.1:8188"

def load_workflow_template(template_path):
    with open(template_path, 'r') as f:
        return json.load(f)

def queue_prompt(workflow):
    response = requests.post(
        f"{COMFYUI_URL}/prompt",
        json={"prompt": workflow}
    )
    return response.json()

def get_history(prompt_id):
    response = requests.get(f"{COMFYUI_URL}/history/{prompt_id}")
    return response.json()

def wait_for_completion(prompt_id, timeout=300):
    start = time.time()
    while time.time() - start < timeout:
        history = get_history(prompt_id)
        if prompt_id in history:
            return history[prompt_id]
        time.sleep(1)
    raise TimeoutError(f"Processing did not complete within {timeout}s")

def process_batch(input_folder, output_folder, workflow_template_path):
    workflow = load_workflow_template(workflow_template_path)
    input_path = Path(input_folder)
    output_path = Path(output_folder)
    output_path.mkdir(exist_ok=True)

    images = sorted(input_path.glob("*.jpg")) + sorted(input_path.glob("*.png"))
    print(f"Processing {len(images)} images")

    for i, image_path in enumerate(images):
        print(f"Processing {i+1}/{len(images)}: {image_path.name}")

        # Modify workflow for this image
        # These node IDs need to match your specific workflow
        workflow["1"]["inputs"]["image"] = str(image_path)
        workflow["10"]["inputs"]["filename_prefix"] = image_path.stem + "_processed"

        # Queue and wait
        result = queue_prompt(workflow)
        prompt_id = result["prompt_id"]

        try:
            completion = wait_for_completion(prompt_id)
            print(f"  Completed successfully")
        except TimeoutError:
            print(f"  ERROR: Timeout processing {image_path.name}")
        except Exception as e:
            print(f"  ERROR: {e}")

    print("Batch processing complete")

# Usage
process_batch(
    "/path/to/input_images",
    "/path/to/output_images",
    "/path/to/workflow_api.json"
)

यह स्क्रिप्ट आपको पूर्ण नियंत्रण देती है: आप लॉगिंग जोड़ सकते हैं, पुनः प्रयास तर्क लागू कर सकते हैं, कई ComfyUI इंस्टेंस में समानांतरित कर सकते हैं, पूर्णता पर सूचनाएं भेज सकते हैं, और अन्य सिस्टम के साथ एकीकृत कर सकते हैं।

API-आधारित बैच प्रोसेसिंग के मुख्य लाभ:

• किसी भी जगह से छवियों को प्रोसेस करें, केवल एक फ़ोल्डर से नहीं
• प्रति छवि प्रॉम्प्ट या पैरामीटर को गतिशील रूप से उत्पन्न करें
• परिष्कृत त्रुटि हैंडलिंग और पुनः प्रयास तर्क लागू करें
• विस्तृत मेट्रिक्स और समय को ट्रैक करें
• बड़ी पाइपलाइनों और स्वचालन सिस्टम के साथ एकीकृत करें
• ऑफ-आवर्स के लिए प्रोसेसिंग शेड्यूल करें

ComfyUI बैच प्रोसेसिंग के लिए प्रदर्शन अनुकूलन

ComfyUI बैच प्रोसेसिंग प्रदर्शन यह निर्धारित करता है कि आपका कार्य घंटों या दिनों में पूरा होता है। अपने ComfyUI बैच प्रोसेसिंग थ्रूपुट को अधिकतम करने के लिए इन कारकों को अनुकूलित करें:

मॉडल लोडिंग ओवरहेड: ComfyUI निष्पादन के बीच लोड किए गए मॉडल को कैश करता है, इसलिए पहली छवि बाद की छवियों (मॉडल लोड) से धीमी है लेकिन शेष छवियां तेजी से प्रोसेस होती हैं। सुनिश्चित करें कि आपका वर्कफ़्लो मॉडल पुनः लोडिंग को बाध्य नहीं करता - जांचें कि मॉडल पथ सुसंगत हैं और कोई नोड ताज़ा लोडिंग को बाध्य नहीं करता।

VRAM प्रबंधन: लंबे बैचों के लिए, VRAM विखंडन जमा हो सकता है। यदि आप समय के साथ मंदी देखते हैं, तो कैश को साफ़ करने की आवश्यकता हो सकती है। मॉडल लोड रखने (तेज़) और कैश साफ़ करने (बड़े व्यक्तिगत संचालन के लिए VRAM मुक्त करना) के बीच संतुलन बनाएं।

डिस्क I/O: हजारों इनपुट छवियों को पढ़ना और हजारों आउटपुट लिखना स्टोरेज पर दबाव डालता है। तेज़ SSD स्टोरेज काफी मदद करता है। यदि संभव हो तो नेटवर्क ड्राइव से पढ़ने और लिखने से बचें - स्थानीय NVMe स्टोरेज सर्वोत्तम प्रदर्शन प्रदान करता है।

समानांतर प्रोसेसिंग: यदि आपके पास कई GPU हैं, तो कई ComfyUI इंस्टेंस चलाएं, प्रत्येक आपके बैच के विभिन्न टुकड़ों को प्रोसेस करता है। यहां तक कि एक GPU पर, आप दो इंस्टेंस चला सकते हैं यदि आपका वर्कफ़्लो पूरी तरह से VRAM का उपयोग नहीं करता है, हालांकि इसके लिए परीक्षण की आवश्यकता होती है।

वर्कफ़्लो अनुकूलन: बैच प्रोसेसिंग के लिए अपने वर्कफ़्लो को सरल बनाएं। किसी भी पूर्वावलोकन नोड को हटा दें (वे ओवरहेड जोड़ते हैं)। सुनिश्चित करें कि आप अनावश्यक संचालन नहीं कर रहे हैं। बाधाओं की पहचान करने के लिए अपने वर्कफ़्लो को प्रोफाइल करें।

रिज़ॉल्यूशन और गुणवत्ता ट्रेडऑफ़: 1024x1024 छवियों को प्रोसेस करना जनरेशन कार्यों के लिए 512x512 की तुलना में लगभग 4x अधिक समय लेता है। बैच प्रोसेसिंग के लिए जहां गति मायने रखती है, विचार करें कि क्या कम रिज़ॉल्यूशन स्वीकार्य है या यदि आप इनपुट को डाउनस्केल कर सकते हैं, प्रोसेस कर सकते हैं, फिर आउटपुट को अपस्केल कर सकते हैं।

सामान्य बैच प्रोसेसिंग अनुप्रयोग

विभिन्न अनुप्रयोगों के लिए विभिन्न वर्कफ़्लो पैटर्न की आवश्यकता होती है।

अपस्केलिंग सबसे सरल बैच अनुप्रयोग है। छवियां लोड करें, अपस्केलर मॉडल के माध्यम से चलाएं, उच्च रिज़ॉल्यूशन पर सहेजें। यह शर्मनाक रूप से समानांतर है और बैच प्रोसेसिंग के लिए अच्छी तरह से अनुकूल है:

Load Image Batch -> RealESRGAN Upscale -> Save Image

एक अच्छे GPU के साथ, आप रातोंरात हजारों छवियों को अपस्केल कर सकते हैं।

स्टाइल ट्रांसफर डेटासेट भर में सुसंगत कलात्मक शैली लागू करता है। प्रत्येक छवि पर शैली संदर्भ लागू करने के लिए IP-Adapter या समान का उपयोग करें:

Load Image Batch (content) ->
Load Image (style, single reference) ->
IP-Adapter -> KSampler -> Save Image

प्रत्येक छवि को समान शैली संदर्भ के साथ प्रोसेस किया जाता है।

इमेज-टू-इमेज जनरेशन संरचना को संरक्षित करते हुए इनपुट को परिवर्तित करता है:

Load Image Batch -> VAE Encode -> KSampler (low-medium denoise) -> VAE Decode -> Save Image

संरचना बनाए रखते हुए मौजूदा छवियों में जनरेशन एन्हांसमेंट लागू करने के लिए उपयोगी।

ऑब्जेक्ट डिटेक्शन/सेगमेंटेशन डेटासेट भर में डिटेक्शन मॉडल चलाता है:

Load Image Batch -> SAM Model -> Export Masks -> Save

आगे उपयोग के लिए प्रत्येक छवि से मास्क या डिटेक्शन निकालता है।

डेटा ऑगमेंटेशन प्रशिक्षण डेटासेट के लिए प्रत्येक छवि के कई वेरिएशन उत्पन्न करता है:

Load Image Batch -> Random transforms -> Save multiple variations

प्रशिक्षण उद्देश्यों के लिए आपके डेटासेट आकार को गुणा करता है।

सुसंगत चरित्र जनरेशन कई दृश्यों में एक चरित्र उत्पन्न करने के लिए बैच प्रॉम्प्ट का उपयोग करता है:

Load Prompt Batch (scene descriptions) ->
Character LoRA -> KSampler -> Save Image

कई अलग-अलग संदर्भों में एक ही चरित्र उत्पन्न करता है।

अक्सर पूछे जाने वाले प्रश्न

1000 छवियों को प्रोसेस करने में कितना समय लगता है?

पूरी तरह से आपके वर्कफ़्लो की जटिलता और हार्डवेयर पर निर्भर करता है। सरल अपस्केलिंग में प्रति छवि 3-5 सेकंड लग सकते हैं (कुल लगभग एक घंटा)। जटिल जनरेशन वर्कफ़्लो में प्रति छवि 30-60 सेकंड लग सकते हैं (कुल 8-16 घंटे)। अनुमानों के लिए अपने प्रति-छवि समय को छवि गणना से गुणा करें।

क्या मैं बैच प्रोसेसिंग को रोक और फिर से शुरू कर सकता हूं?

आप किसी भी समय क्यू रोक सकते हैं। फिर से शुरू करने के लिए, ध्यान दें कि आप किस इंडेक्स पर रुके (आउटपुट की गणना करके या क्यू स्थिति द्वारा), अपने बैच लोडर को उस इंडेक्स पर सेट करें, और शेष छवियों को क्यू करें। कुछ बैच नोड्स में स्पष्ट फिर से शुरू करने की कार्यक्षमता होती है।

प्रोसेसिंग के दौरान एक छवि विफल होने पर क्या होता है?

डिफ़ॉल्ट व्यवहार क्यू रोक देता है। त्रुटियों के बावजूद जारी रखने के लिए, स्किप-ऑन-एरर विकल्पों वाले बैच नोड्स का उपयोग करें, या छोटे टुकड़ों में प्रोसेस करें ताकि विफलताएं कम छवियों को प्रभावित करें। बाद में जांच के लिए हमेशा ध्यान दें कि कौन सी छवियां विफल हुईं।

मुझे कैसे पता चलेगा कि किस छवि ने त्रुटि का कारण बना?

वर्तमान क्यू स्थिति आपको बताती है कि कौन सा इंडेक्स प्रोसेस हो रहा था। इसे अपनी इनपुट फ़ोल्डर सूची से मिलाएं। कुछ बैच नोड्स विफलताओं की पहचान करने में मदद के लिए वर्तमान फ़ाइलनाम आउटपुट करते हैं।

क्या मैं प्रत्येक के लिए विभिन्न प्रॉम्प्ट के साथ छवियों को प्रोसेस कर सकता हूं?

हां, टेक्स्ट फ़ाइल लोडिंग नोड्स का उपयोग करें जो प्रत्येक छवि के अनुरूप प्रॉम्प्ट फ़ाइलों को पढ़ते हैं। अपने डेटा को इस प्रकार संरचित करें कि image_001.jpg में image_001.txt है जिसमें इसका प्रॉम्प्ट है।

क्या बैच प्रोसेसिंग एकल छवियों की तुलना में अधिक VRAM का उपयोग करती है?

प्रति-छवि VRAM उपयोग समान है। हालांकि, कैश प्रबंधन के बिना लंबे बैच मेमोरी जमा कर सकते हैं। लंबे बैचों के दौरान उपयोग की निगरानी करें और यदि मेमोरी बढ़ती है तो कैश साफ़ करें।

मैं इनपुट और आउटपुट के बीच फ़ाइलनाम पत्राचार कैसे बनाए रखूं?

सेव नोड्स का उपयोग करें जो {original_name}_processed जैसे फ़ाइलनाम टेम्पलेट्स का समर्थन करते हैं। यह आउटपुट में इनपुट फ़ाइलनाम को संरक्षित करता है। टेम्पलेट वेरिएबल के लिए अपने विशिष्ट नोड के दस्तावेज़ जांचें।

क्या मैं बैच प्रोसेस वीडियो कर सकता हूं?

हां, फ्रेम निकालें, बैच प्रोसेस फ्रेम करें, फिर फिर से असेंबल करें। VHS (Video Helper Suite) नोड्स वीडियो लोडिंग और सेविंग को संभालते हैं। वीडियो को छवि अनुक्रम के रूप में प्रोसेस करें।

मैं अधिकतम कितने बैच आकार को प्रोसेस कर सकता हूं?

डिस्क स्पेस और धैर्य द्वारा सीमित, ComfyUI द्वारा नहीं। हजारों छवियां व्यवहार्य हैं यदि आपके पास इनपुट और आउटपुट के लिए स्टोरेज है। एक बार में सब कुछ क्यू करने के बजाय प्रबंधनीय टुकड़ों में प्रोसेस करें।

मैं एक बैच में विभिन्न आकारों की छवियों को कैसे संभालूं?

या तो प्रोसेसिंग से पहले सभी इनपुट को सुसंगत आयामों में रीसाइज़ करें, या वर्कफ़्लो नोड्स का उपयोग करें जो विभिन्न आकारों को कुशलता से संभालते हैं। कुछ संचालनों के लिए सुसंगत आयामों की आवश्यकता होती है जबकि अन्य स्वचालित रूप से अनुकूलित हो जाते हैं।

क्या मैं बैच प्रोसेसिंग को कई मशीनों में वितरित कर सकता हूं?

हां, अपनी छवि सेट को मशीनों में विभाजित करें, प्रत्येक ComfyUI चलाता है। इसके लिए समान छवियों को दो बार प्रोसेस करने से बचने और आउटपुट को संयोजित करने के लिए समन्वय की आवश्यकता होती है। नेटवर्क स्टोरेज या क्लाउड ऑर्केस्ट्रेशन मदद करता है।

उन्नत बैच प्रोसेसिंग पैटर्न

बुनियादी पुनरावृत्ति से परे, परिष्कृत पैटर्न जटिल उत्पादन आवश्यकताओं को संभालते हैं।

सशर्त प्रोसेसिंग वर्कफ़्लो

छवि विशेषताओं के आधार पर विभिन्न प्रोसेसिंग लागू करें।

आयाम-आधारित रूटिंग पोर्ट्रेट और स्पेस छवियों को अलग तरीके से प्रोसेस करती है। ओरिएंटेशन का पता लगाएं और प्रत्येक प्रारूप के लिए अनुकूलित सेटिंग्स के साथ उपयुक्त प्रोसेसिंग शाखाओं में रूट करें।

सामग्री-आधारित रूटिंग पता लगाई गई सामग्री के आधार पर विभिन्न प्रोसेसिंग लागू करती है। छवि प्रकारों की पहचान करने और तदनुसार रूट करने के लिए वर्गीकरण या डिटेक्शन नोड्स का उपयोग करें।

गुणवत्ता-आधारित फ़िल्टरिंग प्रोसेसिंग से पहले निम्न-गुणवत्ता वाले इनपुट को हटाती है या फ़्लैग करती है। आउटलायर को उचित रूप से संभालने के लिए रिज़ॉल्यूशन, ब्लर मेट्रिक्स या अन्य गुणवत्ता संकेतक जांचें।

मल्टी-इनपुट सहसंबंध

संबंधित इनपुट के सेट को एक साथ प्रोसेस करें।

इमेज-कैप्शन जोड़े छवि और संबंधित टेक्स्ट फ़ाइल दोनों लोड करते हैं। बैच इंडेक्स उन्हें सिंक्रनाइज़ रखता है, यह सुनिश्चित करते हुए कि छवि 47 कैप्शन 47 के साथ प्रोसेस होती है।

मल्टी-मॉडल इनपुट मास्क, डेप्थ मैप या नियंत्रण छवियों के साथ छवियों को संयोजित करते हैं। सिंक्रनाइज़ किए गए इंडेक्स के साथ कई बैच लोडर प्रत्येक आइटम के लिए सभी इनपुट प्रदान करते हैं।

क्रमिक निर्भरता जहां एक आउटपुट अगला इनपुट बन जाता है। छवि A को प्रोसेस करें, छवि B प्रोसेसिंग के लिए इनपुट के रूप में परिणाम का उपयोग करें। यह श्रृंखलाबद्ध परिवर्तनों को सक्षम बनाता है।

वितरित प्रोसेसिंग

कई मशीनों या GPU में बैच प्रोसेसिंग को स्केल करें।

डेटासेट विभाजन कार्यकर्ताओं में छवियों को विभाजित करता है। मशीन 1 छवियां 0-999 प्रोसेस करती है, मशीन 2 1000-1999 प्रोसेस करती है। ओवरलैप से बचने और आउटपुट को संयोजित करने के लिए समन्वय की आवश्यकता होती है।

क्यू वितरण उपलब्धता के आधार पर विभिन्न कार्यकर्ताओं को विभिन्न कार्य भेजता है। एक समन्वयक कार्य असाइन करता है और परिणाम एकत्र करता है।

क्लाउड बर्स्ट स्थानीय हार्डवेयर का उपयोग विकास के लिए करते हुए बड़े बैचों के लिए क्लाउड GPU को स्केल करता है। RunPod या Vast.ai जैसी सेवाएं अस्थायी GPU क्षमता प्रदान करती हैं।

उत्पादन पाइपलाइनों के साथ एकीकरण

बैच प्रोसेसिंग अक्सर ComfyUI से परे बड़ी प्रणालियों के साथ एकीकृत होती है।

इनपुट पाइपलाइन एकीकरण

बैच प्रोसेसिंग को अपस्ट्रीम डेटा स्रोतों से कनेक्ट करें।

डेटाबेस क्वेरी गतिशील रूप से प्रोसेसिंग क्यू भरती हैं। स्क्रिप्ट प्रोसेसिंग की आवश्यकता वाली छवियों के लिए डेटाबेस को क्वेरी करती है, बैच जॉब उत्पन्न करती है, और ComfyUI चलाती है।

वॉच फ़ोल्डर स्वचालित रूप से नई छवियों को प्रोसेस करते हैं जैसे ही वे दिखाई देती हैं। मॉनिटर स्क्रिप्ट नई फ़ाइलों का पता लगाती है और हाल ही में जोड़े गए के लिए बैच प्रोसेसिंग को ट्रिगर करती है।

API ट्रिगर बाहरी सिस्टम से बैच प्रोसेसिंग शुरू करते हैं। वेब सेवा प्रोसेसिंग अनुरोध प्राप्त करती है, बैच जॉब बनाती है, निष्पादित करती है, और परिणाम लौटाती है।

आउटपुट पाइपलाइन एकीकरण

प्रोसेस किए गए परिणामों को डाउनस्ट्रीम सिस्टम से कनेक्ट करें।

स्वचालित अपलोड प्रोसेसिंग के बाद परिणामों को स्टोरेज या CDN पर भेजता है। स्क्रिप्टेड पाइपलाइन स्वचालित रूप से उपयुक्त गंतव्यों में आउटपुट कॉपी करती हैं।

डेटाबेस अपडेट प्रोसेसिंग पूर्णता और परिणामों को रिकॉर्ड करते हैं। स्थिति अपडेट करें, आउटपुट पथ स्टोर करें, प्रत्येक प्रोसेस किए गए आइटम के लिए मेट्रिक्स रिकॉर्ड करें।

सूचना सिस्टम जब बैच पूर्ण या विफल होते हैं तो अलर्ट करते हैं। ईमेल, Slack या अन्य सूचनाएं प्रोसेसिंग स्थिति की टीमों को सूचित रखती हैं।

निगरानी और अवलोकनीयता

बैच प्रोसेसिंग स्वास्थ्य और प्रदर्शन को ट्रैक करें।

प्रगति डैशबोर्ड वास्तविक समय में बैच स्थिति दिखाते हैं। वेब इंटरफ़ेस क्यू स्थिति, पूर्ण गणना, अनुमानित शेष समय प्रदर्शित करता है।

मेट्रिक संग्रह प्रोसेसिंग गति, त्रुटि दरों, संसाधन उपयोग को ट्रैक करता है। समय श्रृंखला डेटा प्रदर्शन विश्लेषण और क्षमता योजना को सक्षम बनाता है।

लॉग एकत्रीकरण सभी प्रोसेसिंग घटकों से लॉग एकत्र करता है। केंद्रीकृत लॉगिंग वितरित बैच नौकरियों में डिबगिंग सक्षम बनाता है।

ComfyUI बैच प्रोसेसिंग का समर्थन करने वाले मूलभूत वर्कफ़्लो कौशल के लिए, हमारे ComfyUI आवश्यक नोड्स गाइड से शुरू करें। इन बुनियादी नोड्स को समझना प्रभावी ComfyUI बैच प्रोसेसिंग वर्कफ़्लो बनाने के लिए महत्वपूर्ण है।

त्रुटि हैंडलिंग और रिकवरी

ठोस बैच प्रोसेसिंग के लिए व्यापक त्रुटि हैंडलिंग की आवश्यकता होती है।

त्रुटि पहचान

समस्याओं को जल्दी और सटीक रूप से पहचानें।

प्रोसेसिंग त्रुटियां वर्कफ़्लो निष्पादन के दौरान होती हैं। ComfyUI विफल नोड्स के लिए त्रुटियों की रिपोर्ट करता है। इन्हें विशिष्ट छवि के साथ लॉग करें जिसने उन्हें कारण बनाया।

इनपुट त्रुटियां समस्याग्रस्त फ़ाइलों को लोड करते समय होती हैं। दूषित छवियां, गलत प्रारूप, या लापता फ़ाइलें लोड विफलताओं का कारण बनती हैं। पूरे बैच को रोकने के बजाय कुशलता से संभालें।

आउटपुट त्रुटियां परिणाम सहेजते समय होती हैं। पूर्ण डिस्क, अनुमति समस्याएं, या अमान्य पथ सहेजने से रोकते हैं। प्रोसेसिंग कार्य खोने से पहले पता लगाएं और रिपोर्ट करें।

त्रुटि रिकवरी

समस्याओं का समाधान करने के बाद बैच प्रोसेसिंग फिर से शुरू करें।

छोड़ें और जारी रखें त्रुटियों के बावजूद शेष आइटम प्रोसेस करता है। बैच पूरा करते हुए बाद में जांच के लिए विफल आइटम लॉग करें।

पुनः प्रयास तर्क संक्षिप्त विलंब के बाद विफल आइटम को फिर से प्रयास करता है। क्षणिक त्रुटियां (नेटवर्क, डिस्क) पुनः प्रयास पर सफल हो सकती हैं।

चेकपॉइंट रिकवरी जहां प्रोसेसिंग रुकी थी वहां से फिर से शुरू करती है। प्रगति को नियमित रूप से सहेजें ताकि बाधित बैच सही स्थिति पर फिर से शुरू हों।

त्रुटि विश्लेषण

पुनरावृत्ति को रोकने के लिए त्रुटियों से सीखें।

पैटर्न पहचान त्रुटियों में सामान्य कारण ढूंढती है। यदि कई छवियां एक ही तरीके से विफल होती हैं, तो संभवतः एक व्यवस्थित समस्या है जिसे संबोधित करने की आवश्यकता है।

मूल कारण विश्लेषण त्रुटियों को अंतर्निहित समस्याओं तक ट्रेस करता है। एक "decode error" दूषित स्रोत फ़ाइलों, प्रारूप असंगति या मेमोरी समस्याओं का संकेत दे सकता है।

रोकथाम उपाय त्रुटि पैटर्न के आधार पर भविष्य के बैच में सुधार करते हैं। इनपुट सत्यापन जोड़ें, मजबूती के लिए वर्कफ़्लो समायोजित करें, या त्रुटि हैंडलिंग में सुधार करें।

संसाधन योजना और अनुमान

वास्तविक संसाधन अपेक्षाओं के साथ बैच प्रोसेसिंग नौकरियों की योजना बनाएं।

समय अनुमान

भविष्यवाणी करें कि बैच नौकरियों में कितना समय लगेगा।

प्रति-छवि समय परीक्षण रन से आधार रेखा प्रदान करता है। औसत प्रोसेसिंग समय स्थापित करने के लिए एक प्रतिनिधि नमूने का समय लें।

कुल समय गणना प्रति-छवि समय को गणना से गुणा करती है। 1000 छवियों पर 30-सेकंड औसत का अर्थ है लगभग 8.3 घंटे कुल।

ओवरहेड लेखांकन लोडिंग, सेविंग और ट्रांज़िशन के लिए समय जोड़ता है। बैच ओवरहेड शुद्ध प्रोसेसिंग समय में 10-20% जोड़ सकता है।

समानांतरीकरण लाभ यदि उपलब्ध हो तो कैलेंडर समय कम करता है। दो GPU समानांतर में प्रोसेस करने से निश्चित कुल कार्य के लिए कैलेंडर समय आधा हो जाता है।

स्टोरेज योजना

बैच ऑपरेशंस के लिए पर्याप्त स्टोरेज सुनिश्चित करें।

इनपुट स्टोरेज प्रोसेसिंग के लिए सुलभ स्रोत छवियों को रखता है। कुल इनपुट आकार की गणना करें और तेज़ पहुंच सुनिश्चित करें (स्थानीय NVMe नेटवर्क पर पसंदीदा)।

आउटपुट स्टोरेज सभी प्रोसेस किए गए परिणाम प्राप्त करता है। आउटपुट आकार अनुमान लगाएं (इनपुट से भिन्न हो सकता है) और पूर्ण बैच प्लस हेडरूम के लिए योजना बनाएं।

अस्थायी स्टोरेज प्रोसेसिंग के दौरान मध्यवर्ती फ़ाइलों के लिए। ComfyUI जटिल वर्कफ़्लो के दौरान अस्थायी फ़ाइलें बना सकता है।

मेमोरी योजना

पूरे बैच में पर्याप्त सिस्टम संसाधन सुनिश्चित करें।

VRAM आवश्यकताएं प्रति वर्कफ़्लो निष्पादन। बैच प्रोसेसिंग प्रति-छवि VRAM आवश्यकताओं को नहीं बढ़ाती है लेकिन लंबे रन विखंडन जमा कर सकते हैं।

सिस्टम RAM डेटा लोडिंग और बफरिंग के लिए। हजारों छवियों को प्रोसेस करने के लिए GPU आवश्यकताओं से परे फ़ाइल ऑपरेशंस के लिए RAM की आवश्यकता होती है।

स्वैप योजना जब भौतिक मेमोरी अपर्याप्त हो। स्वैप उपयोग प्रोसेसिंग को नाटकीय रूप से धीमा कर देता है, इसलिए पर्याप्त भौतिक RAM के लिए योजना बनाएं।

बैच प्रोसेसिंग दक्षता में सुधार करने वाली मेमोरी अनुकूलन रणनीतियों के लिए, हमारी VRAM अनुकूलन गाइड देखें।

निष्कर्ष

बैच प्रोसेसिंग ComfyUI को एक इंटरैक्टिव रचनात्मक उपकरण से उत्पादन-सक्षम छवि प्रोसेसिंग पाइपलाइन में बदल देती है। मुख्य सिद्धांत उपयुक्त बैच लोडिंग नोड्स का उपयोग करना, विभाजन के माध्यम से लंबे क्यू को प्रबंधित करना, त्रुटियों को कुशलता से संभालना और अपने विशिष्ट हार्डवेयर और वर्कफ़्लो के लिए प्रदर्शन को अनुकूलित करना है।

अपने सेटअप को सही तरीके से काम करने की पुष्टि करने के लिए छवियों के छोटे सेट को प्रोसेस करने वाले सरल बैच वर्कफ़्लो से शुरू करें। एक बार अपने वर्कफ़्लो में आत्मविश्वास होने पर, बड़े बैचों तक स्केल करें। जटिल बैच ऑपरेशंस पर अधिकतम नियंत्रण के लिए API-आधारित स्क्रिप्टिंग का उपयोग करें।

बैच प्रोसेसिंग सीखने में निवेश तब भुगतान करता है जब भी आपको उससे अधिक छवियों को प्रोसेस करने की आवश्यकता होती है जिन्हें आप मैन्युअल रूप से क्लिक करना चाहते हैं। चाहे वह दर्जनों हो या हजारों, बैच प्रोसेसिंग इसे व्यवहार्य बनाती है।

उन उपयोगकर्ताओं के लिए जिन्हें बुनियादी ढांचा प्रबंधन के बिना विश्वसनीय बैच प्रोसेसिंग की आवश्यकता है, Apatero.com पेशेवर निगरानी और त्रुटि हैंडलिंग के साथ बड़े छवि सेट के लिए स्केलेबल प्रोसेसिंग प्रदान करता है।

AI छवि जनरेशन के साथ अभी शुरुआत करने वालों के लिए, हमारी संपूर्ण शुरुआती गाइड मूलभूत ज्ञान प्रदान करती है जो आपके समग्र AI छवि वर्कफ़्लो के भीतर बैच प्रोसेसिंग को संदर्भित करने में मदद करती है।