Merge branch 'master' into gradient-clipping

5 files changed, 118 insertions, 41 deletions

diff --git a/scripts/img2imgalt.py b/scripts/img2imgalt.py
index 964b75c7..1229f61b 100644
--- a/scripts/img2imgalt.py
+++ b/scripts/img2imgalt.py
@@ -157,7 +157,7 @@ class Script(scripts.Script):
     def run(self, p, _, override_sampler, override_prompt, original_prompt, original_negative_prompt, override_steps, st, override_strength, cfg, randomness, sigma_adjustment):

         # Override

         if override_sampler:

-            p.sampler_index = [sampler.name for sampler in sd_samplers.samplers].index("Euler")

+            p.sampler_name = "Euler"

         if override_prompt:

             p.prompt = original_prompt

             p.negative_prompt = original_negative_prompt

@@ -191,7 +191,7 @@ class Script(scripts.Script):
             

             combined_noise = ((1 - randomness) * rec_noise + randomness * rand_noise) / ((randomness**2 + (1-randomness)**2) ** 0.5)

             

-            sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers, p.sampler_index, p.sd_model)

+            sampler = sd_samplers.create_sampler(p.sampler_name, p.sd_model)

 

             sigmas = sampler.model_wrap.get_sigmas(p.steps)

             

diff --git a/scripts/prompt_matrix.py b/scripts/prompt_matrix.py
index e49c9b20..4c79eaef 100644
--- a/scripts/prompt_matrix.py
+++ b/scripts/prompt_matrix.py
@@ -18,7 +18,7 @@ def draw_xy_grid(xs, ys, x_label, y_label, cell):
     ver_texts = [[images.GridAnnotation(y_label(y))] for y in ys]

     hor_texts = [[images.GridAnnotation(x_label(x))] for x in xs]

 

-    first_pocessed = None

+    first_processed = None

 

     state.job_count = len(xs) * len(ys)

 

@@ -27,17 +27,17 @@ def draw_xy_grid(xs, ys, x_label, y_label, cell):
             state.job = f"{ix + iy * len(xs) + 1} out of {len(xs) * len(ys)}"

 

             processed = cell(x, y)

-            if first_pocessed is None:

-                first_pocessed = processed

+            if first_processed is None:

+                first_processed = processed

 

             res.append(processed.images[0])

 

     grid = images.image_grid(res, rows=len(ys))

     grid = images.draw_grid_annotations(grid, res[0].width, res[0].height, hor_texts, ver_texts)

 

-    first_pocessed.images = [grid]

+    first_processed.images = [grid]

 

-    return first_pocessed

+    return first_processed

 

 

 class Script(scripts.Script):

@@ -46,10 +46,11 @@ class Script(scripts.Script):
 

     def ui(self, is_img2img):

         put_at_start = gr.Checkbox(label='Put variable parts at start of prompt', value=False)

+        different_seeds = gr.Checkbox(label='Use different seed for each picture', value=False)

 

-        return [put_at_start]

+        return [put_at_start, different_seeds]

 

-    def run(self, p, put_at_start):

+    def run(self, p, put_at_start, different_seeds):

         modules.processing.fix_seed(p)

 

         original_prompt = p.prompt[0] if type(p.prompt) == list else p.prompt

@@ -73,15 +74,17 @@ class Script(scripts.Script):
         print(f"Prompt matrix will create {len(all_prompts)} images using a total of {p.n_iter} batches.")

 

         p.prompt = all_prompts

-        p.seed = [p.seed for _ in all_prompts]

