Traitement par Lots de 1000+ Images dans ComfyUI - Guide Complet des Workflows

Le système de workflow basé sur les nœuds de ComfyUI n'est pas seulement pour l'expérimentation interactive - c'est un puissant moteur de traitement par lots capable de gérer des milliers d'images avec la bonne configuration. Le traitement par lots ComfyUI transforme vos workflows d'expériences sur une seule image en pipelines de production capables de gérer des ensembles de données massifs. Que vous ayez besoin d'agrandir un catalogue de produits, d'appliquer un transfert de style cohérent sur un ensemble de données, d'exécuter la détection d'objets sur des milliers de frames, ou de générer des variations à partir d'un dossier d'images d'entrée, le traitement par lots ComfyUI transforme ComfyUI d'un outil créatif en un pipeline de production.

Ce guide couvre tout, de la conception de workflow de traitement par lots ComfyUI de base aux techniques d'automatisation avancées qui vous permettent de traiter des ensembles massifs d'images pendant que vous dormez. Vous apprendrez à utiliser efficacement les nœuds de chargement par lots, à gérer les files d'attente de longue durée, à gérer les erreurs avec élégance et à adapter le traitement aux capacités de votre matériel. À la fin, vous aurez les connaissances pour construire des systèmes de traitement par lots ComfyUI fiables qui gèrent de vraies charges de travail de production.

Comprendre l'Architecture de Traitement par Lots ComfyUI

Avant de construire des workflows par lots, comprenez comment le traitement par lots ComfyUI gère les opérations par lots différemment du traitement d'image unique. Comprendre l'architecture de traitement par lots ComfyUI est essentiel pour construire des workflows efficaces.

En mode image unique, vous chargez une image, la traitez à travers votre workflow et enregistrez le résultat. Chaque génération est initiée manuellement. Pour le traitement par lots, vous avez besoin d'une itération automatique : charger l'image 1, traiter, enregistrer le résultat 1, puis passer automatiquement à l'image 2, et continuer jusqu'à ce que toutes les images soient traitées.

ComfyUI y parvient grâce à des nœuds de chargement par lots spécialisés qui itèrent à travers les dossiers d'images. Lorsque vous mettez en file d'attente un workflow avec un chargeur par lots, ComfyUI ne s'exécute pas qu'une seule fois - il met automatiquement en file d'attente plusieurs exécutions, une pour chaque image (ou groupe d'images) dans votre dossier source. Le nœud de chargeur par lots suit quelle image charger pour chaque exécution, incrémentant à travers votre ensemble de données.

Le concept clé dans le traitement par lots ComfyUI est le modèle file-d'attente-par-image. Si vous avez 1000 images à traiter, ComfyUI met en file d'attente 1000 exécutions de workflow. Chaque exécution charge l'image suivante du lot, la traite et enregistre le résultat. Cela diffère des approches de traitement par lots qui chargent plusieurs images simultanément dans une seule exécution - le traitement par lots ComfyUI gère une image par exécution mais automatise l'itération à travers votre ensemble de données.

Cette architecture a des implications importantes. Chaque image est traitée à travers le workflow complet indépendamment, ce qui fournit une isolation - une image échouée ne bloque pas le traitement des images suivantes. Cependant, cela signifie aussi que tout surcoût par exécution (chargement de modèle, etc.) se produit pour chaque image sauf si ComfyUI met en cache de manière appropriée.

Nœuds Essentiels pour le Traitement par Lots ComfyUI

Plusieurs types de nœuds permettent les workflows de traitement par lots ComfyUI. Comprendre ce qui est disponible vous aide à concevoir des pipelines efficaces pour les opérations de traitement par lots ComfyUI.

Les nœuds Load Image Batch de divers packs de nœuds personnalisés chargent les images d'un dossier séquentiellement. Les paramètres principaux incluent :

• Directory path : Le dossier contenant vos images source
• Index : Quelle image dans le dossier charger (basé sur 0)
• Pattern : Filtrage optionnel de motif de fichier (ex., *.jpg, *.png)

Lorsque vous mettez en file d'attente le workflow, ComfyUI incrémente automatiquement l'index pour chaque exécution en file d'attente. Définissez votre index initial et le nombre d'images à traiter, et ComfyUI gère l'itération.

