batch upscaling of many different prompts

[barrubba]

I've generated 2 samples for 300 different artists.
Now i wish to upscale in batch (600 images)
How can I make each sample refer to its specific prompt?
I cannot change it every 2 images for 300 times!
Thank you

[kevmatic]

So I have a similar use case, so I created a script that 'overrides' various settings in IMG2IMG with ones read from the PNG info for the file. Basically it batch-does the "send to img2img" in the "Png info" tab but you can choose which settings you want from the UI and which ones from the file.

Just put this in a file in your scripts folder and choose "Override from file PNGInfo" script and check the checkboxes you want. I only spent about 30 seconds trying it, but its pretty simple.

However, it won't work with SD upscaling because they're both a dropdown script and I don't know what I'm doing enough to change that.

import modules.scripts as scripts
import gradio as gr
import os

from modules import images
from modules import processing
from modules.processing import process_images, Processed
from modules.processing import Processed
from modules.shared import opts, cmd_opts, state
from modules.generation_parameters_copypaste import parse_generation_parameters
from modules.extras import run_pnginfo

class Script(scripts.Script):  

# The title of the script. This is what will be displayed in the dropdown menu.
    def title(self):

        return "Override from file PNGInfo"


# Determines when the script should be shown in the dropdown menu via the 
# returned value. As an example:
# is_img2img is True if the current tab is img2img, and False if it is txt2img.
# Thus, return is_img2img to only show the script on the img2img tab.

    def show(self, is_img2img):

        return is_img2img

# How the script's is displayed in the UI. See https://gradio.app/docs/#components
# for the different UI components you can use and how to create them.
# Most UI components can return a value, such as a boolean for a checkbox.
# The returned values are passed to the run method as parameters.

    def ui(self, is_img2img):
        wantPrompt = gr.Checkbox(False, label="Override Prompt")
        wantNegative= gr.Checkbox(False, label="Override Negative Prompt")
        wantSeed = gr.Checkbox(False, label="Override Seed")
        wantSteps = gr.Checkbox(False, label="Override Steps")
        wantCFGScale = gr.Checkbox(False, label="Override CFG scale")
        wantSize = gr.Checkbox(False, label="Override Width and Height")
        wantdenoise = gr.Checkbox(False, label="Override Denoising strength")
        return [wantPrompt, wantNegative, wantSeed,wantSteps,wantCFGScale,wantSize,wantdenoise]

  

# This is where the additional processing is implemented. The parameters include
# self, the model object "p" (a StableDiffusionProcessing class, see
# processing.py), and the parameters returned by the ui method.
# Custom functions can be defined here, and additional libraries can be imported 
# to be used in processing. The return value should be a Processed object, which is
# what is returned by the process_images method.

    def run(self, p, wantPrompt, wantNegative, wantSeed,wantSteps,wantCFGScale,wantSize,wantdenoise):
        
        #proc = process_images(p)
        mytext = run_pnginfo(p.init_images[0])[1]
        deets = parse_generation_parameters(mytext)
        if wantPrompt and 'Prompt' in deets:
            p.prompt = deets['Prompt']
        if wantNegative and 'Negative prompt' in deets:
            p.negative_prompt = deets['Negative prompt']
        if wantSeed and 'Seed' in deets:
            p.seed = float(deets['Seed'])
        if wantSteps and 'Steps' in deets:
            p.steps = int(deets['Steps'])
        if wantCFGScale  and 'Seed' in deets:
            p.cfg_scale = int(deets['CFG scale'])                        
        if wantSize and 'Size-1' in deets:
            p.width = int(deets['Size-1'])
        if wantSize and 'Size-2' in deets:
            p.height = int(deets['Size-2'])
        if wantdenoise and 'Denoising strength' in deets:
            p.denoising_strength = float(deets['Denoising strength'])
        
        processing.fix_seed(p)


        return process_images(p)

[juan9999]

I think this is what I've been looking for - thanks for sharing!

I'm trying to solve for a similar issue with my workflow:

Currently I generate a lot of images at 512x512 using SD 1.5 and then go through them and create a folder of images that I like (that have the prompts in the png) but then want to batch regenerate them at a larger size? e.g. 1024x1024?