+        p.seed = [p.seed + (i if different_seeds else 0) for i in range(len(all_prompts))]

         p.prompt_for_display = original_prompt

         processed = process_images(p)

 

         grid = images.image_grid(processed.images, p.batch_size, rows=1 << ((len(prompt_matrix_parts) - 1) // 2))

         grid = images.draw_prompt_matrix(grid, p.width, p.height, prompt_matrix_parts)

         processed.images.insert(0, grid)

+        processed.index_of_first_image = 1

+        processed.infotexts.insert(0, processed.infotexts[0])

 

         if opts.grid_save:

-            images.save_image(processed.images[0], p.outpath_grids, "prompt_matrix", prompt=original_prompt, seed=processed.seed, grid=True, p=p)

+            images.save_image(processed.images[0], p.outpath_grids, "prompt_matrix", extension=opts.grid_format, prompt=original_prompt, seed=processed.seed, grid=True, p=p)

 

         return processed

diff --git a/scripts/prompts_from_file.py b/scripts/prompts_from_file.py
index 3388bc77..e8386ed2 100644
--- a/scripts/prompts_from_file.py
+++ b/scripts/prompts_from_file.py
@@ -9,6 +9,7 @@ import shlex
 import modules.scripts as scripts

 import gradio as gr

 

+from modules import sd_samplers

 from modules.processing import Processed, process_images

 from PIL import Image

 from modules.shared import opts, cmd_opts, state

@@ -44,6 +45,7 @@ prompt_tags = {
     "seed_resize_from_h": process_int_tag,

     "seed_resize_from_w": process_int_tag,

     "sampler_index": process_int_tag,

+    "sampler_name": process_string_tag,

     "batch_size": process_int_tag,

     "n_iter": process_int_tag,

     "steps": process_int_tag,

@@ -66,14 +68,28 @@ def cmdargs(line):
         arg = args[pos]

 

         assert arg.startswith("--"), f'must start with "--": {arg}'

+        assert pos+1 < len(args), f'missing argument for command line option {arg}'

+

         tag = arg[2:]

 

+        if tag == "prompt" or tag == "negative_prompt":

+            pos += 1

+            prompt = args[pos]

+            pos += 1

+            while pos < len(args) and not args[pos].startswith("--"):

+                prompt += " "

+                prompt += args[pos]

+                pos += 1

+            res[tag] = prompt

+            continue

+

+

         func = prompt_tags.get(tag, None)

         assert func, f'unknown commandline option: {arg}'

 

-        assert pos+1 < len(args), f'missing argument for command line option {arg}'

-

         val = args[pos+1]

+        if tag == "sampler_name":

+            val = sd_samplers.samplers_map.get(val.lower(), None)

 

         res[tag] = func(val)

 

@@ -124,7 +140,7 @@ class Script(scripts.Script):
                 try:

                     args = cmdargs(line)

                 except Exception:

-                    print(f"Error parsing line [line] as commandline:", file=sys.stderr)

+                    print(f"Error parsing line {line} as commandline:", file=sys.stderr)

                     print(traceback.format_exc(), file=sys.stderr)

                     args = {"prompt": line}

             else:

@@ -145,6 +161,8 @@ class Script(scripts.Script):
         state.job_count = job_count

 

         images = []

+        all_prompts = []

+        infotexts = []

         for n, args in enumerate(jobs):

             state.job = f"{state.job_no + 1} out of {state.job_count}"

 

@@ -157,5 +175,7 @@ class Script(scripts.Script):
             

             if checkbox_iterate:

                 p.seed = p.seed + (p.batch_size * p.n_iter)

+            all_prompts += proc.all_prompts

+            infotexts += proc.infotexts

 

-        return Processed(p, images, p.seed, "")

+        return Processed(p, images, p.seed, "", all_prompts=all_prompts, infotexts=infotexts)

diff --git a/scripts/sd_upscale.py b/scripts/sd_upscale.py
index 01074291..9739545c 100644
--- a/scripts/sd_upscale.py
+++ b/scripts/sd_upscale.py
@@ -17,13 +17,14 @@ class Script(scripts.Script):
         return is_img2img

 

     def ui(self, is_img2img):

-        info = gr.HTML("<p style=\"margin-bottom:0.75em\">Will upscale the image to twice the dimensions; use width and height sliders to set tile size</p>")

+        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)

+        scale_factor = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label='Scale Factor', value=2.0)

         upscaler_index = gr.Radio(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name, type="index")

 

-        return [info, overlap, upscaler_index]

+        return [info, overlap, upscaler_index, scale_factor]

 

-    def run(self, p, _, overlap, upscaler_index):

+    def run(self, p, _, overlap, upscaler_index, scale_factor):

         processing.fix_seed(p)

         upscaler = shared.sd_upscalers[upscaler_index]

 

@@ -34,9 +35,10 @@ class Script(scripts.Script):
         seed = p.seed

 

         init_img = p.init_images[0]

-        

-        if(upscaler.name != "None"): 

-            img = upscaler.scaler.upscale(init_img, 2, upscaler.data_path)

+        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

 

@@ -69,7 +71,7 @@ class Script(scripts.Script):
             work_results = []

             for i in range(batch_count):

                 p.batch_size = batch_size

-                p.init_images = work[i*batch_size:(i+1)*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)

diff --git a/scripts/xy_grid.py b/scripts/xy_grid.py
index 417ed0d4..78ff12c5 100644
--- a/scripts/xy_grid.py
+++ b/scripts/xy_grid.py
@@ -10,13 +10,16 @@ import numpy as np
 import modules.scripts as scripts

 import gradio as gr

 

-from modules import images

+from modules import images, paths, sd_samplers, processing

 from modules.hypernetworks import hypernetwork

-from modules.processing import process_images, Processed, get_correct_sampler, StableDiffusionProcessingTxt2Img

+from modules.processing import process_images, Processed, StableDiffusionProcessingTxt2Img

 from modules.shared import opts, cmd_opts, state

 import modules.shared as shared

 import modules.sd_samplers

 import modules.sd_models

+import modules.sd_vae

+import glob

+import os

 import re

 

 

@@ -58,29 +61,19 @@ def apply_order(p, x, xs):
         prompt_tmp += part

         prompt_tmp += x[idx]

     p.prompt = prompt_tmp + p.prompt

-    

-

-def build_samplers_dict(p):

-    samplers_dict = {}

-    for i, sampler in enumerate(get_correct_sampler(p)):

-        samplers_dict[sampler.name.lower()] = i

-        for alias in sampler.aliases:

-            samplers_dict[alias.lower()] = i

-    return samplers_dict

 

 

 def apply_sampler(p, x, xs):

-    sampler_index = build_samplers_dict(p).get(x.lower(), None)

-    if sampler_index is None:

+    sampler_name = sd_samplers.samplers_map.get(x.lower(), None)

+    if sampler_name is None:

         raise RuntimeError(f"Unknown sampler: {x}")

 

-    p.sampler_index = sampler_index

+    p.sampler_name = sampler_name

 

 

 def confirm_samplers(p, xs):

-    samplers_dict = build_samplers_dict(p)

     for x in xs:

-        if x.lower() not in samplers_dict.keys():

+        if x.lower() not in sd_samplers.samplers_map:

             raise RuntimeError(f"Unknown sampler: {x}")

 

 

@@ -124,6 +117,38 @@ def apply_clip_skip(p, x, xs):
     opts.data["CLIP_stop_at_last_layers"] = x

 

 

+def apply_upscale_latent_space(p, x, xs):

+    if x.lower().strip() != '0':

+        opts.data["use_scale_latent_for_hires_fix"] = True

+    else:

+        opts.data["use_scale_latent_for_hires_fix"] = False

+

+

+def find_vae(name: str):

+    if name.lower() in ['auto', 'none']:

+        return name

+    else:

+        vae_path = os.path.abspath(os.path.join(paths.models_path, 'VAE'))

+        found = glob.glob(os.path.join(vae_path, f'**/{name}.*pt'), recursive=True)

+        if found:

+            return found[0]

+        else:

+            return 'auto'

+

+

+def apply_vae(p, x, xs):

+    if x.lower().strip() == 'none':

+        modules.sd_vae.reload_vae_weights(shared.sd_model, vae_file='None')

+    else:

+        found = find_vae(x)

+        if found:

+            v = modules.sd_vae.reload_vae_weights(shared.sd_model, vae_file=found)

+

+

+def apply_styles(p: StableDiffusionProcessingTxt2Img, x: str, _):

+    p.styles = x.split(',')

+

+

 def format_value_add_label(p, opt, x):

     if type(x) == float:

         x = round(x, 8)

@@ -177,7 +202,10 @@ axis_options = [
     AxisOption("Eta", float, apply_field("eta"), format_value_add_label, None),

     AxisOption("Clip skip", int, apply_clip_skip, format_value_add_label, None),

     AxisOption("Denoising", float, apply_field("denoising_strength"), format_value_add_label, None),

+    AxisOption("Hires upscaler", str, apply_field("hr_upscaler"), format_value_add_label, None),

     AxisOption("Cond. Image Mask Weight", float, apply_field("inpainting_mask_weight"), format_value_add_label, None),

+    AxisOption("VAE", str, apply_vae, format_value_add_label, None),

+    AxisOption("Styles", str, apply_styles, format_value_add_label, None),

 ]

 

 

@@ -239,9 +267,11 @@ class SharedSettingsStackHelper(object):
         self.CLIP_stop_at_last_layers = opts.CLIP_stop_at_last_layers

         self.hypernetwork = opts.sd_hypernetwork

         self.model = shared.sd_model

+        self.vae = opts.sd_vae

   

     def __exit__(self, exc_type, exc_value, tb):

         modules.sd_models.reload_model_weights(self.model)

+        modules.sd_vae.reload_vae_weights(self.model, vae_file=find_vae(self.vae))

 

         hypernetwork.load_hypernetwork(self.hypernetwork)

         hypernetwork.apply_strength()

@@ -255,6 +285,7 @@ re_range_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d
 re_range_count = re.compile(r"\s*([+-]?\s*\d+)\s*-\s*([+-]?\s*\d+)(?:\s*\[(\d+)\s*\])?\s*")

 re_range_count_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d*)?)(?:\s*\[(\d+(?:.\d*)?)\s*\])?\s*")

 