Le nœud Image Input du ComfyUI-Impact-Pack fournit une fonctionnalité de lot avec des caractéristiques supplémentaires comme la préservation automatique du nom de fichier de sortie. C'est particulièrement utile lorsque vous avez besoin que les fichiers de sortie correspondent aux noms de fichiers d'entrée.

VHS Load Images du Video Helper Suite peut charger des images par lots avec une bonne gestion des noms de fichiers et prend en charge le chargement de séquences d'images dans l'ordre.

Les nœuds Save Image ont besoin d'une configuration pour la sortie par lots. La clé est le templating de nom de fichier qui assure que chaque sortie a un nom unique. Les options incluent :

• Numérotation séquentielle : output_0001.png, output_0002.png, etc.
• Préservation du nom de fichier d'entrée : si l'entrée est photo_001.jpg, la sortie est photo_001_processed.png
• Ajout de préfixes/suffixes pour organiser les sorties

La plupart des nœuds de sauvegarde personnalisés prennent en charge ces modèles. Consultez la documentation de votre nœud spécifique pour la syntaxe des modèles.

Construire un Workflow de Traitement par Lots ComfyUI Basique

Parcourons la création d'un workflow de traitement par lots ComfyUI complet pour une tâche courante : l'agrandissement d'un dossier d'images.

Commencez par votre nœud d'entrée. Placez un nœud Load Image Batch et configurez-le :

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

L'index commence à 0 pour la première image. Vous mettrez en file d'attente plusieurs exécutions pour traiter toutes les images.

Connectez l'image chargée à votre pipeline de traitement. Pour l'agrandissement, cela pourrait être :

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

Ou pour un agrandissement plus sophistiqué :

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

Configurez votre nœud Save Image pour gérer la sortie par lots. Définissez le répertoire de sortie et le modèle de nom de fichier :

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

Avec certains nœuds de sauvegarde, vous pouvez préserver le nom de fichier original :

Filename Template: {original_name}_upscaled

Maintenant, déterminez combien d'images traiter. Vérifiez combien d'images sont dans votre dossier d'entrée (ex., 500 images). Dans ComfyUI, définissez le nombre de queue prompt pour correspondre. Lorsque vous cliquez sur Queue Prompt avec "Extra options" montrant 500, ComfyUI met en file d'attente 500 exécutions de workflow. Le chargeur par lots incrémente automatiquement l'index pour chaque exécution, traitant l'image 0 à l'image 499.

Cliquez sur Queue et observez la progression. ComfyUI affiche le nombre restant de la file d'attente, et vous pouvez voir les sorties apparaître dans votre dossier de sortie.

Gérer le Traitement par Lots ComfyUI à Grande Échelle (1000+ Images)

Le traitement de centaines ou de milliers d'images introduit des défis que les lots plus petits ne rencontrent pas. Voici comment gérer efficacement le traitement par lots ComfyUI à grande échelle.

Diviser les grands lots en chunks est essentiel pour la maniabilité. Plutôt que de mettre en file d'attente 5000 exécutions à la fois, divisez en chunks de 500-1000. Cela offre plusieurs avantages :

• Surveillance de progression plus facile (vous savez quand chaque chunk est terminé)
• Possibilité de faire une pause entre les chunks pour vérifier les résultats
• Récupération plus facile si quelque chose ne va pas au milieu du lot
• Meilleure gestion de la mémoire (certains caches peuvent se vider entre les chunks)

Pour traiter en chunks, ajustez votre index de départ et le nombre de files d'attente :

• Chunk 1 : Index 0, mettre en file d'attente 500 images
• Chunk 2 : Index 500, mettre en file d'attente 500 images
• Chunk 3 : Index 1000, mettre en file d'attente 500 images

Vous pouvez scripter cela avec l'API ComfyUI pour un traitement automatique.

La gestion de la mémoire est importante pour les lots longs. ComfyUI met en cache les modèles chargés et les résultats intermédiaires pour la performance, mais sur des milliers d'itérations, la mémoire peut s'accumuler. Si vous voyez la mémoire croître au fil du temps :

• Videz le cache ComfyUI périodiquement via l'interface
• Pour les très longs lots, planifiez des chunks avec des redémarrages de ComfyUI entre eux
• Utilisez --cpu-vae ou d'autres flags d'économie de mémoire si nécessaire

