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

ComfyUI की नोड-आधारित वर्कफ़्लो प्रणाली केवल इंटरैक्टिव प्रयोग के लिए नहीं है - यह एक शक्तिशाली बैच प्रसंस्करण इंजन है जो सही सेटअप के साथ हजारों छवियों को संभाल सकता है। ComfyUI बैच प्रसंस्करण आपके वर्कफ़्लो को एकल-छवि प्रयोगों से उत्पादन पाइपलाइनों में परिवर्तित करता है जो बड़े पैमाने पर डेटासेट को संभालने में सक्षम हैं। चाहे आपको उत्पाद कैटलॉग को upscale करने, डेटासेट में सुसंगत स्टाइल ट्रांसफर लागू करने, हजारों फ्रेम पर ऑब्जेक्ट डिटेक्शन चलाने, या इनपुट छवियों के फ़ोल्डर से विविधताएं उत्पन्न करने की आवश्यकता हो, 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-based)
• Pattern: वैकल्पिक फ़ाइल पैटर्न फ़िल्टरिंग (जैसे, *.jpg, *.png)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 बैच प्रसंस्करण को प्रभावी ढंग से कैसे संभालें।

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

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

chunks में प्रोसेस करने के लिए, अपने शुरुआती इंडेक्स और कतार काउंट को समायोजित करें:

• Chunk 1: Index 0, 500 छवियों को कतार में रखें
• Chunk 2: Index 500, 500 छवियों को कतार में रखें
• Chunk 3: Index 1000, 500 छवियों को कतार में रखें

आप हैंड्स-ऑफ प्रसंस्करण के लिए ComfyUI API के साथ इसे स्क्रिप्ट कर सकते हैं।

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

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

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

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

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

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

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

उन्नत ComfyUI बैच प्रसंस्करण पैटर्न

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

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

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 Landscape: 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}")

        # इस छवि के लिए वर्कफ़्लो संशोधित करें
        # ये नोड ID आपके विशिष्ट वर्कफ़्लो से मेल खाने की आवश्यकता है
        workflow["1"]["inputs"]["image"] = str(image_path)
        workflow["10"]["inputs"]["filename_prefix"] = image_path.stem + "_processed"

        # कतार और प्रतीक्षा करें
        result = queue_prompt(workflow)
        prompt_id = result["prompt_id"]

        try:
            completion = wait_for_completion(prompt_id)
            print(f"  सफलतापूर्वक पूर्ण")
        except TimeoutError:
            print(f"  त्रुटि: {image_path.name} प्रसंस्करण में टाइमआउट")
        except Exception as e:
            print(f"  त्रुटि: {e}")

    print("बैच प्रसंस्करण पूर्ण")

# उपयोग
process_batch(
    "/path/to/input_images",
    "/path/to/output_images",
    "/path/to/workflow_api.json"
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Load Image Batch -> RealESRGAN Upscale -> Save Image

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

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

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

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

Image-to-image जनरेशन संरचना को संरक्षित करते हुए इनपुट को transform करता है:

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

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

Object detection/segmentation डेटासेट में detection मॉडल चलाता है:

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

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

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

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

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

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

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

कई विभिन्न संदर्भों में समान character उत्पन्न करता है।

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

अधिकतम बैच साइज़ क्या है जिसे मैं प्रोसेस कर सकता हूं?

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

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

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

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

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

निष्कर्ष

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

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

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

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

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