So I installed your script, overwrote strengh, de-noising, and size and although it seems to have re-generated the images based on the original prompt/seed, unfortunately, it executed very quickly and seems to be producing lower quality (steps) versions that are of the original size.

UPDATE: Did a test where I did NOT check any of buttons, but changed the size and maybe the sampling method, and it did generate bigger images that are of worst quality.

Since the file produced do not have any .PNG info embedded in them so I can't see exactly what was done. Do you know of a way to enable that? It works fine for txt2image.

Any clues of what I'm doing wrong?

[tom-7-7]

In the meantime, is there already a customized code that works with SD upscaling? I think many would be interested in achieving good upscaling results even with bulk processing.

Actually one should only merge the script with the SD upscaler script, right? Then the features of both scripts would run under one dropdown script area. The merge should be easy for a programmer. The code seems to be simple. However, I have no idea about programming. Anyone else?

[juan9999]

Yeah, I'd like to see a script that first regenerates at a higher size, then upscales it...

[bkfindley]

I merged the above with the sd upscale script below. I've batched together like 400 images in one go and it seems to work pretty well.

import math

import modules.scripts as scripts
import gradio as gr
from PIL import Image

from modules import processing, shared, sd_samplers, images, devices
from modules.processing import Processed
from modules.shared import opts, cmd_opts, state

import os

from modules import images
from modules import processing
from modules.processing import process_images, Processed
from modules.generation_parameters_copypaste import parse_generation_parameters
from modules.extras import run_pnginfo



class Script(scripts.Script):
    def title(self):
        return "Custon Png Info SD Upscale"

    def show(self, is_img2img):
        return is_img2img

    def ui(self, is_img2img):        
        info = gr.HTML("<p style=\"margin-bottom:0.75em\">Will upscale the image by the selected scale factor; use width and height sliders to set tile size</p>")
        overlap = gr.Slider(minimum=0, maximum=256, step=16, label='Tile overlap', value=64, elem_id=self.elem_id("overlap"))
        scale_factor = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label='Scale Factor', value=2.0, elem_id=self.elem_id("scale_factor"))
        upscaler_index = gr.Radio(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name, type="index", elem_id=self.elem_id("upscaler_index"))
		
        wantPrompt = gr.Checkbox(False, label="Override Prompt")
        wantNegative= gr.Checkbox(False, label="Override Negative Prompt")
        wantSeed = gr.Checkbox(False, label="Override Seed")
        wantSteps = gr.Checkbox(False, label="Override Steps")
        wantCFGScale = gr.Checkbox(False, label="Override CFG scale")
        wantSize = gr.Checkbox(False, label="Override Width and Height")
        wantdenoise = gr.Checkbox(False, label="Override Denoising strength")		

        return [info, overlap, upscaler_index, scale_factor, wantPrompt, wantNegative, wantSeed,wantSteps,wantCFGScale,wantSize,wantdenoise]

    def run(self, p, _, overlap, upscaler_index, scale_factor, wantPrompt, wantNegative, wantSeed,wantSteps,wantCFGScale,wantSize,wantdenoise):
        if isinstance(upscaler_index, str):
            upscaler_index = [x.name.lower() for x in shared.sd_upscalers].index(upscaler_index.lower())

		
        mytext = run_pnginfo(p.init_images[0])[1]
        deets = parse_generation_parameters(mytext)
        if wantPrompt and 'Prompt' in deets:
            p.prompt = deets['Prompt']
        if wantNegative and 'Negative prompt' in deets:
            p.negative_prompt = deets['Negative prompt']
        if wantSeed and 'Seed' in deets:
            p.seed = float(deets['Seed'])
        if wantSteps and 'Steps' in deets:
            p.steps = int(deets['Steps'])
        if wantCFGScale  and 'Seed' in deets:
            p.cfg_scale = float(deets['CFG scale'])                        
        if wantSize and 'Size-1' in deets:
            p.width = int(deets['Size-1'])
        if wantSize and 'Size-2' in deets:
            p.height = int(deets['Size-2'])
        if wantdenoise and 'Denoising strength' in deets:
            p.denoising_strength = float(deets['Denoising strength'])
        
        processing.fix_seed(p)
		
		
		
		
        upscaler = shared.sd_upscalers[upscaler_index]

        p.extra_generation_params["SD upscale overlap"] = overlap
        p.extra_generation_params["SD upscale upscaler"] = upscaler.name

        initial_info = None
        seed = p.seed

        init_img = p.init_images[0]
        init_img = images.flatten(init_img, opts.img2img_background_color)

        if upscaler.name != "None":
            img = upscaler.scaler.upscale(init_img, scale_factor, upscaler.data_path)
        else:
            img = init_img

        devices.torch_gc()

        grid = images.split_grid(img, tile_w=p.width, tile_h=p.height, overlap=overlap)

        batch_size = p.batch_size
        upscale_count = p.n_iter
        p.n_iter = 1
        p.do_not_save_grid = True
        p.do_not_save_samples = True

        work = []

        for y, h, row in grid.tiles:
            for tiledata in row:
                work.append(tiledata[2])

        batch_count = math.ceil(len(work) / batch_size)
        state.job_count = batch_count * upscale_count

        print(f"SD upscaling will process a total of {len(work)} images tiled as {len(grid.tiles[0][2])}x{len(grid.tiles)} per upscale in a total of {state.job_count} batches.")

        result_images = []
        for n in range(upscale_count):
            start_seed = seed + n
            p.seed = start_seed

            work_results = []
            for i in range(batch_count):
                p.batch_size = batch_size
                p.init_images = work[i * batch_size:(i + 1) * batch_size]

                state.job = f"Batch {i + 1 + n * batch_count} out of {state.job_count}"
                processed = processing.process_images(p)

                if initial_info is None:
                    initial_info = processed.info

                p.seed = processed.seed + 1
                work_results += processed.images

            image_index = 0
            for y, h, row in grid.tiles:
                for tiledata in row:
                    tiledata[2] = work_results[image_index] if image_index < len(work_results) else Image.new("RGB", (p.width, p.height))
                    image_index += 1

            combined_image = images.combine_grid(grid)
            result_images.append(combined_image)

            if opts.samples_save:
                images.save_image(combined_image, p.outpath_samples, "", start_seed, p.prompt, opts.samples_format, info=initial_info, p=p)

        processed = Processed(p, result_images, seed, initial_info)

        return processed