La surveillance de progression devient importante lorsque le traitement prend des heures ou des jours. Les options incluent :

• Observer le compteur de file d'attente dans l'interface
• Compter les fichiers de sortie apparaissant dans votre dossier de sortie
• Utiliser une surveillance basée sur l'API pour suivre la progression programmatiquement
• Enregistrer la complétion de chaque chunk si vous scriptez

La gestion des erreurs est critique car certaines images échoueront. Peut-être qu'un fichier est corrompu, ou qu'une image a des dimensions inhabituelles qui cassent votre workflow. Le comportement par défaut de ComfyUI s'arrête sur erreur, ce qui signifie que vous découvrez le lendemain matin que le traitement s'est arrêté à l'image 347 sur 5000.

Meilleures approches :

• Certains nœuds de lots ont des options skip-on-error qui continuent le traitement
• Implémentez la gestion des erreurs dans votre workflow en utilisant des nœuds personnalisés
• Enregistrez les images échouées pour une investigation ultérieure tout en permettant au lot de continuer
• Traitez en petits chunks pour que les erreurs affectent moins d'images

Modèles Avancés de Traitement par Lots ComfyUI

Au-delà de l'itération basique, plusieurs modèles permettent des workflows de traitement par lots ComfyUI plus sophistiqués.

Le traitement d'entrée appariée gère les cas où chaque image d'entrée a une image de contrôle, un masque ou un fichier de prompt correspondant. Par exemple, l'inpainting avec des masques par image :

Load Image Batch (images) -> index 0, 1, 2...
Load Image Batch (masks) -> index 0, 1, 2... (même indexation)
Inpaint Node -> reçoit l'image et le masque correspondant

Les deux chargeurs par lots utilisent le même index, donc l'image 0 s'apparie avec le masque 0.

Les prompts de fichier texte permettent des prompts par image. Structurez vos données comme :

/images/image_000.jpg
/prompts/image_000.txt (contient le prompt pour image_000)

Chargez le fichier texte de prompt correspondant à chaque image et envoyez-le à l'entrée de prompt de votre nœud sampler.

Le traitement conditionnel applique un traitement différent basé sur les propriétés de l'image. Utilisez des nœuds qui détectent les caractéristiques de l'image (dimensions, contenu, etc.) et orientent vers différentes branches de traitement :

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

Cela permet des workflows de traitement par lots qui s'adaptent aux entrées variées.

Les workflows multi-sorties génèrent plusieurs sorties par entrée. Par exemple, générer trois variations de chaque image :

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

Chaque exécution en file d'attente produit trois sorties pour une entrée.

Contrôle Programmatique du Traitement par Lots ComfyUI via API

Pour un contrôle maximum sur le traitement par lots ComfyUI, utilisez l'API ComfyUI plutôt que l'interface. Le traitement par lots ComfyUI basé sur l'API offre la plus grande flexibilité pour les environnements de production.

ComfyUI expose une API WebSocket qui accepte le JSON de workflow et met en file d'attente les exécutions. Vous pouvez écrire des scripts qui :