+

 class Script(scripts.Script):

     def title(self):

         return "X/Y plot"

@@ -351,7 +382,7 @@ class Script(scripts.Script):
         ys = process_axis(y_opt, y_values)

 

         def fix_axis_seeds(axis_opt, axis_list):

-            if axis_opt.label in ['Seed','Var. seed']:

+            if axis_opt.label in ['Seed', 'Var. seed']:

                 return [int(random.randrange(4294967294)) if val is None or val == '' or val == -1 else val for val in axis_list]

             else:

                 return axis_list

@@ -373,12 +404,33 @@ class Script(scripts.Script):
         print(f"X/Y plot will create {len(xs) * len(ys) * p.n_iter} images on a {len(xs)}x{len(ys)} grid. (Total steps to process: {total_steps * p.n_iter})")

         shared.total_tqdm.updateTotal(total_steps * p.n_iter)

 

+        grid_infotext = [None]

+

         def cell(x, y):

             pc = copy(p)

             x_opt.apply(pc, x, xs)

             y_opt.apply(pc, y, ys)

 

-            return process_images(pc)

+            res = process_images(pc)

+

+            if grid_infotext[0] is None:

+                pc.extra_generation_params = copy(pc.extra_generation_params)

+

+                if x_opt.label != 'Nothing':

+                    pc.extra_generation_params["X Type"] = x_opt.label

+                    pc.extra_generation_params["X Values"] = x_values

+                    if x_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:

+                        pc.extra_generation_params["Fixed X Values"] = ", ".join([str(x) for x in xs])

+

+                if y_opt.label != 'Nothing':

+                    pc.extra_generation_params["Y Type"] = y_opt.label

+                    pc.extra_generation_params["Y Values"] = y_values

+                    if y_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:

+                        pc.extra_generation_params["Fixed Y Values"] = ", ".join([str(y) for y in ys])

+

+                grid_infotext[0] = processing.create_infotext(pc, pc.all_prompts, pc.all_seeds, pc.all_subseeds)

+

+            return res

 

         with SharedSettingsStackHelper():

             processed = draw_xy_grid(

@@ -393,6 +445,6 @@ class Script(scripts.Script):
             )

 

         if opts.grid_save:

-            images.save_image(processed.images[0], p.outpath_grids, "xy_grid", prompt=p.prompt, seed=processed.seed, grid=True, p=p)

+            images.save_image(processed.images[0], p.outpath_grids, "xy_grid", info=grid_infotext[0], extension=opts.grid_format, prompt=p.prompt, seed=processed.seed, grid=True, p=p)

 

         return processed