Merge remote-tracking branch 'upstream/dev' into Extended-Merging

modules/images.py

@@ -18,10 +18,8 @@ import piexif.helper
 from PIL import Image, ImageFont, ImageDraw, PngImagePlugin, ExifTags
 from modules import sd_samplers, shared, script_callbacks, errors, paths
 
-LANCZOS = (Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS)
+
 debug = errors.log.info if os.environ.get('SD_PATH_DEBUG', None) is not None else lambda *args, **kwargs: None
-
-
 try:
     from pi_heif import register_heif_opener
     register_heif_opener()
@@ -143,8 +141,8 @@ def draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin=0, tit
         for line in lines:
             font = initial_fnt
             fontsize = initial_fontsize
-            while drawing.multiline_textsize(line.text, font=font)[0] > line.allowed_width and fontsize > 0:
-                fontsize -= 2
+            while drawing.multiline_textbbox((0,0), text=line.text, font=font)[0] > line.allowed_width and fontsize > 0:
+                fontsize -= 1
                 font = get_font(fontsize)
             drawing.multiline_text((draw_x, draw_y + line.size[1] / 2), line.text, font=font, fill=shared.opts.font_color if line.is_active else color_inactive, anchor="mm", align="center")
             if not line.is_active:
@@ -230,7 +228,7 @@ def resize_image(resize_mode, im, width, height, upscaler_name=None, output_type
 
     def resize(im, w, h):
         if upscaler_name is None or upscaler_name == "None" or im.mode == 'L':
-            return im.resize((w, h), resample=LANCZOS)
+            return im.resize((w, h), resample=Image.Resampling.LANCZOS)
         scale = max(w / im.width, h / im.height)
         if scale > 1.0:
             upscalers = [x for x in shared.sd_upscalers if x.name == upscaler_name]
@@ -241,7 +239,7 @@ def resize_image(resize_mode, im, width, height, upscaler_name=None, output_type
                 upscaler = upscalers[0]
             im = upscaler.scaler.upscale(im, scale, upscaler.data_path)
         if im.width != w or im.height != h:
-            im = im.resize((w, h), resample=LANCZOS)
+            im = im.resize((w, h), resample=Image.Resampling.LANCZOS)
         return im
 
     if resize_mode == 0:

modules/processing_diffusers.py

@@ -42,16 +42,14 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
         if latent_upscaler is not None:
             latents = torch.nn.functional.interpolate(latents, size=(p.hr_upscale_to_y // 8, p.hr_upscale_to_x // 8), mode=latent_upscaler["mode"], antialias=latent_upscaler["antialias"])
         first_pass_images = vae_decode(latents=latents, model=shared.sd_model, full_quality=p.full_quality, output_type='pil')
-        p.init_images = []
+        resized_images = []
         for img in first_pass_images:
             if latent_upscaler is None:
-                init_image = images.resize_image(1, img, p.hr_upscale_to_x, p.hr_upscale_to_y, upscaler_name=p.hr_upscaler)
+                resized_image = images.resize_image(1, img, p.hr_upscale_to_x, p.hr_upscale_to_y, upscaler_name=p.hr_upscaler)
             else:
-                init_image = img
-            # if is_refiner_enabled:
-            #    init_image = vae_encode(init_image, model=shared.sd_model, full_quality=p.full_quality)
-            p.init_images.append(init_image)
-        return p.init_images
+                resized_image = img
+            resized_images.append(resized_image)
+        return resized_images
 
     def save_intermediate(latents, suffix):
         for i in range(len(latents)):
@@ -470,7 +468,6 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
         desc='Base',
     )
     shared.state.sampling_steps = base_args['num_inference_steps']
-    p.extra_generation_params['CFG rescale'] = p.diffusers_guidance_rescale
     p.extra_generation_params["Sampler Eta"] = shared.opts.scheduler_eta if shared.opts.scheduler_eta is not None and shared.opts.scheduler_eta > 0 and shared.opts.scheduler_eta < 1 else None
     try:
         output = shared.sd_model(**base_args) # pylint: disable=not-callable
@@ -490,7 +487,7 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
         return results
 
     # optional hires pass
-    if p.enable_hr and p.hr_upscaler != 'None' and p.denoising_strength > 0 and len(getattr(p, 'init_images', [])) == 0:
+    if p.enable_hr and getattr(p, 'hr_upscaler', 'None') != 'None' and len(getattr(p, 'init_images', [])) == 0:
         p.is_hr_pass = True
     latent_scale_mode = shared.latent_upscale_modes.get(p.hr_upscaler, None) if (hasattr(p, "hr_upscaler") and p.hr_upscaler is not None) else shared.latent_upscale_modes.get(shared.latent_upscale_default_mode, "None")
     if p.is_hr_pass:
@@ -502,7 +499,7 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
                 save_intermediate(latents=output.images, suffix="-before-hires")
             shared.state.job = 'upscale'
             output.images = hires_resize(latents=output.images)
-            if latent_scale_mode is not None or p.hr_force:
+            if (latent_scale_mode is not None or p.hr_force) and p.denoising_strength > 0:
                 p.ops.append('hires')
                 shared.sd_model = sd_models.set_diffuser_pipe(shared.sd_model, sd_models.DiffusersTaskType.IMAGE_2_IMAGE)
                 recompile_model(hires=True)
@@ -519,7 +516,7 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
                     guidance_rescale=p.diffusers_guidance_rescale,
                     output_type='latent' if hasattr(shared.sd_model, 'vae') else 'np',
                     clip_skip=p.clip_skip,
-                    image=p.init_images,
+                    image=output.images,
                     strength=p.denoising_strength,
                     desc='Hires',
                 )

modules/sd_models.py

@@ -595,51 +595,52 @@ def change_backend():
     refresh_vae_list()
 
 
-def detect_pipeline(f: str, op: str = 'model'):
+def detect_pipeline(f: str, op: str = 'model', warning=True):
     if not f.endswith('.safetensors'):
         return None, None
     guess = shared.opts.diffusers_pipeline
+    warn = shared.log.warning if warning else lambda *args, **kwargs: None
     if guess == 'Autodetect':
         try:
             size = round(os.path.getsize(f) / 1024 / 1024)
             if size < 128:
-                shared.log.warning(f'Model size smaller than expected: {f} size={size} MB')
+                warn(f'Model size smaller than expected: {f} size={size} MB')
             elif (size >= 316 and size <= 324) or (size >= 156 and size <= 164): # 320 or 160
-                shared.log.warning(f'Model detected as VAE model, but attempting to load as model: {op}={f} size={size} MB')
+                warn(f'Model detected as VAE model, but attempting to load as model: {op}={f} size={size} MB')
                 guess = 'VAE'
             elif size >= 5351 and size <= 5359: # 5353
                 guess = 'Stable Diffusion' # SD v2
             elif size >= 5791 and size <= 5799: # 5795
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as SD-XL refiner model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as SD-XL refiner model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 if op == 'model':
-                    shared.log.warning(f'Model detected as SD-XL refiner model, but attempting to load a base model: {op}={f} size={size} MB')
+                    warn(f'Model detected as SD-XL refiner model, but attempting to load a base model: {op}={f} size={size} MB')
                 guess = 'Stable Diffusion XL'
             elif (size >= 6611 and size <= 6619) or (size >= 6771 and size <= 6779): # 6617, HassakuXL is 6776
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as SD-XL base model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as SD-XL base model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 guess = 'Stable Diffusion XL'
             elif size >= 3361 and size <= 3369: # 3368
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as SD upscale model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as SD upscale model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 guess = 'Stable Diffusion Upscale'
             elif size >= 4891 and size <= 4899: # 4897
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as SD XL inpaint model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as SD XL inpaint model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 guess = 'Stable Diffusion XL Inpaint'
             elif size >= 9791 and size <= 9799: # 9794
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as SD XL instruct pix2pix model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as SD XL instruct pix2pix model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 guess = 'Stable Diffusion XL Instruct'
             else:
                 guess = 'Stable Diffusion'
             if 'LCM_' in f or 'LCM-' in f:
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as LCM model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as LCM model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 guess = 'Latent Consistency Model'
             if 'PixArt' in f:
                 if shared.backend == shared.Backend.ORIGINAL:
-                    shared.log.warning(f'Model detected as PixArt Alpha model, but attempting to load using backend=original: {op}={f} size={size} MB')
+                    warn(f'Model detected as PixArt Alpha model, but attempting to load using backend=original: {op}={f} size={size} MB')
                 guess = 'PixArt Alpha'
             pipeline = shared_items.get_pipelines().get(guess, None)
             shared.log.info(f'Autodetect: {op}="{guess}" class={pipeline.__name__} file="{f}" size={size}MB')
@@ -1087,6 +1088,7 @@ def load_model(checkpoint_info=None, already_loaded_state_dict=None, timer=None,
     shared.log.debug(f"Model created from config: {checkpoint_config}")
     sd_model.used_config = checkpoint_config
     sd_model.has_accelerate = False
+    sd_model.is_sdxl = False # a1111 compatibility item
     timer.record("create")
     ok = load_model_weights(sd_model, checkpoint_info, state_dict, timer)
     if not ok:

modules/sd_models_compile.py

@@ -76,6 +76,9 @@ def compile_stablefast(sd_model):
     warnings.filterwarnings("ignore", category=torch.jit.TracerWarning)
     config.enable_cuda_graph = shared.opts.cuda_compile_fullgraph
     config.enable_jit_freeze = shared.opts.diffusers_eval
+    config.memory_format = torch.channels_last if shared.opts.opt_channelslast else torch.contiguous_format
+    # config.enable_cnn_optimization
+    # config.prefer_lowp_gemm
     try:
         t0 = time.time()
         sd_model = sf.compile(sd_model, config)

modules/shared.py

@@ -307,7 +307,7 @@ options_templates.update(options_section(('cuda', "Compute Settings"), {
     "cuda_compile_vae": OptionInfo(True if cmd_opts.use_openvino else False, "Compile VAE"),
     "cuda_compile_upscaler": OptionInfo(True if cmd_opts.use_openvino else False, "Compile upscaler"),
     "cuda_compile_backend": OptionInfo("openvino_fx" if cmd_opts.use_openvino else "none", "Model compile backend", gr.Radio, {"choices": ['none', 'inductor', 'cudagraphs', 'aot_ts_nvfuser', 'hidet', 'ipex', 'openvino_fx', 'stable-fast']}),
-    "cuda_compile_mode": OptionInfo("default", "Model compile mode", gr.Radio, {"choices": ['default', 'reduce-overhead', 'max-autotune']}),
+    "cuda_compile_mode": OptionInfo("default", "Model compile mode", gr.Radio, {"choices": ['default', 'reduce-overhead', 'max-autotune', 'max-autotune-no-cudagraphs']}),
     "cuda_compile_fullgraph": OptionInfo(False, "Model compile fullgraph"),
     "cuda_compile_precompile": OptionInfo(False if cmd_opts.use_openvino else True, "Model compile precompile"),
     "cuda_compile_verbose": OptionInfo(False, "Model compile verbose mode"),

modules/ui_common.py

@@ -6,7 +6,7 @@ import platform
 import subprocess
 import gradio as gr
 from modules import call_queue, shared
-from modules.generation_parameters_copypaste import image_from_url_text
+from modules.generation_parameters_copypaste import image_from_url_text, parse_generation_parameters
 import modules.ui_symbols as symbols
 import modules.images
 import modules.script_callbacks
@@ -34,12 +34,19 @@ def plaintext_to_html(text):
 
 
 def infotext_to_html(text):
-    res = '<p class="html_info">Prompt: ' + html.escape(text or '').replace('\n', '<br>') + '</p>'
-    sections = res.split('Steps:') # before and after prompt+negprompt'
-    if len(sections) > 1:
-        res = sections[0] + '<br>Steps: ' + sections[1].strip().replace(', ', ' | ')
-    res = res.replace('<br><br>', '<br>')
-    return res
+    res = parse_generation_parameters(text)
+    prompt = res.get('Prompt', None)
+    negative = res.get('Negative prompt', None)
+    res.pop('Prompt', None)
+    res.pop('Negative prompt', None)
+    params = [f'{k}: {v}' for k, v in res.items() if v is not None]
+    params = '| '.join(params)
+    code = f'''
+        <p><b>Prompt:</b> {prompt}</p>
+        <p><b>Negative:</b> {negative}</p>
+        <p><b>Parameters:</b> {params}</p>
+        '''
+    return code
 
 
 def delete_files(js_data, images, _html_info, index):

modules/upscaler.py

@@ -228,7 +228,7 @@ def compile_upscaler(model, name=""):
 
             if modules.shared.opts.cuda_compile_backend == "openvino_fx":
                 from modules.intel.openvino import openvino_fx # pylint: disable=unused-import
-                from modules.sd_models_compile import CompiledModelState
+                from modules.sd_models_compile import CompiledModelState # pylint: disable=unused-import
                 torch._dynamo.eval_frame.check_if_dynamo_supported = lambda: True # pylint: disable=protected-access
 
             log_level = logging.WARNING if modules.shared.opts.cuda_compile_verbose else logging.CRITICAL # pylint: disable=protected-access