• Chargent votre modèle de workflow
• Modifient les paramètres pour chaque élément du lot (chemin d'entrée, chemin de sortie, prompts)
• Soumettent à l'API
• Suivent la complétion
• Gèrent les résultats

Voici un exemple Python pour le traitement par lots avec contrôle API :

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

        # Modifier le workflow pour cette image
        workflow["1"]["inputs"]["image"] = str(image_path)
        workflow["10"]["inputs"]["filename_prefix"] = image_path.stem + "_processed"

        # Mettre en file d'attente et attendre
        result = queue_prompt(workflow)
        prompt_id = result["prompt_id"]

        try:
            completion = wait_for_completion(prompt_id)
            print(f"  Complété avec succès")
        except TimeoutError:
            print(f"  ERREUR: Timeout lors du traitement de {image_path.name}")
        except Exception as e:
            print(f"  ERREUR: {e}")

    print("Traitement par lots terminé")

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

Ce script vous donne un contrôle complet : vous pouvez ajouter du logging, implémenter une logique de réessai, paralléliser sur plusieurs instances ComfyUI, envoyer des notifications à la fin et intégrer avec d'autres systèmes.

Avantages clés du traitement par lots basé sur l'API :

• Traiter des images de n'importe où, pas seulement d'un seul dossier
• Générer dynamiquement des prompts ou des paramètres par image
• Implémenter une gestion des erreurs sophistiquée et une logique de réessai
• Suivre des métriques détaillées et le timing
• Intégrer avec des pipelines plus grands et des systèmes d'automatisation
• Planifier le traitement pour les heures creuses

Optimisation des Performances pour le Traitement par Lots ComfyUI

La performance du traitement par lots ComfyUI détermine si votre travail se termine en heures ou en jours. Optimisez ces facteurs pour maximiser votre débit de traitement par lots ComfyUI :

Surcoût de chargement de modèle : ComfyUI met en cache les modèles chargés entre les exécutions, donc la première image est plus lente que les suivantes (chargement de modèle) mais les images restantes sont traitées plus rapidement. Assurez-vous que votre workflow ne force pas le rechargement de modèle - vérifiez que les chemins de modèle sont cohérents et qu'aucun nœud ne force un chargement frais.

Gestion de la VRAM : Pour les longs lots, la fragmentation de la VRAM peut s'accumuler. Si vous remarquez des ralentissements au fil du temps, le cache pourrait avoir besoin d'être vidé. Équilibrez entre garder les modèles chargés (rapide) et vider le cache (libérer de la VRAM pour des opérations individuelles plus importantes).

I/O disque : Lire des milliers d'images d'entrée et écrire des milliers de sorties sollicite le stockage. Le stockage SSD rapide aide significativement. Évitez de lire et d'écrire sur des lecteurs réseau si possible - le stockage NVMe local offre les meilleures performances.

Traitement parallèle : Si vous avez plusieurs GPU, exécutez plusieurs instances ComfyUI, chacune traitant différents chunks de votre lot. Même sur un seul GPU, vous pourriez exécuter deux instances si votre workflow n'utilise pas complètement la VRAM, bien que cela nécessite des tests.

Optimisation du workflow : Simplifiez votre workflow pour le traitement par lots. Supprimez tous les nœuds de prévisualisation (ils ajoutent du surcoût). Assurez-vous de ne pas faire d'opérations inutiles. Profilez votre workflow pour identifier les goulots d'étranglement.

Compromis résolution et qualité : Le traitement d'images 1024x1024 prend environ 4x plus longtemps que 512x512 pour les tâches de génération. Pour le traitement par lots où la vitesse compte, considérez si une résolution inférieure est acceptable ou si vous pouvez réduire les entrées, traiter, puis agrandir les sorties.

Applications Courantes de Traitement par Lots

Différentes applications nécessitent différents modèles de workflow.

L'agrandissement est l'application de lot la plus simple. Charger des images, passer par le modèle d'agrandissement, enregistrer à plus haute résolution. C'est embarrassamment parallèle et bien adapté au traitement par lots :

Load Image Batch -> RealESRGAN Upscale -> Save Image

Avec un bon GPU, vous pouvez agrandir des milliers d'images pendant la nuit.

Le transfert de style applique un style artistique cohérent à travers un ensemble de données. Utilisez IP-Adapter ou similaire pour appliquer une référence de style à chaque image :

Load Image Batch (content) ->
Load Image (style, référence unique) ->
IP-Adapter -> KSampler -> Save Image

Chaque image est traitée avec la même référence de style.

La génération image-à-image transforme les entrées tout en préservant la structure :

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

Utile pour appliquer des améliorations de génération aux images existantes tout en maintenant la composition.

La détection/segmentation d'objets exécute des modèles de détection sur un ensemble de données :

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

Extrait des masques ou des détections de chaque image pour une utilisation ultérieure.

L'augmentation de données génère plusieurs variations de chaque image pour les ensembles de données d'entraînement :

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

Multiplie la taille de votre ensemble de données à des fins d'entraînement.

La génération cohérente de personnages utilise des prompts par lots pour générer un personnage dans de nombreuses scènes :

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

Génère le même personnage dans de nombreux contextes différents.

Questions Fréquemment Posées

Combien de temps faut-il pour traiter 1000 images ?

Dépend entièrement de la complexité de votre workflow et du matériel. L'agrandissement simple pourrait prendre 3-5 secondes par image (environ une heure au total). Les workflows de génération complexes pourraient prendre 30-60 secondes par image (8-16 heures au total). Multipliez votre temps par image par le nombre d'images pour les estimations.

Puis-je mettre en pause et reprendre le traitement par lots ?

Vous pouvez arrêter la file d'attente à tout moment. Pour reprendre, notez à quel index vous vous êtes arrêté (en comptant les sorties ou la position de la file d'attente), définissez votre chargeur de lots sur cet index, et mettez en file d'attente les images restantes. Certains nœuds de lots ont une fonctionnalité de reprise explicite.

