ERNIE-Image

ERNIE-Image Batch Production Workflow Optimization: From 1 to 10,000 Images — The Throughput Guide

May 19, 2026

ERNIE-Image Batch Production Workflow Optimization: From 1 to 10,000 Images — The Throughput Guide

Read time: ~10 minutes | Last updated: 2026-05-19

When you need to generate 10, 100, or even 10,000 images from ERNIE-Image, manual one-by-one generation is no longer viable. This guide dives deep into ComfyUI batch node configuration, Turbo mode optimization, grid artifact removal, SGLang API batch endpoints, and quantized deployment acceleration — five optimization strategies to build an efficient batch production pipeline.

Why Batch Optimization Matters

Typical Use Cases

Use Case Volume Time Requirement Cost Sensitivity
E-commerce product photos 500-2000/week Same-day High
Social media content 50-200/week Daily updates Medium
A/B test materials 200-1000/batch Fast iteration High
Data augmentation 5000-10000/batch Offline processing Low

Benchmark: Single vs Batch

Tested on RTX 4090 (24GB VRAM) with ERNIE-Image-Turbo:

Configuration Per Image 100 Images Throughput
BF16 + 50 steps ~25 sec ~45 min 2.2 img/min
BF16 + 8 steps (Turbo) ~5 sec ~9 min 11 img/min
FP8 + 8 steps (Turbo) ~4 sec ~7 min 14 img/min
INT8 + 8 steps (Turbo) ~3.5 sec ~6 min 16.7 img/min

Bottom line: Turbo mode + quantization = the optimal batch production setup.

ComfyUI Batch Workflow Setup

Core Node Configuration

[Load Checkpoint] → ERNIE-Image-Turbo.safetensors
       ↓
[CLIP Text Encode] → Prompt List (CSV input)
       ↓
[Empty Latent Image] → 1264 × 848
       ↓
[Sampler] → steps=8, cfg=1.0, scheduler=euler_ancestral
       ↓
[VAE Decode]
       ↓
[Save Image] → Output directory + auto-numbering

CSV Batch Prompt Input

Manage batch prompts with CSV files:

sku,name,style,prompt
SKU001,Wireless Headphones,Minimal White,"a product photo of wireless headphones on pure white background, studio lighting, 8K, commercial photography"
SKU002,Smart Watch,Tech Feel,"a product photo of a smartwatch on dark gradient background, blue accent light, tech aesthetic, 8K"
SKU003,Running Shoes,Sporty,"a product photo of running shoes on gym floor background, dynamic angle, sporty lifestyle, 8K"

Python CSV-to-Images Script

import pandas as pd
import torch
from diffusers import ErnieImagePipeline

pipe = ErnieImagePipeline.from_pretrained(

"Baidu/ERNIE-Image-Turbo",

torch_dtype=torch.float8_e4m3fn  # FP8 quantization

).to("cuda")


products = pd.read_csv("batch_prompts.csv")


for idx, row in products.iterrows():

image = pipe(

prompt=row['prompt'],

height=1264,

width=848,

num_inference_steps=8,

guidance_scale=1.0,

use_pe=True

).images[0]

image.save(f"output/{row['sku']}.png")

print(f"✓ Generated: {row['sku']} - {row['name']}")

Turbo Mode Deep Optimization

Why Turbo is the Batch Production Choice

ERNIE-Image-Turbo is optimized through DMD (Diffusion Model Distillation) + RL (Reinforcement Learning), achieving near-equivalent aesthetic quality to the 50-step standard version in just 8 steps:

Metric ERNIE-Image (50 steps) ERNIE-Image-Turbo (8 steps) Difference
Inference steps 50 8 6.25x faster
CFG Scale 4.0 1.0 Further speedup
GenEval score 0.8856 0.8667 -2.1%
Time/image (RTX 4090) ~25 sec ~5 sec 5x faster

Optimal Turbo Parameters

# Recommended batch production config
pipe = ErnieImagePipeline.from_pretrained(
    "Baidu/ERNIE-Image-Turbo",
    torch_dtype=torch.float8_e4m3fn
).to("cuda")

OPTIMAL_SETTINGS = {

"height": 1264,

"width": 848,

"num_inference_steps": 8,      # Turbo fixed at 8

"guidance_scale": 1.0,          # Recommended for Turbo

"use_pe": True,                 # Enable Prompt Enhancer

"scheduler": "euler_ancestral"  # Recommended scheduler

}