[pablonaj]

Thanks that worked really well.

[gobshyte]

Love this script it is so useful.
I have even been using it with controlnet tile upscaling method with great success.
Any way we can get this as an official function? extension?

[aquCHAOS]

Love this script it is so useful. I have even been using it with controlnet tile upscaling method with great success. Any way we can get this as an official function? extension?

May I ask how did you manage to get it work? I use this script together with controlnet tile in batch tab, but only the first image is generated and it stops there.

[ghost]

I cant get the API's upscaling to work at all

[rnruxn773]

I have modified @kevmatic's code to implement the options to add or remove tags for each image. I hope this will be useful.

import modules.scripts as scripts
import gradio as gr
import os
import re

from modules import images
from modules import processing
from modules.processing import process_images, Processed
from modules.processing import Processed
from modules.shared import opts, cmd_opts, state
from modules.generation_parameters_copypaste import parse_generation_parameters
from modules.extras import run_pnginfo

class Script(scripts.Script):  

# The title of the script. This is what will be displayed in the dropdown menu.
    def title(self):

        return "Override from file PNGInfo"


# Determines when the script should be shown in the dropdown menu via the 
# returned value. As an example:
# is_img2img is True if the current tab is img2img, and False if it is txt2img.
# Thus, return is_img2img to only show the script on the img2img tab.

    def show(self, is_img2img):

        return is_img2img