Que se passe-t-il si une image échoue pendant le traitement ?

Le comportement par défaut arrête la file d'attente. Pour continuer malgré les erreurs, utilisez des nœuds de lots avec des options skip-on-error, ou traitez en petits chunks pour que les échecs affectent moins d'images. Notez toujours quelles images ont échoué pour une investigation ultérieure.

Comment savoir quelle image a causé une erreur ?

La position actuelle de la file d'attente vous dit quel index était en cours de traitement. Faites correspondre cela avec le listing de votre dossier d'entrée. Certains nœuds de lots affichent le nom de fichier actuel pour aider à identifier les échecs.

Puis-je traiter des images avec des prompts différents pour chacune ?

Oui, utilisez des nœuds de chargement de fichier texte qui lisent les fichiers de prompt correspondant à chaque image. Structurez vos données pour que image_001.jpg ait image_001.txt contenant son prompt.

Le traitement par lots utilise-t-il plus de VRAM que les images individuelles ?

L'utilisation de VRAM par image est la même. Cependant, les longs lots sans gestion du cache peuvent accumuler de la mémoire. Surveillez l'utilisation pendant les longs lots et videz les caches si la mémoire augmente.

Comment maintenir la correspondance des noms de fichiers entre l'entrée et la sortie ?

Utilisez des nœuds de sauvegarde qui prennent en charge des modèles de nom de fichier comme {original_name}_processed. Cela préserve le nom de fichier d'entrée dans la sortie. Vérifiez la documentation de votre nœud spécifique pour les variables de modèle.

Puis-je traiter des vidéos par lots ?

Oui, extrayez les frames, traitez les frames par lots, puis réassemblez. Les nœuds VHS (Video Helper Suite) gèrent le chargement et la sauvegarde de vidéo. Traitez les vidéos comme des séquences d'images.

Quelle est la taille de lot maximale que je peux traiter ?

Limité par l'espace disque et la patience, pas par ComfyUI. Des dizaines de milliers d'images sont faisables si vous avez le stockage pour les entrées et les sorties. Traitez en chunks gérables plutôt que de tout mettre en file d'attente en une fois.

Comment gérer des images de tailles différentes dans un lot ?

Soit redimensionnez toutes les entrées à des dimensions cohérentes avant le traitement, soit utilisez des nœuds de workflow qui gèrent les tailles variables avec élégance. Certaines opérations nécessitent des dimensions cohérentes tandis que d'autres s'adaptent automatiquement.

Puis-je distribuer le traitement par lots sur plusieurs machines ?

Oui, divisez votre ensemble d'images entre les machines, chacune exécutant ComfyUI. Cela nécessite une coordination pour éviter de traiter les mêmes images deux fois et pour combiner les sorties. Le stockage réseau ou l'orchestration cloud aide.

Conclusion

Le traitement par lots transforme ComfyUI d'un outil créatif interactif en un pipeline de traitement d'images capable de production. Les principes clés sont d'utiliser des nœuds de chargement par lots appropriés, de gérer les longues files d'attente par chunking, de gérer les erreurs avec élégance et d'optimiser les performances pour votre matériel et workflow spécifiques.

Commencez avec des workflows de lots simples traitant de petits ensembles d'images pour vérifier que votre configuration fonctionne correctement. Une fois confiant dans votre workflow, passez à des lots plus grands. Utilisez le scripting basé sur l'API pour un contrôle maximum sur les opérations de lots complexes.

L'investissement dans l'apprentissage du traitement par lots est rentable chaque fois que vous devez traiter plus d'images que vous ne voudriez cliquer manuellement. Que ce soit des dizaines ou des milliers, le traitement par lots le rend faisable.

Pour les utilisateurs qui ont besoin d'un traitement par lots fiable sans gestion d'infrastructure, Apatero.com fournit un traitement évolutif pour de grands ensembles d'images avec une surveillance professionnelle et une gestion des erreurs.