Note: Do NOT adjust num_inference_steps for Turbo mode. 8 steps is the distilled optimum.

Grid Artifacts: Problem & Solutions

The Problem

Reddit users reported grid artifacts in ERNIE-Image-Turbo outputs, especially in:

  • Large solid-color backgrounds
  • Low-complexity scenes
  • High CFG scale (>1.5)

Solution 1: Increase Prompt Complexity

❌ Too simple:
"a red ball on white background"

✅ Add scene details:

"a matte red sphere centered on a clean white surface, soft studio lighting from above, subtle shadow underneath, commercial product photography, 8K"

Solution 2: Add "Film Camera" Keywords

Reddit users found these keywords effectively reduce artifacts:

"point-and-shoot film camera, 35mm, slight grain, natural lighting"

Solution 3: img2img Refinement

For images with artifacts, use img2img for secondary refinement:

# First pass: Quick Turbo generation
base_image = pipe_turbo(prompt, num_inference_steps=8, guidance_scale=1.0).images[0]

Second pass: Quality refinement with standard model


refined_image = pipe_standard(

prompt=prompt,

image=base_image,

strength=0.3,          # Low denoise strength

num_inference_steps=20,

guidance_scale=2.0

).images[0]

Solution 4: Lower CFG Scale

# In Turbo mode
guidance_scale = 1.0  # Recommended
# If artifacts appear, try
guidance_scale = 0.8  # Lower CFG

SGLang API Batch Endpoint

Deploy SGLang Service

# Install SGLang
git clone https://github.com/sgl-project/sglang.git
cd sglang
pip install -e .

Start service (Turbo mode)


sglang serve --model-path baidu/ERNIE-Image-Turbo 

--host 0.0.0.0 

--port 30000 

--mem-fraction-static 0.85

Batch API Calls

# Single request, batch generate 4 images
curl -X POST http://localhost:30000/v1/images/generations \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a luxury watch on dark marble surface, dramatic lighting, 8K",
    "n": 4,
    "size": "1264x848"
  }'

Python Batch Script

import requests
import json
from concurrent.futures import ThreadPoolExecutor, as_completed

API_URL = "http://localhost:30000/v1/images/generations"


def generate_batch(prompts, batch_size=4):

"""Batch API request with thread pool"""

results = []

with ThreadPoolExecutor(max_workers=4) as executor:

futures = []

for prompt in prompts:

payload = {

"prompt": prompt,

"n": batch_size,

"size": "1264x848"

}

futures.append(executor.submit(

requests.post, API_URL, json=payload

))


    for future in as_completed(futures):
        response = future.result()
        if response.status_code == 200:
            results.append(response.json())

return results



Usage


prompts = [

"a product photo of headphones on white background",

"a product photo of sneakers on gym floor",

"a product photo of watch on dark surface",

# ... more prompts

]


batch_results = generate_batch(prompts, batch_size=4)

PE Separated Deployment (Advanced)

Separate the Prompt Enhancer and DiT servers for higher throughput:

# Terminal 1: PE server (vLLM)
vllm serve baidu/ERNIE-Image-PE --port 8000

Terminal 2: DiT server (SGLang)


sglang serve --model-path baidu/ERNIE-Image-Turbo --port 30000

Quantized Deployment Acceleration

Quantization Comparison

Quantization VRAM Speed Gain Quality Loss Best For
BF16 (Original) ~16 GB Baseline None Quality-first
FP8 (E4M3) ~8 GB +30% Minimal Batch production
INT8 ~6 GB +40% Acceptable VRAM-limited
NVFP4 ~4.78 GB +50% Acceptable Low VRAM
GGUF (Q4) ~5 GB +35% Moderate Consumer GPU

Recommended Hardware Matrix

Hardware Quantization Strategy Throughput
RTX 4090 (24GB) FP8 + Turbo Single GPU batch 14 img/min
RTX 3090 (24GB) FP8 + Turbo Single GPU batch 12 img/min
A100 (48GB) BF16 + Turbo Multi-concurrent 25+ img/min
A6000 (48GB) BF16 + Turbo Multi-concurrent 25+ img/min
RTX 3060 (12GB) INT8 + Turbo Serial 8 img/min
RTX 4060 (8GB) GGUF Q4 + Turbo Lower res 6 img/min