# How the script's is displayed in the UI. See https://gradio.app/docs/#components
# for the different UI components you can use and how to create them.
# Most UI components can return a value, such as a boolean for a checkbox.
# The returned values are passed to the run method as parameters.

    def ui(self, is_img2img):
        wantPrompt = gr.Checkbox(False, label="Override Prompt")
        addTags = gr.Textbox(label="Tags to add")
        addTagsAtEnd = gr.Textbox(label="Tags to add at the end")
        removeTags = gr.Textbox(label="Tags to remove (Remove only tags already in each image)")
        wantNegative= gr.Checkbox(False, label="Override Negative Prompt")
        wantSeed = gr.Checkbox(False, label="Override Seed")
        wantSteps = gr.Checkbox(False, label="Override Steps")
        wantCFGScale = gr.Checkbox(False, label="Override CFG scale")
        wantSize = gr.Checkbox(False, label="Override Width and Height")
        wantdenoise = gr.Checkbox(False, label="Override Denoising strength")
        return [wantPrompt, addTags, addTagsAtEnd, removeTags, wantNegative, wantSeed,wantSteps,wantCFGScale,wantSize,wantdenoise]

  

# This is where the additional processing is implemented. The parameters include
# self, the model object "p" (a StableDiffusionProcessing class, see
# processing.py), and the parameters returned by the ui method.
# Custom functions can be defined here, and additional libraries can be imported 
# to be used in processing. The return value should be a Processed object, which is
# what is returned by the process_images method.

    def run(self, p, wantPrompt,addTags,addTagsAtEnd,removeTags,wantNegative,wantSeed,wantSteps,wantCFGScale,wantSize,wantdenoise):
        
        #proc = process_images(p)
        mytext = run_pnginfo(p.init_images[0])[1]
        deets = parse_generation_parameters(mytext)

        if wantPrompt and 'Prompt' in deets:
            p.prompt = deets['Prompt']

            if removeTags:
                tags = removeTags.split(", ")
                text = p.prompt
                for tag in tags:
                    text = re.sub("\(\(" + tag + "\)\)|\(" + tag + ":.*?\)|<" + tag + ":.*?>|<" + tag + ">", "", text)
                    text = re.sub(r'\([^\(]*(%s)\S*\)' % tag, '', text)
                    text = re.sub(r'\[[^\[]*(%s)\S*\]' % tag, '', text)
                    text = re.sub(r'<[^<]*(%s)\S*>' % tag, '', text)
                    text = re.sub(r'\b' + tag + r'\b', '', text)

                text = re.sub(r'(, ?)+', ', ', text)
                p.prompt = text

            if addTags:
                if addTags.endswith(' ') == False and addTags.endswith(',') == False:
                    addTags = addTags + ','
                p.prompt = ''.join([addTags, p.prompt])

            if addTagsAtEnd:
                if addTags.startswith(' ') == False and addTags.startswith(',') == False:
                    addTagsAtEnd = ',' + addTagsAtEnd
                p.prompt = ''.join([p.prompt, addTagsAtEnd])

        if wantNegative and 'Negative prompt' in deets:
            p.negative_prompt = deets['Negative prompt']
        if wantSeed and 'Seed' in deets:
            p.seed = float(deets['Seed'])
        if wantSteps and 'Steps' in deets:
            p.steps = int(deets['Steps'])
        if wantCFGScale  and 'Seed' in deets:
            p.cfg_scale = int(deets['CFG scale'])                        
        if wantSize and 'Size-1' in deets:
            p.width = int(deets['Size-1'])
        if wantSize and 'Size-2' in deets:
            p.height = int(deets['Size-2'])
        if wantdenoise and 'Denoising strength' in deets:
            p.denoising_strength = float(deets['Denoising strength'])
        
        processing.fix_seed(p)


        return process_images(p)

[mattehicks]

Is there a possibility to add the prompt to the console output? I'd like to know which image is being processed, so I can track any bad source images or prompts. Asking because I can't tell what order the images are being processed.

[souvik0306]

Made this Google Colab Notebook that can generate bulk images by just providing a list of prompts in a go!

Colab Link - http://bit.ly/40BM7v4

You can Upscale an entire batch of images and download them as a ZIP

[sss25285]

error
耗时：0.00sTorch 活动/保留：3373/3732 MiB，Sys VRAM：6088/24576 MiB (24.77%)

[retret66]

this thing doesnt work, even if I copy this py script to the script directory it is not available in the drop down even restarting UI