FP8 Quantized Loading

from diffusers import ErnieImagePipeline
import torch

FP8 quantized loading


pipe = ErnieImagePipeline.from_pretrained(

"Baidu/ERNIE-Image-Turbo",

torch_dtype=torch.float8_e4m3fn

).to("cuda")


Batch generation


for prompt in prompts:

image = pipe(

prompt=prompt,

height=1264,

width=848,

num_inference_steps=8,

guidance_scale=1.0,

use_pe=True

).images[0]

image.save(f"output/{idx}.png")

Complete Batch Production Workflow

End-to-End Flow

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  CSV/JSON     │────▶│  Prompt       │────▶│  Batch        │
│  Prompt Input │     │  Enhancer     │     │  Inference    │
└──────────────┘     └──────────────┘     │  (Turbo+FP8)  │
                                          └──────┬───────┘
                    ┌──────────────┐     ┌────────▼───────┐
                    │  Quality      │◀────│  Image Output   │
                    │  Filtering    │     │  Auto-name+sort │
                    │  (optional)   │     └───────────────┘
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │  Final Output │
                    │  E-com/Social │
                    └──────────────┘

Complete Python Batch Producer

import pandas as pd
import torch
from diffusers import ErnieImagePipeline
import os
from datetime import datetime

class ERNIEBatchProducer:

def init(self, model_path="Baidu/ERNIE-Image-Turbo"):

self.pipe = ErnieImagePipeline.from_pretrained(

model_path,

torch_dtype=torch.float8_e4m3fn

).to("cuda")


def batch_generate(self, csv_path, output_dir="output", variants_per_prompt=1):
    """Batch generation entry point"""
    products = pd.read_csv(csv_path)
    os.makedirs(output_dir, exist_ok=True)
    
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    batch_dir = os.path.join(output_dir, f"batch_{timestamp}")
    os.makedirs(batch_dir, exist_ok=True)
    
    success_count = 0
    fail_count = 0
    
    for idx, row in products.iterrows():
        try:
            for v in range(variants_per_prompt):
                image = self.pipe(
                    prompt=row['prompt'],
                    height=1264,
                    width=848,
                    num_inference_steps=8,
                    guidance_scale=1.0,
                    use_pe=True
                ).images[0]
                
                filename = f"{row['sku']}_v{v+1}.png"
                image.save(os.path.join(batch_dir, filename))
            
            success_count += 1
            if (idx + 1) % 20 == 0:
                print(f"✓ Progress: {idx+1}/{len(products)} ({(idx+1)/len(products)*100:.1f}%)")
                
        except Exception as e:
            print(f"✗ Failed: {row['sku']} - {str(e)}")
            fail_count += 1
    
    print(f"\n📊 Batch Complete: {success_count} succeeded, {fail_count} failed")
    print(f"📁 Output: {batch_dir}")
    return batch_dir



Usage


producer = ERNIEBatchProducer()

output = producer.batch_generate("products.csv", variants_per_prompt=2)

Summary & Best Practices

Batch Production Checklist

  • Use ERNIE-Image-Turbo (8 steps + CFG 1.0)
  • Load FP8 quantized model (speed/quality balance)
  • Manage batch prompts via CSV/JSON
  • Use SGLang or Diffusers for batch inference
  • Handle grid artifacts (add prompt detail or img2img refine)
  • Set up auto-naming and categorized output
  • Perform quality spot-checks (especially for large batches)

Performance Expectations

On RTX 4090 (24GB) with Turbo + FP8:

  • 100 images: ~7 minutes
  • 500 images: ~35 minutes
  • 1000 images: ~70 minutes
  • Cost: ~$0.50/hr electricity, 1000 images totals ~$0.60

References

  1. ERNIE-Image GitHub — Official documentation
  2. ERNIE-Image-Turbo HuggingFace — Turbo model
  3. SGLang Documentation — API deployment guide
  4. Reddit r/StableDiffusion — Grid artifact discussions
  5. ComfyUI Documentation — Workflow setup

This article is based on hands-on testing. Performance data is based on RTX 4090 (24GB) + CUDA 12.4 + PyTorch 2.5. Results may vary with different hardware configurations.

ERNIE-Image Team