Public/automatic
1
0
Fork 0
mirror of https://github.com/vladmandic/automatic synced 2026-09-19 09:14:35 +02:00
Code Issues Packages Projects Releases Wiki Activity

unified logger

Browse Source
This commit is contained in:
Vladimir Mandic
2026-02-19 09:46:42 +01:00
parent bfe014f5da
commit a3074baf8b
315 changed files with 2507 additions and 2116 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/animatediff.py
+17 -16
View File
@@ -3,6 +3,7 @@ import gradio as gr
import diffusers
from safetensors.torch import load_file
from modules import scripts_manager, processing, shared, devices, sd_models
from modules import logger
# config
@@ -49,18 +50,18 @@ def set_adapter(adapter_name: str = 'None'):
motion_adapter = None
loaded_adapter = None
if orig_pipe is not None:
shared.log.debug(f'AnimateDiff restore pipeline: adapter="{loaded_adapter}"')
logger.log.debug(f'AnimateDiff restore pipeline: adapter="{loaded_adapter}"')
shared.sd_model = orig_pipe
orig_pipe = None
return
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl' and not (shared.sd_model.__class__.__name__ == 'AnimateDiffPipeline' or shared.sd_model.__class__.__name__ == 'AnimateDiffSDXLPipeline'):
shared.log.warning(f'AnimateDiff: unsupported model type: {shared.sd_model.__class__.__name__}')
logger.log.warning(f'AnimateDiff: unsupported model type: {shared.sd_model.__class__.__name__}')
return
if motion_adapter is not None and loaded_adapter == adapter_name and (shared.sd_model.__class__.__name__ == 'AnimateDiffPipeline' or shared.sd_model.__class__.__name__ == 'AnimateDiffSDXLPipeline'):
shared.log.debug(f'AnimateDiff: adapter="{adapter_name}" cached')
logger.log.debug(f'AnimateDiff: adapter="{adapter_name}" cached')
return
if getattr(shared.sd_model, 'image_encoder', None) is not None:
shared.log.debug('AnimateDiff: unloading IP adapter')
logger.log.debug('AnimateDiff: unloading IP adapter')
# shared.sd_model.image_encoder = None
# shared.sd_model.unet.set_default_attn_processor()
shared.sd_model.unet.config.encoder_hid_dim_type = None
@@ -69,7 +70,7 @@ def set_adapter(adapter_name: str = 'None'):
folder, filename = os.path.split(adapter_name)
adapter_name = hf.hf_hub_download(repo_id=folder, filename=filename, cache_dir=shared.opts.diffusers_dir)
try:
shared.log.info(f'AnimateDiff load: adapter="{adapter_name}"')
logger.log.info(f'AnimateDiff load: adapter="{adapter_name}"')
motion_adapter = None
if adapter_name.endswith('.safetensors'):
motion_adapter = diffusers.MotionAdapter().to(shared.device, devices.dtype)
@@ -84,7 +85,7 @@ def set_adapter(adapter_name: str = 'None'):
new_pipe = None
if 'Model' in shared.opts.sdnq_quantize_weights:
shared.log.debug(f'AnimateDiff: sdnq={shared.opts.sdnq_quantize_weights} reloading model weights')
logger.log.debug(f'AnimateDiff: sdnq={shared.opts.sdnq_quantize_weights} reloading model weights')
prev_opts = shared.opts.sdnq_quantize_weights
shared.opts.sdnq_quantize_weights = []
sd_models.reload_model_weights(force=True)
@@ -118,7 +119,7 @@ def set_adapter(adapter_name: str = 'None'):
if new_pipe is None:
motion_adapter = None
loaded_adapter = None
shared.log.error(f'AnimateDiff load error: adapter="{adapter_name}"')
logger.log.error(f'AnimateDiff load error: adapter="{adapter_name}"')
return
orig_pipe = shared.sd_model
shared.sd_model = new_pipe
@@ -126,11 +127,11 @@ def set_adapter(adapter_name: str = 'None'):
sd_models.copy_diffuser_options(new_pipe, orig_pipe)
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
sd_models.move_model(shared.sd_model.unet, devices.device) # move pipeline to device
shared.log.debug(f'AnimateDiff: adapter="{loaded_adapter}"')
logger.log.debug(f'AnimateDiff: adapter="{loaded_adapter}"')
except Exception as e:
motion_adapter = None
loaded_adapter = None
shared.log.error(f'AnimateDiff load error: adapter="{adapter_name}" {e}')
logger.log.error(f'AnimateDiff load error: adapter="{adapter_name}" {e}')
from modules import errors
errors.display('e', 'AnimateDiff')
@@ -142,7 +143,7 @@ def set_scheduler(p, model, override: bool = False):
shared.sd_model.scheduler = diffusers.LCMScheduler.from_config(shared.sd_model.scheduler.config)
else:
shared.sd_model.scheduler = diffusers.DDIMScheduler.from_config(shared.sd_model.scheduler.config)
shared.log.debug(f'AnimateDiff: scheduler={shared.sd_model.scheduler.__class__.__name__}')
logger.log.debug(f'AnimateDiff: scheduler={shared.sd_model.scheduler.__class__.__name__}')
def set_prompt(p):
@@ -158,14 +159,14 @@ def set_prompt(p):
prompt[int(k.strip())] = v.strip()
except Exception:
prompt = p.prompt
shared.log.debug(f'AnimateDiff prompt: {prompt}')
logger.log.debug(f'AnimateDiff prompt: {prompt}')
p.task_args['prompt'] = prompt
p.task_args['negative_prompt'] = p.negative_prompt
def set_lora(p, lora, strength):
if lora is not None and lora != 'None':
shared.log.debug(f'AnimateDiff: lora="{lora}" strength={strength}')
logger.log.debug(f'AnimateDiff: lora="{lora}" strength={strength}')
if lora.endswith('.safetensors'):
fn = os.path.basename(lora)
lora = lora.replace(f'/{fn}', '')
@@ -178,7 +179,7 @@ def set_lora(p, lora, strength):
def set_free_init(method, iters, order, spatial, temporal):
if hasattr(shared.sd_model, 'enable_free_init') and method != 'none':
shared.log.debug(f'AnimateDiff free init: method={method} iters={iters} order={order} spatial={spatial} temporal={temporal}')
logger.log.debug(f'AnimateDiff free init: method={method} iters={iters} order={order} spatial={spatial} temporal={temporal}')
shared.sd_model.enable_free_init(
num_iters=iters,
use_fast_sampling=False,
@@ -193,7 +194,7 @@ def set_free_noise(frames):
context_length = 16
context_stride = 4
if frames >= context_length and hasattr(shared.sd_model, 'enable_free_noise'):
shared.log.debug(f'AnimateDiff free noise: frames={frames} context={context_length} stride={context_stride}')
logger.log.debug(f'AnimateDiff free noise: frames={frames} context={context_length} stride={context_stride}')
shared.sd_model.enable_free_noise(context_length=context_length, context_stride=context_stride)
@@ -251,7 +252,7 @@ class Script(scripts_manager.Script):
p.task_args['num_frames'] = frames
p.task_args['num_inference_steps'] = p.steps
p.task_args['output_type'] = 'np'
shared.log.debug(f'AnimateDiff args: {p.task_args}')
logger.log.debug(f'AnimateDiff args: {p.task_args}')
set_prompt(p)
orig_prompt_attention = shared.opts.prompt_attention
shared.opts.data['prompt_attention'] = 'fixed'
@@ -264,5 +265,5 @@ class Script(scripts_manager.Script):
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, adapter_index, frames, lora_index, strength, latent_mode, video_type, duration, gif_loop, mp4_pad, mp4_interpolate, override_scheduler, fi_method, fi_iters, fi_order, fi_spatial, fi_temporal): # pylint: disable=arguments-differ, unused-argument
from modules.images import save_video
if video_type != 'None':
shared.log.debug(f'AnimateDiff video: type={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
logger.log.debug(f'AnimateDiff video: type={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
save_video(p, filename=None, images=processed.images, video_type=video_type, duration=duration, loop=gif_loop, pad=mp4_pad, interpolate=mp4_interpolate)
scripts/apg.py
+3 -2
View File
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
from modules import logger
registered = False
@@ -53,7 +54,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, eta = 0.0, momentum = 0.0, threshold = 0.0): # pylint: disable=arguments-differ
supported_model_list = ['sd', 'sdxl', 'sc']
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'APG: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'APG: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
from modules import apg
apg.eta = getattr(p, 'apg_eta', eta) # use values set by xyz grid or via ui
@@ -70,7 +71,7 @@ class Script(scripts_manager.Script):
elif shared.sd_model_type == "sc":
self.orig_pipe = shared.sd_model.prior_pipe
shared.sd_model.prior_pipe = sd_models.switch_pipe(apg.StableCascadePriorPipelineAPG, shared.sd_model.prior_pipe)
shared.log.info(f'APG apply: guidance={p.cfg_scale} momentum={apg.momentum} eta={apg.eta} threshold={apg.threshold} class={shared.sd_model.__class__.__name__}')
logger.log.info(f'APG apply: guidance={p.cfg_scale} momentum={apg.momentum} eta={apg.eta} threshold={apg.threshold} class={shared.sd_model.__class__.__name__}')
p.extra_generation_params["APG"] = f'ETA={apg.eta} Momentum={apg.momentum} Threshold={apg.threshold}'
# processed = processing.process_images(p)
return None
scripts/automatic_color_inpaint.py
+3 -2
View File
@@ -2,6 +2,7 @@ import gradio as gr
from PIL import Image
import numpy as np
from modules import shared, scripts_manager, processing, masking
from modules import logger
"""
Automatic Color Inpaint Script for SD.NEXT - SD & SDXL Support
@@ -89,7 +90,7 @@ class Script(scripts_manager.Script):
# Run pipeline
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ
if shared.sd_model_type not in supported_models:
shared.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
logger.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
return None
if not hasattr(p, 'init_images') or p.init_images is None or len(p.init_images) == 0:
return None
@@ -98,7 +99,7 @@ class Script(scripts_manager.Script):
# Convert hex color to RGB tuple (0-255)
color_to_mask_rgb = tuple(int(color_to_mask_hex[i:i+2], 16) for i in (1, 3, 5))
shared.log.debug(f'ACI: rgb={color_to_mask_rgb} tolerance={mask_tolerance} dilate={mask_dilate} erode={mask_erode} blur={mask_blur} denoise={inpaint_denoising_strength}')
logger.log.debug(f'ACI: rgb={color_to_mask_rgb} tolerance={mask_tolerance} dilate={mask_dilate} erode={mask_erode} blur={mask_blur} denoise={inpaint_denoising_strength}')
# Create Color Mask using vectorized operations
init_image = p.init_images[0].convert("RGB")
scripts/blipdiffusion.py
+4 -3
View File
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
from modules import logger
class Script(scripts_manager.Script):
@@ -23,7 +24,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, source_subject, target_subject, prompt_strength): # pylint: disable=arguments-differ, unused-argument
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if c != 'BlipDiffusionPipeline':
shared.log.error(f'BLIP: model selected={c} required=BLIPDiffusion')
logger.log.error(f'BLIP: model selected={c} required=BLIPDiffusion')
return None
if hasattr(p, 'init_images') and len(p.init_images) > 0:
p.task_args['reference_image'] = p.init_images[0]
@@ -33,10 +34,10 @@ class Script(scripts_manager.Script):
p.task_args['source_subject_category'] = [source_subject]
p.task_args['target_subject_category'] = [target_subject]
p.task_args['output_type'] = 'pil'
shared.log.debug(f'BLIP Diffusion: args={p.task_args}')
logger.log.debug(f'BLIP Diffusion: args={p.task_args}')
shared.sd_model = sd_models.set_diffuser_pipe(shared.sd_model, sd_models.DiffusersTaskType.IMAGE_2_IMAGE)
processed = processing.process_images(p)
return processed
else:
shared.log.error('BLIP: no init_images')
logger.log.error('BLIP: no init_images')
return None
scripts/consistory_ext.py
+16 -15
View File
@@ -13,6 +13,7 @@ import time
import gradio as gr
import diffusers
from modules import scripts_manager, devices, errors, processing, shared, sd_models, sd_samplers
from modules import logger
class Script(scripts_manager.Script):
@@ -30,7 +31,7 @@ class Script(scripts_manager.Script):
def reset(self):
self.anchor_cache_first_stage = None
self.anchor_cache_second_stage = None
shared.log.debug('ConsiStory reset anchors')
logger.log.debug('ConsiStory reset anchors')
def ui(self, _is_img2img): # ui elements
with gr.Row():
@@ -68,7 +69,7 @@ class Script(scripts_manager.Script):
diffusers.models.embeddings.PositionNet = diffusers.models.embeddings.GLIGENTextBoundingboxProjection # patch as renamed in https://github.com/huggingface/diffusers/pull/6244/files
import scripts.consistory as cs
if shared.sd_model.__class__.__name__ != 'ConsistoryExtendAttnSDXLPipeline':
shared.log.debug('ConsiStory init')
logger.log.debug('ConsiStory init')
t0 = time.time()
state_dict = shared.sd_model.unet.state_dict() # save existing unet
shared.sd_model = sd_models.switch_pipe(cs.ConsistoryExtendAttnSDXLPipeline, shared.sd_model)
@@ -80,7 +81,7 @@ class Script(scripts_manager.Script):
sd_models.move_model(shared.sd_model, devices.device)
sd_models.move_model(shared.sd_model.unet, devices.device)
t1 = time.time()
shared.log.debug(f'ConsiStory load: model={shared.sd_model.__class__.__name__} time={t1-t0:.2f}')
logger.log.debug(f'ConsiStory load: model={shared.sd_model.__class__.__name__} time={t1-t0:.2f}')
devices.torch_gc(force=True)
def set_args(self, p: processing.StableDiffusionProcessing, *args):
@@ -95,7 +96,7 @@ class Script(scripts_manager.Script):
freeu_preset = [float(f.strip()) for f in freeu_preset.split(',')]
except Exception:
freeu_preset = []
shared.log.warning(f'ConsiStory: freeu="{freeu_preset}" invalid')
logger.log.warning(f'ConsiStory: freeu="{freeu_preset}" invalid')
if len(freeu) == 4:
shared.sd_model.enable_freeu(s1=freeu[0], s2=freeu[0], b1=freeu[0], b2=freeu[0])
steps = 50 if steps else p.steps
@@ -106,14 +107,14 @@ class Script(scripts_manager.Script):
alpha = (int(alpha[0]), int(alpha[1]), float(alpha[2]))
except Exception:
alpha=(10, 20, 0.8)
shared.log.warning(f'ConsiStory: alpha="{alpha}" invalid')
logger.log.warning(f'ConsiStory: alpha="{alpha}" invalid')
else:
alpha=(10, 20, 0.8)
seed = p.seed
concepts = [c.strip() for c in concepts.split(',') if c.strip() != '']
for c in concepts:
if c not in subject:
shared.log.warning(f'ConsiStory: concept="{c}" not in subject')
logger.log.warning(f'ConsiStory: concept="{c}" not in subject')
subject = f'{subject} {c}'
settings = [p.strip() for p in prompts.split('\n') if p.strip() != '']
anchors = [f'{subject} {p}' for p in settings]
@@ -124,16 +125,16 @@ class Script(scripts_manager.Script):
for i, prompt in enumerate(prompts):
if subject not in prompt:
prompts[i] = f'{subject} {prompt}'
shared.log.debug(f'ConsiStory args: sampler={shared.sd_model.scheduler.__class__.__name__} steps={steps} sdsa={sdsa} queries={queries} same={same} dropout={dropout} freeu={freeu_preset if freeu else None} alpha={alpha if injection else None}')
logger.log.debug(f'ConsiStory args: sampler={shared.sd_model.scheduler.__class__.__name__} steps={steps} sdsa={sdsa} queries={queries} same={same} dropout={dropout} freeu={freeu_preset if freeu else None} alpha={alpha if injection else None}')
return concepts, anchors, prompts, alpha, steps, seed
def create_anchors(self, anchors, concepts, seed, steps, dropout, same, queries, sdsa, injection, alpha):
import scripts.consistory as cs
t0 = time.time()
if len(anchors) == 0:
shared.log.warning('ConsiStory: no anchors')
logger.log.warning('ConsiStory: no anchors')
return []
shared.log.debug(f'ConsiStory anchors: concepts={concepts} anchors={anchors}')
logger.log.debug(f'ConsiStory anchors: concepts={concepts} anchors={anchors}')
with devices.inference_context():
try:
images, self.anchor_cache_first_stage, self.anchor_cache_second_stage = cs.run_anchor_generation(
@@ -150,19 +151,19 @@ class Script(scripts_manager.Script):
perform_injection=injection,
)
except Exception as e:
shared.log.error(f'ConsiStory: {e}')
logger.log.error(f'ConsiStory: {e}')
errors.display(e, 'ConsiStory')
images = []
devices.torch_gc()
t1 = time.time()
shared.log.debug(f'ConsiStory anchors: images={len(images)} time={t1-t0:.2f}')
logger.log.debug(f'ConsiStory anchors: images={len(images)} time={t1-t0:.2f}')
return images
def create_extra(self, prompt, concepts, seed, steps, dropout, same, queries, sdsa, injection, alpha):
import scripts.consistory as cs
t0 = time.time()
images = []
shared.log.debug(f'ConsiStory extra: concepts={concepts} prompt="{prompt}"')
logger.log.debug(f'ConsiStory extra: concepts={concepts} prompt="{prompt}"')
with devices.inference_context():
try:
images = cs.run_extra_generation(
@@ -181,18 +182,18 @@ class Script(scripts_manager.Script):
perform_injection=injection,
)
except Exception as e:
shared.log.error(f'ConsiStory: {e}')
logger.log.error(f'ConsiStory: {e}')
errors.display(e, 'ConsiStory')
images = []
devices.torch_gc()
t1 = time.time()
shared.log.debug(f'ConsiStory extra: images={len(images)} time={t1-t0:.2f}')
logger.log.debug(f'ConsiStory extra: images={len(images)} time={t1-t0:.2f}')
return images
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if shared.sd_model_type not in supported_model_list and shared.sd_model.__class__.__name__ != 'ConsistoryExtendAttnSDXLPipeline':
shared.log.warning(f'ConsiStory: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'ConsiStory: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
subject, concepts, prompts, dropout, sampler, steps, same, queries, sdsa, freeu, _freeu_preset, alpha, injection = args # pylint: disable=unused-variable
scripts/ctrlx_ext.py
+5 -4
View File
@@ -3,6 +3,7 @@
import gradio as gr
from diffusers import StableDiffusionXLPipeline
from modules import shared, scripts_manager, processing, processing_helpers, sd_models, devices
from modules import logger
class Script(scripts_manager.Script):
@@ -40,7 +41,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, struct_prompt, struct_strength, struct_guidance, struct_image, appear_prompt, appear_strength, appear_guidance, appear_image): # pylint: disable=arguments-differ
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if shared.sd_model_type != 'sdxl':
shared.log.warning(f'Ctrl-X: pipeline={c} required=StableDiffusionXLPipeline')
logger.log.warning(f'Ctrl-X: pipeline={c} required=StableDiffusionXLPipeline')
return None
import yaml
@@ -55,7 +56,7 @@ class Script(scripts_manager.Script):
# calculate ctrx+x schedule
if p.sampler_name not in ['DDIM', 'Euler', 'Euler a', 'DPM++ 1S', 'DDPM', 'Euler SGM', 'LCM', 'TCD']:
shared.log.warning(f'Ctrl-X: sampler={p.sampler_name} override="Euler a" supported=[Euler, Euler a, Euler SGM, DDIM, DDPM, , LCM, TCD]')
logger.log.warning(f'Ctrl-X: sampler={p.sampler_name} override="Euler a" supported=[Euler, Euler a, Euler SGM, DDIM, DDPM, , LCM, TCD]')
p.sampler_name = 'Euler a'
processing_helpers.update_sampler(p, shared.sd_model)
shared.sd_model.scheduler.set_timesteps(p.steps, device=devices.device)
@@ -85,8 +86,8 @@ class Script(scripts_manager.Script):
p.task_args['self_recurrence_schedule'] = get_self_recurrence_schedule(config['self_recurrence_schedule'], p.steps)
is_struct = p.task_args.get('structure_image') is not None
is_appear = p.task_args.get('appearance_image') is not None
shared.log.info(f'Ctrl-X: structure={struct_strength if is_struct else None} appearance={appear_strength if is_appear else None}')
shared.log.debug(f'Ctrl-X: config={control_config} args={p.task_args}')
logger.log.info(f'Ctrl-X: structure={struct_strength if is_struct else None} appearance={appear_strength if is_appear else None}')
logger.log.debug(f'Ctrl-X: config={control_config} args={p.task_args}')
# process
processed: processing.Processed = processing.process_images(p)
scripts/daam_ext.py
+4 -3
View File
@@ -3,6 +3,7 @@
import gradio as gr
from installer import install
from modules import shared, scripts_manager, processing
from modules import logger
COLORMAP = ['autumn', 'bone', 'jet', 'winter', 'rainbow', 'ocean', 'summer', 'spring', 'cool', 'hsv', 'pink', 'hot', 'parula', 'magma', 'inferno', 'plasma', 'viridis', 'cividis', 'twilight', 'shifted', 'turbo', 'deepgreen']
@@ -26,7 +27,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, append_images, colormap): # pylint: disable=arguments-differ
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if shared.sd_model_type != 'sdxl':
shared.log.warning(f'DAAM: pipeline={c} required=StableDiffusionXLPipeline')
logger.log.warning(f'DAAM: pipeline={c} required=StableDiffusionXLPipeline')
return None
install('thinc==8.3.4')
@@ -40,7 +41,7 @@ class Script(scripts_manager.Script):
with daam.trace(shared.sd_model) as tc:
processed: processing.Processed = processing.process_images(p)
global_heat_map = tc.compute_global_heat_map()
shared.log.info(f'DAAM: prompt="{global_heat_map.prompt}" heatmaps={global_heat_map.heat_maps.shape}')
logger.log.info(f'DAAM: prompt="{global_heat_map.prompt}" heatmaps={global_heat_map.heat_maps.shape}')
# word_heat_map = global_heat_map.compute_word_heat_map('woman')
parsed_heat_maps = global_heat_map.parsed_heat_maps()
@@ -48,7 +49,7 @@ class Script(scripts_manager.Script):
image = processed.images[0]
for parsed_heat_map in parsed_heat_maps:
if len(parsed_heat_map.token.text) > 1:
shared.log.debug(f'DAAM: token="{parsed_heat_map.token.text}"')
logger.log.debug(f'DAAM: token="{parsed_heat_map.token.text}"')
overlay = parsed_heat_map.word_heat_map.plot_overlay(image=image, color_normalize=True, cmap=colormap)
processed.images.append(overlay)
scripts/demofusion.py
+12 -11
View File
@@ -15,6 +15,7 @@ from diffusers.utils import is_accelerate_available, is_accelerate_version
from diffusers.utils.torch_utils import randn_tensor
from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
from modules import scripts_manager, processing, shared, sd_models, devices
from modules import logger
### Class definition
@@ -164,7 +165,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
text_input_ids, untruncated_ids
):
removed_text = tokenizer.batch_decode(untruncated_ids[:, tokenizer.model_max_length - 1 : -1])
shared.log.warning(f"The following part of your input was truncated because CLIP can only handle sequences up to {tokenizer.model_max_length} tokens: {removed_text}")
logger.log.warning(f"The following part of your input was truncated because CLIP can only handle sequences up to {tokenizer.model_max_length} tokens: {removed_text}")
prompt_embeds = text_encoder(
text_input_ids.to(device),
@@ -346,11 +347,11 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
# DemoFusion specific checks
if max(height, width) % 1024 != 0:
shared.log.error('DemoFusion: resolution={width}x{height} long side must be divisible by 1024')
logger.log.error('DemoFusion: resolution={width}x{height} long side must be divisible by 1024')
return None
if num_images_per_prompt != 1:
shared.log.warning('DemoFusion: number of images per prompt is not support and will be ignored')
logger.log.warning('DemoFusion: number of images per prompt is not support and will be ignored')
num_images_per_prompt = 1
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents
@@ -830,7 +831,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
self.text_encoder.cpu()
self.text_encoder_2.cpu()
shared.log.debug('DemoFusion: phase=1 denoising')
logger.log.debug('DemoFusion: phase=1 denoising')
with self.progress_bar(total=num_inference_steps) as progress_bar:
for i, t in enumerate(timesteps):
@@ -896,7 +897,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
if needs_upcasting:
self.upcast_vae()
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
shared.log.debug('DemoFusion: phase=1 decoding')
logger.log.debug('DemoFusion: phase=1 decoding')
if self.lowvram and multi_decoder:
current_width_height = self.unet.config.sample_size * self.vae_scale_factor
image = self.tiled_decode(latents, current_width_height, current_width_height)
@@ -916,7 +917,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
latents = latents.to(device)
self.unet.to(device)
torch.cuda.empty_cache()
shared.log.debug(f'DemoFusion: phase={current_scale_num} denoising')
logger.log.debug(f'DemoFusion: phase={current_scale_num} denoising')
current_height = self.unet.config.sample_size * self.vae_scale_factor * current_scale_num
current_width = self.unet.config.sample_size * self.vae_scale_factor * current_scale_num
if height > width:
@@ -1136,7 +1137,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
self.upcast_vae()
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
shared.log.debug(f'DemoFusion: phase={current_scale_num} decoding')
logger.log.debug(f'DemoFusion: phase={current_scale_num} decoding')
if multi_decoder:
image = self.tiled_decode(latents, current_height, current_width)
else:
@@ -1176,7 +1177,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
if hasattr(component, "_hf_hook"):
is_model_cpu_offload = isinstance(component._hf_hook, CpuOffload) # pylint: disable=protected-access
is_sequential_cpu_offload = isinstance(component._hf_hook, AlignDevicesHook) # pylint: disable=protected-access
shared.log.info("Accelerate hooks detected. Since you have called `load_lora_weights()`, the previous hooks will be first removed. Then the LoRA parameters will be loaded and the hooks will be applied again.")
logger.log.info("Accelerate hooks detected. Since you have called `load_lora_weights()`, the previous hooks will be first removed. Then the LoRA parameters will be loaded and the hooks will be applied again.")
recursive = is_sequential_cpu_offload
remove_hook_from_module(component, recurse=recursive)
state_dict, network_alphas = self.lora_state_dict(
@@ -1245,7 +1246,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, cosine_scale_1, cosine_scale_2, cosine_scale_3, sigma, view_batch_size, stride, multi_decoder): # pylint: disable=arguments-differ
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if c != 'StableDiffusionXLPipeline':
shared.log.warning(f'DemoFusion: pipeline={c} required=StableDiffusionXLPipeline')
logger.log.warning(f'DemoFusion: pipeline={c} required=StableDiffusionXLPipeline')
return None
p.task_args['cosine_scale_1'] = cosine_scale_1
p.task_args['cosine_scale_2'] = cosine_scale_2
@@ -1256,7 +1257,7 @@ class Script(scripts_manager.Script):
p.task_args['multi_decoder'] = multi_decoder
p.task_args['output_type'] = 'np'
p.task_args['low_vram'] = True
shared.log.debug(f'DemoFusion: {p.task_args}')
logger.log.debug(f'DemoFusion: {p.task_args}')
old_pipe = shared.sd_model
new_pipe = DemoFusionSDXLPipeline(
vae = shared.sd_model.vae,
@@ -1271,7 +1272,7 @@ class Script(scripts_manager.Script):
shared.sd_model = new_pipe
sd_models.move_model(shared.sd_model, devices.device) # move pipeline to device
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
shared.log.debug(f'DemoFusion create: pipeline={shared.sd_model.__class__.__name__}')
logger.log.debug(f'DemoFusion create: pipeline={shared.sd_model.__class__.__name__}')
processed = processing.process_images(p)
shared.sd_model = old_pipe
return processed
scripts/differential_diffusion.py
+7 -6
View File
@@ -1835,6 +1835,7 @@ import gradio as gr
import diffusers
from PIL import Image, ImageEnhance, ImageOps # pylint: disable=reimported
from modules import errors, shared, devices, scripts_manager, processing, sd_models, images
from modules import logger
from modules.image import convert
@@ -1900,15 +1901,15 @@ class Script(scripts_manager.Script):
if not enabled:
return
if shared.sd_model_type not in ['sdxl', 'sd', 'f1']:
shared.log.error(f'Differential-diffusion: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'Differential-diffusion: incorrect base model: {shared.sd_model.__class__.__name__}')
return
if not hasattr(p, 'init_images') or len(p.init_images) == 0:
shared.log.error('Differential-diffusion: no input images')
logger.log.error('Differential-diffusion: no input images')
return
image_init, image_map, image_mask = self.depthmap(p.init_images[0], image, model, strength, invert)
if image_map is None:
shared.log.error('Differential-diffusion: no image map')
logger.log.error('Differential-diffusion: no image map')
return
orig_pipeline = shared.sd_model
@@ -1949,13 +1950,13 @@ class Script(scripts_manager.Script):
if shared.sd_model_type == 'sdxl':
p.task_args['original_image'] = image_init
if p.batch_size > 1:
shared.log.warning(f'Differential-diffusion: batch-size={p.batch_size} parallel processing not supported')
logger.log.warning(f'Differential-diffusion: batch-size={p.batch_size} parallel processing not supported')
p.batch_size = 1
shared.log.debug(f'Differential-diffusion: pipeline={pipe.__class__.__name__} strength={strength} model={model} auto={image is None}')
logger.log.debug(f'Differential-diffusion: pipeline={pipe.__class__.__name__} strength={strength} model={model} auto={image is None}')
shared.sd_model = pipe
sd_models.move_model(pipe.vae, devices.device, force=True)
except Exception as e:
shared.log.error(f'Differential-diffusion: pipeline creation failed: {e}')
logger.log.error(f'Differential-diffusion: pipeline creation failed: {e}')
errors.display(e, 'Differential-diffusion: pipeline creation failed')
shared.sd_model = orig_pipeline
scripts/example.py
+3 -2
View File
@@ -1,6 +1,7 @@
import gradio as gr
from diffusers.pipelines import StableDiffusionPipeline, StableDiffusionXLPipeline # pylint: disable=unused-import
from modules import shared, scripts_manager, processing, sd_models, devices
from modules import logger
"""
This is a simpler template for script for SD.Next that implements a custom pipeline
@@ -88,7 +89,7 @@ class Script(scripts_manager.Script):
# prepare pipeline
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if c != pipeline_base:
shared.log.warning(f'{title}: pipeline={c} required={pipeline_base}')
logger.log.warning(f'{title}: pipeline={c} required={pipeline_base}')
return None
orig_pipeline = shared.sd_model # backup current pipeline definition
shared.sd_model = pipeline_class( # create new pipeline using currently loaded model which is always in `shared.sd_model`
@@ -123,7 +124,7 @@ class Script(scripts_manager.Script):
if not latent:
p.task_args['output_type'] = 'np'
shared.log.debug(f'{c}: args={p.task_args}')
logger.log.debug(f'{c}: args={p.task_args}')
# if you need to run any preprocessing, this is the place to do it
scripts/flux_enhance.py
+7 -6
View File
@@ -6,6 +6,7 @@ import threading
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import gradio as gr
from modules import shared, scripts_manager, devices, processing
from modules import logger
repo_id = "gokaygokay/Flux-Prompt-Enhance"
@@ -37,7 +38,7 @@ class Script(scripts_manager.Script):
if self.tokenizer is None:
self.tokenizer = AutoTokenizer.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir)
if self.model is None:
shared.log.info(f'Prompt enhance: model="{repo_id}"')
logger.log.info(f'Prompt enhance: model="{repo_id}"')
self.model = AutoModelForSeq2SeqLM.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir).to(device=devices.cpu, dtype=devices.dtype)
def enhance(self, prompt, auto_apply: bool = False, temperature: float = 0.7, repetition_penalty: float = 1.2, max_length: int = 128):
@@ -56,18 +57,18 @@ class Script(scripts_manager.Script):
try:
outputs = self.model.generate(input_ids, **kwargs)
except Exception as e:
shared.log.error(f'Prompt enhance: error="{e}"')
logger.log.error(f'Prompt enhance: error="{e}"')
return [['']]
self.model = self.model.to(devices.cpu)
prompts = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
prompts = [[p] for p in prompts]
t1 = time.time()
shared.log.info(f'Prompt enhance: temperature={temperature} repetition={repetition_penalty} length={max_length} sequences={num_return_sequences} apply={auto_apply} time={t1-t0:.2f}s')
logger.log.info(f'Prompt enhance: temperature={temperature} repetition={repetition_penalty} length={max_length} sequences={num_return_sequences} apply={auto_apply} time={t1-t0:.2f}s')
return prompts
def select(self, cell: gr.SelectData, _table):
prompt = cell.value if hasattr(cell, 'value') else cell
shared.log.info(f'Prompt enhance: prompt="{prompt}"')
logger.log.info(f'Prompt enhance: prompt="{prompt}"')
return prompt
def ui(self, _is_img2img):
@@ -92,10 +93,10 @@ class Script(scripts_manager.Script):
p.negative_prompt = shared.prompt_styles.apply_negative_styles_to_prompt(p.negative_prompt, p.styles)
shared.prompt_styles.apply_styles_to_extra(p)
p.styles = []
shared.log.debug(f'Prompt enhance: source="{p.prompt}"')
logger.log.debug(f'Prompt enhance: source="{p.prompt}"')
prompts = self.enhance(p.prompt, auto_apply, temperature, repetition_penalty, max_length)
p.prompt = random.choice(prompts)[0]
shared.log.debug(f'Prompt enhance: prompt="{p.prompt}"')
logger.log.debug(f'Prompt enhance: prompt="{p.prompt}"')
def after_component(self, component, **kwargs): # searching for actual ui prompt components
if getattr(component, 'elem_id', '') in ['txt2img_prompt', 'img2img_prompt', 'control_prompt', 'video_prompt']:
scripts/flux_tools.py
+11 -10
View File
@@ -4,6 +4,7 @@ import time
import gradio as gr
import diffusers
from modules import scripts_manager, processing, shared, devices, sd_models
from modules import logger
from installer import install
@@ -47,21 +48,21 @@ class Script(scripts_manager.Script):
return None
image = getattr(p, 'init_images', None)
if image is None or len(image) == 0:
shared.log.error(f'{title}: tool={tool} no init_images')
logger.log.error(f'{title}: tool={tool} no init_images')
return None
else:
image = image[0] if isinstance(image, list) else image
shared.log.info(f'{title}: tool={tool} init')
logger.log.info(f'{title}: tool={tool} init')
t0 = time.time()
if tool == 'Redux':
supported_model_list = ['f1']
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'{title}: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'{title}: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
# pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained("black-forest-labs/FLUX.1-Redux-dev", revision="refs/pr/8", torch_dtype=torch.bfloat16).to("cuda")
shared.log.debug(f'{title}: tool={tool} prompt={prompt}')
logger.log.debug(f'{title}: tool={tool} prompt={prompt}')
if redux_pipe is None:
redux_pipe = diffusers.FluxPriorReduxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Redux-dev",
@@ -70,7 +71,7 @@ class Script(scripts_manager.Script):
cache_dir=shared.opts.hfcache_dir
).to(devices.device)
if prompt > 0:
shared.log.info(f'{title}: tool={tool} load text encoder')
logger.log.info(f'{title}: tool={tool} load text encoder')
redux_pipe.tokenizer, redux_pipe.tokenizer_2 = shared.sd_model.tokenizer, shared.sd_model.tokenizer_2
redux_pipe.text_encoder, redux_pipe.text_encoder_2 = shared.sd_model.text_encoder, shared.sd_model.text_encoder_2
sd_models.apply_balanced_offload(redux_pipe)
@@ -88,13 +89,13 @@ class Script(scripts_manager.Script):
p.task_args[k] = v
else:
if redux_pipe is not None:
shared.log.debug(f'{title}: tool=Redux unload')
logger.log.debug(f'{title}: tool=Redux unload')
redux_pipe = None
if tool in ['Fill', 'Fill (Nunchaku)']:
# pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16, revision="refs/pr/4").to("cuda")
if p.image_mask is None:
shared.log.error(f'{title}: tool={tool} no image_mask')
logger.log.error(f'{title}: tool={tool} no image_mask')
return None
nunchaku_suffix = '+nunchaku' if tool == 'Fill (Nunchaku)' else ''
checkpoint = f"black-forest-labs/FLUX.1-Fill-dev{nunchaku_suffix}"
@@ -123,7 +124,7 @@ class Script(scripts_manager.Script):
p.task_args['strength'] = None
else:
if processor_canny is not None:
shared.log.debug(f'{title}: tool=Canny unload processor')
logger.log.debug(f'{title}: tool=Canny unload processor')
processor_canny = None
if tool in ['Depth', 'Depth (Nunchaku)']:
@@ -146,9 +147,9 @@ class Script(scripts_manager.Script):
p.task_args['strength'] = None
else:
if processor_depth is not None:
shared.log.debug(f'{title}: tool=Depth unload processor')
logger.log.debug(f'{title}: tool=Depth unload processor')
processor_depth = None
shared.log.debug(f'{title}: tool={tool} ready time={time.time() - t0:.2f}')
logger.log.debug(f'{title}: tool={tool} ready time={time.time() - t0:.2f}')
devices.torch_gc()
return None
scripts/freescale_ext.py
+5 -4
View File
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
from modules import logger
registered = False
@@ -50,12 +51,12 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, cosine_scale, override_sampler, cosine_scale_bg, dilate_tau, s1_enable, s1_scale, s1_restart, s2_enable, s2_scale, s2_restart, s3_enable, s3_scale, s3_restart, s4_enable, s4_scale, s4_restart): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'FreeScale: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'FreeScale: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
if self.is_img2img:
if p.init_images is None or len(p.init_images) == 0:
shared.log.warning('FreeScale: missing input image')
logger.log.warning('FreeScale: missing input image')
return None
from scripts.freescale import StableDiffusionXLFreeScale, StableDiffusionXLFreeScaleImg2Img # pylint: disable=no-name-in-module
@@ -101,7 +102,7 @@ class Script(scripts_manager.Script):
p.sampler_name = 'Euler a'
if p.width < 1024 or p.height < 1024:
shared.log.error(f'FreeScale: width={p.width} height={p.height} minimum=1024')
logger.log.error(f'FreeScale: width={p.width} height={p.height} minimum=1024')
return None
if not self.is_img2img:
@@ -111,7 +112,7 @@ class Script(scripts_manager.Script):
shared.sd_model.enable_vae_slicing()
shared.sd_model.enable_vae_tiling()
shared.log.info(f'FreeScale: mode={"txt" if not self.is_img2img else "img"} cosine={cosine_scale} bg={cosine_scale_bg} tau={dilate_tau} scales={scales} resolutions={resolutions_list} steps={restart_steps} sampler={p.sampler_name}')
logger.log.info(f'FreeScale: mode={"txt" if not self.is_img2img else "img"} cosine={cosine_scale} bg={cosine_scale_bg} tau={dilate_tau} scales={scales} resolutions={resolutions_list} steps={restart_steps} sampler={p.sampler_name}')
resolutions = ','.join([f'{x[0]}x{x[1]}' for x in resolutions_list])
steps = ','.join([str(x) for x in restart_steps])
p.extra_generation_params["FreeScale"] = f'cosine {cosine_scale} resolutions {resolutions} steps {steps}'
scripts/hdr.py
+5 -4
View File
@@ -4,6 +4,7 @@ import numpy as np
import gradio as gr
from PIL import Image
from modules import images, processing, shared, scripts_manager
from modules import logger
from modules.processing import get_processed
from modules.shared import opts, state
@@ -34,7 +35,7 @@ class Script(scripts_manager.Script):
return [gr.update(visible=is_tonemap), gr.update(visible=is_tonemap), gr.update(visible=is_tonemap)]
def merge(self, imgs: list, is_tonemap: bool, gamma, scale, saturation):
shared.log.info(f'HDR: merge images={len(imgs)} tonemap={is_tonemap} sgamma={gamma} scale={scale} saturation={saturation}')
logger.log.info(f'HDR: merge images={len(imgs)} tonemap={is_tonemap} sgamma={gamma} scale={scale} saturation={saturation}')
imgs_np = [np.asarray(img).astype(np.uint8) for img in imgs]
align = cv2.createAlignMTB()
@@ -58,12 +59,12 @@ class Script(scripts_manager.Script):
def run(self, p, hdr_range, save_hdr, is_tonemap, gamma, scale, saturation): # pylint: disable=arguments-differ
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
shared.log.error(f'HDR: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'HDR: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
p.extra_generation_params = {
"HDR range": hdr_range,
}
shared.log.info(f'HDR: range={hdr_range}')
logger.log.info(f'HDR: range={hdr_range}')
processing.fix_seed(p)
imgs = []
info = ''
@@ -89,7 +90,7 @@ class Script(scripts_manager.Script):
fn = os.path.splitext(saved_fn)[0] + '-hdr.png'
# cv2.imwrite(fn, hdr, [cv2.IMWRITE_PNG_COMPRESSION, 6, cv2.IMWRITE_PNG_STRATEGY, cv2.IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY, cv2.IMWRITE_HDR_COMPRESSION, cv2.IMWRITE_HDR_COMPRESSION_RLE])
cv2.imwrite(fn, hdr)
shared.log.debug(f'Save: image="{fn}" type=PNG mode=HDR channels=16 size={os.path.getsize(fn)}')
logger.log.debug(f'Save: image="{fn}" type=PNG mode=HDR channels=16 size={os.path.getsize(fn)}')
# if opts.grid_save:
# images.save_image(grid, p.outpath_grids, "grid", p.seed, p.prompt, opts.grid_format, info=processed.info, grid=True, p=p)
grid = [images.image_grid(imgs, rows=1)] if opts.return_grid else []
scripts/image2video.py
+7 -6
View File
@@ -2,6 +2,7 @@ import torch
import gradio as gr
import diffusers
from modules import scripts_manager, processing, shared, images, sd_models, devices
from modules import logger
MODELS = [
@@ -58,16 +59,16 @@ class Script(scripts_manager.Script):
return None
model = [m for m in MODELS if m['name'] == model_name][0]
repo_id = model['url']
shared.log.debug(f'Image2Video: model={model_name} frames={num_frames}, video={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
logger.log.debug(f'Image2Video: model={model_name} frames={num_frames}, video={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
p.ops.append('video')
p.do_not_save_grid = True
orig_pipeline = shared.sd_model
if model_name == 'PIA':
if shared.sd_model_type != 'sd':
shared.log.error('Image2Video PIA: base model must be SD15')
logger.log.error('Image2Video PIA: base model must be SD15')
return None
shared.log.info(f'Image2Video PIA load: model={repo_id}')
logger.log.info(f'Image2Video PIA load: model={repo_id}')
motion_adapter = diffusers.MotionAdapter.from_pretrained(repo_id)
sd_models.move_model(motion_adapter, devices.device)
shared.sd_model = sd_models.switch_pipe(diffusers.PIAPipeline, shared.sd_model, { 'motion_adapter': motion_adapter })
@@ -84,14 +85,14 @@ class Script(scripts_manager.Script):
spatial_stop_frequency=fi_spatial,
temporal_stop_frequency=fi_temporal,
)
shared.log.debug(f'Image2Video PIA: args={p.task_args}')
logger.log.debug(f'Image2Video PIA: args={p.task_args}')
processed = processing.process_images(p)
shared.sd_model.motion_adapter = None
processed = None
if model_name == 'VGen':
if not isinstance(shared.sd_model, diffusers.I2VGenXLPipeline):
shared.log.info(f'Image2Video VGen load: model={repo_id}')
logger.log.info(f'Image2Video VGen load: model={repo_id}')
pipe = diffusers.I2VGenXLPipeline.from_pretrained(repo_id, torch_dtype=devices.dtype, cache_dir=shared.opts.diffusers_dir)
sd_models.copy_diffuser_options(pipe, shared.sd_model)
sd_models.set_diffuser_options(pipe)
@@ -104,7 +105,7 @@ class Script(scripts_manager.Script):
p.task_args['target_fps'] = max(1, int(num_frames * vg_fps))
p.task_args['decode_chunk_size'] = max(1, int(num_frames * vg_chunks))
p.task_args['output_type'] = 'pil'
shared.log.debug(f'Image2Video VGen: args={p.task_args}')
logger.log.debug(f'Image2Video VGen: args={p.task_args}')
processed = processing.process_images(p)
shared.sd_model = orig_pipeline
scripts/infiniteyou/pipeline_infu_flux.py
+5 -4
View File
@@ -28,6 +28,7 @@ from insightface.utils import face_align
from PIL import Image
from modules import shared, devices, model_quant
from modules import logger
from .pipeline_flux_infusenet import FluxInfuseNetPipeline
from .resampler import Resampler
@@ -147,12 +148,12 @@ class InfUFluxPipeline:
self.infu_flux_version = infu_flux_version
self.model_version = model_version
# Load controlnet
shared.log.debug(f'InfiniteYou: cls={shared.sd_model.__class__.__name__} loading')
logger.log.debug(f'InfiniteYou: cls={shared.sd_model.__class__.__name__} loading')
local_path = snapshot_download(repo_id='ByteDance/InfiniteYou', cache_dir=shared.opts.hfcache_dir)
infiniteyou_path = os.path.join(local_path, f'infu_flux_{infu_flux_version}', model_version)
infusenet_path = os.path.join(infiniteyou_path, 'InfuseNetModel')
quant_args = model_quant.create_config(module='Control')
shared.log.debug(f'InfiniteYou: fn="{infusenet_path}" load infusenet')
logger.log.debug(f'InfiniteYou: fn="{infusenet_path}" load infusenet')
infusenet = FluxControlNetModel.from_pretrained(
infusenet_path,
torch_dtype=devices.dtype,
@@ -185,7 +186,7 @@ class InfUFluxPipeline:
ff_mult=4,
)
image_proj_model_path = os.path.join(infiniteyou_path, 'image_proj_model.bin')
shared.log.debug(f'InfiniteYou: fn="{image_proj_model_path}" load image projection')
logger.log.debug(f'InfiniteYou: fn="{image_proj_model_path}" load image projection')
ipm_state_dict = torch.load(image_proj_model_path, map_location="cpu")
self.image_proj_model.load_state_dict(ipm_state_dict['image_proj'])
del ipm_state_dict
@@ -193,7 +194,7 @@ class InfUFluxPipeline:
self.image_proj_model.eval()
# Load face encoder
insightface_root_path = os.path.join(local_path, 'supports', 'insightface')
shared.log.debug(f'InfiniteYou: fn="{insightface_root_path}" load face encoder')
logger.log.debug(f'InfiniteYou: fn="{insightface_root_path}" load face encoder')
self.app_640 = FaceAnalysis(name='antelopev2', root=insightface_root_path, providers=devices.onnx)
self.app_640.prepare(ctx_id=0, det_size=(640, 640))
self.app_320 = FaceAnalysis(name='antelopev2', root=insightface_root_path, providers=devices.onnx)
scripts/infiniteyou_ext.py
+6 -5
View File
@@ -5,6 +5,7 @@
import gradio as gr
from PIL import Image
from modules import scripts_manager, processing, shared, sd_models, devices
from modules import logger
prefix = 'InfiniteYou'
@@ -73,10 +74,10 @@ class Script(scripts_manager.Script):
if model is None or model not in model_versions:
return None
if id_image is None:
shared.log.error(f'{prefix}: no init_images')
logger.log.error(f'{prefix}: no init_images')
return None
if shared.sd_model_type != 'f1':
shared.log.error(f'{prefix}: invalid model type: {shared.sd_model_type}')
logger.log.error(f'{prefix}: invalid model type: {shared.sd_model_type}')
return None
if scale <= 0:
return None
@@ -87,7 +88,7 @@ class Script(scripts_manager.Script):
verify_insightface()
load_infiniteyou(model)
devices.torch_gc()
shared.log.info(f'{prefix}: cls={shared.sd_model.__class__.__name__} loaded')
logger.log.info(f'{prefix}: cls={shared.sd_model.__class__.__name__} loaded')
processing.fix_seed(p)
p.task_args['id_image'] = id_image
@@ -103,7 +104,7 @@ class Script(scripts_manager.Script):
p.extra_generation_params['IY guidance'] = f'{scale:.1f}/{start:.1f}/{end:.1f}'
orig_prompt_attention = shared.opts.prompt_attention
shared.opts.data['prompt_attention'] = 'fixed'
shared.log.debug(f'{prefix}: args={p.task_args}')
logger.log.debug(f'{prefix}: args={p.task_args}')
processed = processing.process_images(p)
return processed
@@ -116,6 +117,6 @@ class Script(scripts_manager.Script):
shared.opts.data['prompt_attention'] = orig_prompt_attention
orig_prompt_attention = None
if restore and orig_pipeline is not None:
shared.log.info(f'{prefix}: restoring pipeline')
logger.log.info(f'{prefix}: restoring pipeline')
shared.sd_model = orig_pipeline
orig_pipeline = None
scripts/init_latents.py
+2 -1
View File
@@ -1,3 +1,4 @@
from modules import logger
from modules import scripts_manager, processing, shared, devices
@@ -44,5 +45,5 @@ class Script(scripts_manager.Script):
subseed_strength=p.subseed_strength,
p=p
)
shared.log.debug(f'Latent: seed={p.seeds} subseed={p.subseeds} strength={p.subseed_strength} tensor={list(p.init_latent.shape)}')
logger.log.debug(f'Latent: seed={p.seeds} subseed={p.subseeds} strength={p.subseed_strength} tensor={list(p.init_latent.shape)}')
p.init_latent = p.init_latent.to(device=shared.sd_model._execution_device, dtype=shared.sd_model.unet.dtype) # pylint: disable=protected-access
scripts/instantir_ext.py
+7 -6
View File
@@ -3,6 +3,7 @@ import torch
import diffusers
from huggingface_hub import hf_hub_download
from modules import scripts_manager, processing, shared, sd_models, devices, ipadapter
from modules import logger
class Script(scripts_manager.Script):
@@ -36,10 +37,10 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if not hasattr(p, 'init_images') or len(p.init_images) == 0:
shared.log.warning('InstantIR: no image')
logger.log.warning('InstantIR: no image')
return None
if shared.sd_model_type not in supported_model_list and shared.sd_model.__class__.__name__ != "InstantIRPipeline":
shared.log.warning(f'InstantIR: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'InstantIR: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
start, end, hq, multistep, adastep, image, _unload = args
from scripts import instantir
@@ -50,7 +51,7 @@ class Script(scripts_manager.Script):
adapter_file = hf_hub_download('InstantX/InstantIR', subfolder='models', filename='adapter.pt', cache_dir=shared.opts.hfcache_dir)
aggregator_file = hf_hub_download('InstantX/InstantIR', subfolder='models', filename='aggregator.pt', cache_dir=shared.opts.hfcache_dir)
previewer_file = hf_hub_download('InstantX/InstantIR', subfolder='models', filename='previewer_lora_weights.bin', cache_dir=shared.opts.hfcache_dir)
shared.log.debug(f'InstantIR: adapter="{adapter_file}" aggregator="{aggregator_file}" previewer="{previewer_file}"')
logger.log.debug(f'InstantIR: adapter="{adapter_file}" aggregator="{aggregator_file}" previewer="{previewer_file}"')
shared.sd_model = sd_models.switch_pipe(instantir.InstantIRPipeline, shared.sd_model)
instantir.load_adapter_to_pipe(
pipe=shared.sd_model,
@@ -68,7 +69,7 @@ class Script(scripts_manager.Script):
sd_models.clear_caches()
sd_models.apply_balanced_offload(shared.sd_model)
shared.log.info(f'InstantIR: class={shared.sd_model.__class__.__name__} start={start} end={end} multistep={multistep} adastep={adastep} hq={hq} cache={shared.opts.hfcache_dir}')
logger.log.info(f'InstantIR: class={shared.sd_model.__class__.__name__} start={start} end={end} multistep={multistep} adastep={adastep} hq={hq} cache={shared.opts.hfcache_dir}')
p.sampler_name = 'Default' # ir has its own sampler
p.init() # run init early to take care of resizing
p.task_args['previewer_scheduler'] = instantir.LCMSingleStepScheduler.from_config(shared.sd_model.scheduler.config)
@@ -89,7 +90,7 @@ class Script(scripts_manager.Script):
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, *args): # pylint: disable=arguments-differ, unused-argument
_start, _end, _hq, _multistep, _adastep, _image, unload = args
if unload:
shared.log.info('InstantIR: unloading adapter')
logger.log.info('InstantIR: unloading adapter')
if self.orig_ip_unapply is not None:
ipadapter.unapply = self.orig_ip_unapply
self.orig_ip_unapply = None
@@ -101,6 +102,6 @@ class Script(scripts_manager.Script):
self.orig_pipe = None
shared.sd_model.unet.register_to_config(encoder_hid_dim_type=None)
sd_models.apply_balanced_offload(shared.sd_model)
shared.log.debug(f'InstantIR restore: class={shared.sd_model.__class__.__name__}')
logger.log.debug(f'InstantIR restore: class={shared.sd_model.__class__.__name__}')
devices.torch_gc()
return processed
scripts/ipadapter.py
+3 -2
View File
@@ -2,6 +2,7 @@ import json
from PIL import Image
import gradio as gr
from modules import scripts_manager, processing, shared, ipadapter, ui_common
from modules import logger
MAX_ADAPTERS = 4
@@ -33,7 +34,7 @@ class Script(scripts_manager.Script):
raise ValueError(f'IP adapter unknown input: {file}')
init_images.append(image)
except Exception as e:
shared.log.warning(f'IP adapter failed to load image: {e}')
logger.log.warning(f'IP adapter failed to load image: {e}')
return gr.update(value=init_images, visible=len(init_images) > 0)
def display_units(self, num_units):
@@ -116,5 +117,5 @@ class Script(scripts_manager.Script):
layers = json.loads(layers)
p.ip_adapter_layers = layers
except Exception as e:
shared.log.error(f'IP adapter: failed to parse layer scales: {e}')
logger.log.error(f'IP adapter: failed to parse layer scales: {e}')
# ipadapter.apply(shared.sd_model, p, p.ip_adapter_names, p.ip_adapter_scales, p.ip_adapter_starts, p.ip_adapter_ends, p.ip_adapter_images) # called directly from processing.process_images_inner
scripts/ipinstruct.py
+5 -4
View File
@@ -8,6 +8,7 @@ import os
import importlib
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models, devices
from modules import logger
repo = 'https://github.com/vladmandic/IP-Instruct'
@@ -57,11 +58,11 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, query, image, strength, tokens, instruct_guidance, image_guidance): # pylint: disable=arguments-differ
supported_model_list = ['sd', 'sdxl', 'sd3']
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'IP-Instruct: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'IP-Instruct: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
self.install()
if self.lib is None:
shared.log.error('IP-Instruct: failed to import library')
logger.log.error('IP-Instruct: failed to import library')
return None
self.orig_pipe = shared.sd_model
if shared.sd_model_type == 'sdxl':
@@ -83,8 +84,8 @@ class Script(scripts_manager.Script):
ip_ckpt = hf.hf_hub_download(repo_id=repo_id, filename=ckpt, cache_dir=shared.opts.hfcache_dir)
ip_model = cls(shared.sd_model, encoder, ip_ckpt, device=devices.device, dtypein=devices.dtype, num_tokens=tokens)
processing.fix_seed(p)
shared.log.debug(f'IP-Instruct: class={shared.sd_model.__class__.__name__} wrapper={ip_model.__class__.__name__} encoder={encoder} adapter={ckpt}')
shared.log.info(f'IP-Instruct: image={image} query="{query}" strength={strength} tokens={tokens} instruct_guidance={instruct_guidance} image_guidance={image_guidance}')
logger.log.debug(f'IP-Instruct: class={shared.sd_model.__class__.__name__} wrapper={ip_model.__class__.__name__} encoder={encoder} adapter={ckpt}')
logger.log.info(f'IP-Instruct: image={image} query="{query}" strength={strength} tokens={tokens} instruct_guidance={instruct_guidance} image_guidance={image_guidance}')
image_list = ip_model.generate(
query = query,
scripts/kohya_hires_fix.py
+3 -2
View File
@@ -1,6 +1,7 @@
import gradio as gr
import diffusers
from modules import scripts_manager, processing, shared, sd_models, devices
from modules import logger
class Script(scripts_manager.Script):
@@ -26,7 +27,7 @@ class Script(scripts_manager.Script):
if not enabled:
return None
if shared.sd_model_type != 'sd':
shared.log.warning(f'Kohya Hires Fix: pipeline={shared.sd_model_type} required=sd')
logger.log.warning(f'Kohya Hires Fix: pipeline={shared.sd_model_type} required=sd')
return None
old_pipe = shared.sd_model
high_res_fix = [{'timestep': timestep, 'scale_factor': scale_factor, 'block_num': block_num}]
@@ -34,7 +35,7 @@ class Script(scripts_manager.Script):
sd_models.copy_diffuser_options(shared.sd_model, old_pipe)
sd_models.move_model(shared.sd_model, devices.device) # move pipeline to device
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
shared.log.debug(f'Kohya Hires Fix: pipeline={shared.sd_model.__class__.__name__} args={high_res_fix}')
logger.log.debug(f'Kohya Hires Fix: pipeline={shared.sd_model.__class__.__name__} args={high_res_fix}')
processed = processing.process_images(p)
shared.sd_model = old_pipe
return processed
scripts/layerdiffuse/__init__.py
+6 -5
View File
@@ -3,6 +3,7 @@
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from modules import shared, errors, devices
from modules import logger
from .layerdiffuse_model import TransparentVAEDecoder
from .layerdiffuse_loader import load_lora_to_unet, merge_delta_weights_into_unet
@@ -43,16 +44,16 @@ def apply_layerdiffuse_sdxl_conv(pipeline):
def apply_layerdiffuse():
try:
if shared.sd_model_type == 'sd':
shared.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__}')
logger.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__}')
apply_layerdiffuse_sd15(shared.sd_model)
elif shared.sd_model_type == 'sdxl':
# shared.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=attn')
# logger.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=attn')
# apply_layerdiffuse_sdxl_attn(shared.sd_model)
shared.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=conv')
logger.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=conv')
apply_layerdiffuse_sdxl_conv(shared.sd_model)
else:
shared.log.warning(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} not supported')
logger.log.warning(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} not supported')
shared.sd_model.layerdiffusion = True
except Exception as e:
shared.log.error(f'LayerDiffuse: {e}')
logger.log.error(f'LayerDiffuse: {e}')
errors.display(e, 'LayerDiffuse')
scripts/layerdiffuse_ext.py
+4 -3
View File
@@ -1,5 +1,6 @@
import gradio as gr
from modules import shared, scripts_manager, sd_models
from modules import logger
class Script(scripts_manager.Script):
@@ -13,13 +14,13 @@ class Script(scripts_manager.Script):
def apply(self):
from scripts import layerdiffuse # pylint: disable=no-name-in-module
if not shared.sd_loaded:
shared.log.error('LayerDiffuse: model not loaded')
logger.log.error('LayerDiffuse: model not loaded')
return self.is_active()
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
shared.log.error(f'LayerDiffuse: incorrect base model: class={shared.sd_model.__class__.__name__} type={shared.sd_model_type}')
logger.log.error(f'LayerDiffuse: incorrect base model: class={shared.sd_model.__class__.__name__} type={shared.sd_model_type}')
return self.is_active()
if hasattr(shared.sd_model, 'layerdiffusion'):
shared.log.warning('LayerDiffuse: already applied')
logger.log.warning('LayerDiffuse: already applied')
return self.is_active()
layerdiffuse.apply_layerdiffuse()
return self.is_active()
scripts/lbm_ext.py
+3 -2
View File
@@ -2,6 +2,7 @@ from copy import deepcopy
from PIL import Image
import gradio as gr
from modules import scripts_manager, processing, shared, devices
from modules import logger
birefnet = None
@@ -76,7 +77,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, lbm_method, lbm_composite, lbm_steps, bg_image): # pylint: disable=arguments-differ, unused-argument
fg_image = getattr(p, 'init_images', None)
if fg_image is None or len(fg_image) == 0 or bg_image is None:
shared.log.error('LBM: no init images')
logger.log.error('LBM: no init images')
return None
else:
fg_image = fg_image[0]
@@ -92,7 +93,7 @@ class Script(scripts_manager.Script):
closest_ar_bg = min(ASPECT_RATIOS, key=lambda x: abs(float(x) - ar_bg))
dimensions_bg = ASPECT_RATIOS[closest_ar_bg]
shared.log.info(f'LBM: method={lbm_method} steps={lbm_steps} size={dimensions_bg[0]}x{dimensions_bg[1]}')
logger.log.info(f'LBM: method={lbm_method} steps={lbm_steps} size={dimensions_bg[0]}x{dimensions_bg[1]}')
self.load(lbm_method)
if birefnet:
scripts/ledits.py
+6 -5
View File
@@ -1,6 +1,7 @@
import diffusers
import gradio as gr
from modules import scripts_manager, processing, shared, devices, sd_models
from modules import logger
class Script(scripts_manager.Script):
@@ -31,13 +32,13 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, edit_start, edit_stop, intersect_mask, prompt1, scale1, threshold1, prompt2, scale2, threshold2): # pylint: disable=arguments-differ, unused-argument
image = getattr(p, 'init_images', None)
if len(prompt1) == 0 and len(prompt2) == 0:
shared.log.error('LEdits: no prompts')
logger.log.error('LEdits: no prompts')
return None
if image is None or len(image) == 0:
shared.log.error('LEdits: no init_images')
logger.log.error('LEdits: no init_images')
return None
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
shared.log.error(f'LEdits: invalid model type: {shared.sd_model_type}')
logger.log.error(f'LEdits: invalid model type: {shared.sd_model_type}')
return None
orig_pipeline = shared.sd_model
@@ -67,7 +68,7 @@ class Script(scripts_manager.Script):
'skip': 1.0 - p.denoising_strength, # invert start
'generator': None, # not supported
}
shared.log.info(f'LEdits invert: {invert_args}')
logger.log.info(f'LEdits invert: {invert_args}')
_output = shared.sd_model.invert(**invert_args)
p.task_args = {
'editing_prompt': [],
@@ -91,7 +92,7 @@ class Script(scripts_manager.Script):
p.task_args['edit_guidance_scale'].append(10.0 * scale2)
p.task_args['edit_threshold'].append(threshold2)
shared.log.info(f'LEdits: {p.task_args}')
logger.log.info(f'LEdits: {p.task_args}')
processed = processing.process_images(p)
# restore pipeline
scripts/lut.py
+3 -2
View File
@@ -6,6 +6,7 @@ import os
import gradio as gr
from installer import install
from modules import scripts_manager, shared, processing
from modules import logger
class Script(scripts_manager.Script):
@@ -44,14 +45,14 @@ class Script(scripts_manager.Script):
cube = None
name = os.path.splitext(os.path.basename(cube_file.name))[0] if cube_file is not None else None
shared.log.info(f'Color grading: cube="{name}" scale={cube_scale} brightness={brightness} exposure={exposure} contrast={contrast} warmth={warmth} saturation={saturation} vibrance={vibrance} hue={hue} gamma={gamma}')
logger.log.info(f'Color grading: cube="{name}" scale={cube_scale} brightness={brightness} exposure={exposure} contrast={contrast} warmth={warmth} saturation={saturation} vibrance={vibrance} hue={hue} gamma={gamma}')
if cube_file is not None:
try:
cube = pillow_lut.load_cube_file(cube_file.name)
cube = pillow_lut.amplify_lut(cube, cube_scale)
cube = pillow_lut.rgb_color_enhance(source=cube, brightness=brightness, exposure=exposure, contrast=contrast, warmth=warmth, saturation=saturation, vibrance=vibrance, hue=hue, gamma=gamma)
except Exception as e:
shared.log.error(f'Color grading: {e}')
logger.log.error(f'Color grading: {e}')
images = []
if processed is not None and len(processed.images) > 0:
scripts/mixture_of_diffusers.py
+4 -3
View File
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
from modules import logger
supported_models = ['sdxl']
@@ -73,12 +74,12 @@ class Script(scripts_manager.Script):
from ligo.segments import segment # pylint: disable=unused-import
return True
except Exception as e:
shared.log.error(f'MoD: {e}')
logger.log.error(f'MoD: {e}')
return False
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ, unused-argument
if shared.sd_model_type not in supported_models:
shared.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
logger.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
return None
if not self.check_dependencies():
return None
@@ -108,7 +109,7 @@ class Script(scripts_manager.Script):
p.extra_generation_params["MoD Y"] = f'{y_tiles}/{p.task_args["tile_height"]}/{p.task_args["tile_row_overlap"]}'
p.keep_prompts = True
shared.opts.prompt_attention = 'fixed'
shared.log.info(f'MoD: xtiles={x_tiles} ytiles={y_tiles} xoverlap={p.task_args["tile_col_overlap"]} yoverlap={p.task_args["tile_row_overlap"]} xsize={p.task_args["tile_width"]} ysize={p.task_args["tile_height"]}')
logger.log.info(f'MoD: xtiles={x_tiles} ytiles={y_tiles} xoverlap={p.task_args["tile_col_overlap"]} yoverlap={p.task_args["tile_row_overlap"]} xsize={p.task_args["tile_width"]} ysize={p.task_args["tile_height"]}')
shared.sd_model = sd_models.switch_pipe(StableDiffusionXLTilingPipeline, shared.sd_model)
sd_models.set_diffuser_options(shared.sd_model)
scripts/mixture_tiling.py
+6 -5
View File
@@ -1,6 +1,7 @@
import gradio as gr
import torch
from modules import shared, devices, scripts_manager, processing, sd_models
from modules import logger
checked_ok = False
@@ -20,7 +21,7 @@ def check_dependencies():
checked_ok = True
return True
except Exception as e:
shared.log.error(f'Mixture tiling: {e}')
logger.log.error(f'Mixture tiling: {e}')
return False
@@ -50,7 +51,7 @@ class Script(scripts_manager.Script):
return None
prompts = p.prompt.splitlines()
if len(prompts) != x_size * y_size:
shared.log.error(f'Mixture tiling prompt count mismatch: prompts={len(prompts)} required={x_size * y_size}')
logger.log.error(f'Mixture tiling prompt count mismatch: prompts={len(prompts)} required={x_size * y_size}')
return None
# backup pipeline and params
orig_pipeline = shared.sd_model
@@ -58,11 +59,11 @@ class Script(scripts_manager.Script):
orig_prompt_attention = shared.opts.prompt_attention
# create pipeline
if shared.sd_model_type != 'sd':
shared.log.error(f'Mixture tiling: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'Mixture tiling: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
shared.sd_model = sd_models.switch_pipe('mixture_tiling', shared.sd_model)
if shared.sd_model.__class__.__name__ != 'StableDiffusionTilingPipeline': # switch failed
shared.log.error(f'Mixture tiling: not a tiling pipeline: {shared.sd_model.__class__.__name__}')
logger.log.error(f'Mixture tiling: not a tiling pipeline: {shared.sd_model.__class__.__name__}')
shared.sd_model = orig_pipeline
return None
sd_models.set_diffuser_options(shared.sd_model)
@@ -84,7 +85,7 @@ class Script(scripts_manager.Script):
p.task_args['tile_row_overlap'] = int(p.width * y_overlap)
p.task_args['output_type'] = 'np'
# run pipeline
shared.log.debug(f'Tiling: args={p.task_args}')
logger.log.debug(f'Tiling: args={p.task_args}')
processed: processing.Processed = processing.process_images(p) # runs processing using main loop
# restore pipeline and params
shared.opts.data['prompt_attention'] = orig_prompt_attention
scripts/mulan.py
+5 -4
View File
@@ -25,6 +25,7 @@ Examples:
import gradio as gr
from modules import shared, scripts_manager, processing, devices
from modules import logger
ENCODERS =[
@@ -64,7 +65,7 @@ class Script(scripts_manager.Script):
return None
# create pipeline
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
shared.log.error(f'MuLan: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'MuLan: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
adapter_path = None
@@ -100,21 +101,21 @@ class Script(scripts_manager.Script):
adapter = None
if text_encoder is None or tokenizer is None or text_encoder_path != selected_encoder:
text_encoder_path = selected_encoder
shared.log.debug(f'MuLan loading: encoder="{text_encoder_path}"')
logger.log.debug(f'MuLan loading: encoder="{text_encoder_path}"')
text_encoder = None
tokenizer = None
devices.torch_gc(force=True)
text_encoder, tokenizer = mulankit.api.load_internvl(text_encoder_path, text_encoder, tokenizer, torch_dtype=shared.sd_model.text_encoder.dtype)
devices.torch_gc(force=True)
if adapter is None:
shared.log.debug(f'MuLan loading: adapter="{adapter_path}"')
logger.log.debug(f'MuLan loading: adapter="{adapter_path}"')
adapter = None
devices.torch_gc(force=True)
adapter = mulankit.api.load_adapter(adapter_path, type=pipe_type)
devices.torch_gc(force=True)
if not getattr(shared.sd_model, 'mulan', False):
shared.log.info(f'MuLan apply: adapter="{adapter_path}" encoder="{text_encoder_path}"')
logger.log.info(f'MuLan apply: adapter="{adapter_path}" encoder="{text_encoder_path}"')
# mulankit.setup(force_sdxl_zero_empty_prompt=False, force_sdxl_zero_pool_prompt=False)
shared.sd_model = mulankit.transform(shared.sd_model,
adapter=adapter,
scripts/nudenet/imageguard.py
+4 -3
View File
@@ -1,3 +1,4 @@
from modules import logger
repo_id = 'AIML-TUDA/LlavaGuard-v1.2-0.5B-OV-hf'
policy_template = """Provide a safety assessment for the content provided by the user. Determine compliance or violation against our safety policy by reviewing the following policy categories:
Hate:
@@ -109,7 +110,7 @@ def image_guard(image, policy:str=None) -> str:
cache_dir=shared.opts.hfcache_dir,
)
processor = transformers.AutoProcessor.from_pretrained(repo_id, cache_dir=shared.opts.hfcache_dir)
shared.log.info(f'NudeNet load: model="{repo_id}"')
logger.log.info(f'NudeNet load: model="{repo_id}"')
if policy is None or len(policy) < 10:
policy = policy_template
chat_template = [
@@ -139,9 +140,9 @@ def image_guard(image, policy:str=None) -> str:
result = processor.decode(results[0], skip_special_tokens=True)
result = result.split('assistant', 1)[-1].strip()
data = json.loads(result)
shared.log.debug(f'NudeNet LlavaGuard: {data}')
logger.log.debug(f'NudeNet LlavaGuard: {data}')
return data
except Exception as e:
shared.log.error(f'NudeNet LlavaGuard: {e}')
logger.log.error(f'NudeNet LlavaGuard: {e}')
errors.display(e, 'LlavaGuard')
return {'error': str(e)}
scripts/nudenet/langdetect.py
+4 -3
View File
@@ -1,3 +1,4 @@
from modules import logger
repo_id = "facebook/fasttext-language-identification"
model = None
@@ -12,13 +13,13 @@ def lang_detect(text:str, top:int=1, threshold:float=0.25) -> str:
import fasttext
from huggingface_hub import hf_hub_download
model_path = hf_hub_download(repo_id, filename="model.bin", cache_dir=shared.opts.hfcache_dir)
shared.log.info(f'NudeNet load: model="{repo_id}"')
logger.log.info(f'NudeNet load: model="{repo_id}"')
model = fasttext.load_model(model_path)
text = text.replace('\n', '. ')
lang, score = model.predict(text, k=top, threshold=threshold, on_unicode_error="ignore")
result = [f'{l.replace("__label__", "").lower()}:{s:.2f}' for l, s in zip(lang, score) if s > threshold][:top]
shared.log.debug(f'NudeNet LangDetect: {result}')
logger.log.debug(f'NudeNet LangDetect: {result}')
return result
except Exception as e:
shared.log.error(f'NudeNet LangDetect: {e}')
logger.log.error(f'NudeNet LangDetect: {e}')
return str(e)
scripts/pixelsmith_ext.py
+4 -3
View File
@@ -1,6 +1,7 @@
import gradio as gr
from PIL import Image
from modules import scripts_manager, processing, shared, sd_models, devices, images
from modules import logger
class Script(scripts_manager.Script):
@@ -37,14 +38,14 @@ class Script(scripts_manager.Script):
with devices.inference_context():
latent = shared.sd_model.vae.tiled_encode(tensor)
latent = shared.sd_model.vae.config.scaling_factor * latent.latent_dist.sample()
shared.log.info(f'PixelSmith encode: image={image} latent={latent.shape} width={p.width} height={p.height} vae={shared.sd_model.vae.__class__.__name__}')
logger.log.info(f'PixelSmith encode: image={image} latent={latent.shape} width={p.width} height={p.height} vae={shared.sd_model.vae.__class__.__name__}')
return latent
def run(self, p: processing.StableDiffusionProcessing, slider: int = 20): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'PixelSmith: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'PixelSmith: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
from scripts.pixelsmith import PixelSmithXLPipeline, PixelSmithVAE # pylint: disable=no-name-in-module
self.orig_pipe = shared.sd_model
self.orig_vae = shared.sd_model.vae
@@ -60,7 +61,7 @@ class Script(scripts_manager.Script):
if hasattr(p, 'init_images') and p.init_images is not None and len(p.init_images) > 0:
p.task_args['image'] = self.encode(p, p.init_images[0])
p.init_images = None
shared.log.info(f'PixelSmith apply: slider={slider} class={shared.sd_model.__class__.__name__} vae={shared.sd_model.vae.__class__.__name__}')
logger.log.info(f'PixelSmith apply: slider={slider} class={shared.sd_model.__class__.__name__} vae={shared.sd_model.vae.__class__.__name__}')
# processed = processing.process_images(p)
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, slider): # pylint: disable=unused-argument
scripts/postprocessing_upscale.py
+4 -3
View File
@@ -3,6 +3,7 @@ import gradio as gr
from modules import scripts_postprocessing, shared
from modules.ui_components import ToolButton
import modules.ui_symbols as symbols
from modules import logger
class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
@@ -69,7 +70,7 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_1_name]), None)
if not upscaler1:
if upscaler_1_name is not None:
shared.log.warning(f"Could not find upscaler: {upscaler_1_name or '<empty string>'}")
logger.log.warning(f"Could not find upscaler: {upscaler_1_name or '<empty string>'}")
return
upscaled_image = self.upscale(pp.image, pp.info, upscaler1, upscale_mode, upscale_by, upscale_to_width, upscale_to_height, upscale_crop)
pp.info["Postprocess upscaler"] = upscaler1.name
@@ -78,7 +79,7 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
upscaler_2_name = None
upscaler2 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_2_name and x.name != "None"]), None)
if not upscaler2 and (upscaler_2_name is not None):
shared.log.warning(f"Could not find upscaler: {upscaler_2_name or '<empty string>'}")
logger.log.warning(f"Could not find upscaler: {upscaler_2_name or '<empty string>'}")
if upscaler2 and upscaler_2_visibility > 0:
second_upscale = self.upscale(pp.image, pp.info, upscaler2, upscale_mode, upscale_by, upscale_to_width, upscale_to_height, upscale_crop)
upscaled_image = Image.blend(upscaled_image, second_upscale, upscaler_2_visibility)
@@ -108,6 +109,6 @@ class ScriptPostprocessingUpscaleSimple(ScriptPostprocessingUpscale):
return
upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_name]), None)
if upscaler1 is None:
shared.log.debug(f"Upscaler not found: {upscaler_name}")
logger.log.debug(f"Upscaler not found: {upscaler_name}")
pp.image = self.upscale(pp.image, pp.info, upscaler1, 0, upscale_by, 0, 0, False)
pp.info["Postprocess upscaler"] = upscaler1.name
scripts/prompt_enhance.py
+18 -17
View File
@@ -11,10 +11,11 @@ import gradio as gr
from PIL import Image
from modules import scripts_manager, shared, devices, errors, processing, sd_models, sd_modules, timer, ui_symbols
from modules import ui_control_helpers
from modules import logger
debug_enabled = os.environ.get('SD_LLM_DEBUG', None) is not None
debug_log = shared.log.trace if debug_enabled else lambda *args, **kwargs: None
debug_log = logger.log.trace if debug_enabled else lambda *args, **kwargs: None
def b64(image):
@@ -203,7 +204,7 @@ class Script(scripts_manager.Script):
# Strip symbols from display name if present
name = get_model_repo_from_display(name) if name else self.options.default
if self.busy:
shared.log.debug('Prompt enhance: busy')
logger.log.debug('Prompt enhance: busy')
return
self.busy = True
if self.model is not None and self.model == name:
@@ -223,8 +224,8 @@ class Script(scripts_manager.Script):
if model_type is not None and model_file is not None and len(model_type) > 2 and len(model_file) > 2:
debug_log(f'Prompt enhance: gguf supported={self.options.supported}')
if model_type not in self.options.supported:
shared.log.error(f'Prompt enhance: name="{name}" repo="{model_repo}" fn="{model_file}" type={model_type} gguf not supported')
shared.log.trace(f'Prompt enhance: gguf supported={self.options.supported}')
logger.log.error(f'Prompt enhance: name="{name}" repo="{model_repo}" fn="{model_file}" type={model_type} gguf not supported')
logger.log.trace(f'Prompt enhance: gguf supported={self.options.supported}')
self.busy = False
return
ggml.install_gguf()
@@ -237,7 +238,7 @@ class Script(scripts_manager.Script):
t0 = time.time()
if self.llm is not None:
self.llm = None
shared.log.debug(f'Prompt enhance: name="{self.model}" unload')
logger.log.debug(f'Prompt enhance: name="{self.model}" unload')
self.model = None
load_args = { 'pretrained_model_name_or_path': model_repo if not gguf_args else model_gguf }
if model_subfolder:
@@ -281,10 +282,10 @@ class Script(scripts_manager.Script):
debug_log(f'Prompt enhance: {m}')
self.model = name
t1 = time.time()
shared.log.info(f'Prompt enhance: cls={self.llm.__class__.__name__} name="{name}" repo="{model_repo}" fn="{model_file}" time={t1-t0:.2f} loaded')
logger.log.info(f'Prompt enhance: cls={self.llm.__class__.__name__} name="{name}" repo="{model_repo}" fn="{model_file}" time={t1-t0:.2f} loaded')
self.compile()
except Exception as e:
shared.log.error(f'Prompt enhance: load {e}')
logger.log.error(f'Prompt enhance: load {e}')
errors.display(e, 'Prompt enhance')
devices.torch_gc()
self.busy = False
@@ -296,15 +297,15 @@ class Script(scripts_manager.Script):
def unload(self):
if self.llm is not None:
model_name = self.model
shared.log.debug(f'Prompt enhance: unloading model="{model_name}"')
logger.log.debug(f'Prompt enhance: unloading model="{model_name}"')
sd_models.move_model(self.llm, devices.cpu, force=True)
self.model = None
self.llm = None
self.tokenizer = None
devices.torch_gc(force=True, reason='prompt enhance unload')
shared.log.debug(f'Prompt enhance: model="{model_name}" unloaded')
logger.log.debug(f'Prompt enhance: model="{model_name}" unloaded')
else:
shared.log.debug('Prompt enhance: no model loaded')
logger.log.debug('Prompt enhance: no model loaded')
def clean(self, response, keep_thinking=False, prefill_text='', keep_prefill=False):
# Handle thinking tags FIRST (before generic tag removal)
@@ -413,7 +414,7 @@ class Script(scripts_manager.Script):
seed = int(random.randrange(4294967294))
torch.manual_seed(seed)
if self.llm is None:
shared.log.error('Prompt enhance: model not loaded')
logger.log.error('Prompt enhance: model not loaded')
return prompt
prompt_text, networks = self.extract(prompt) # Use prompt_text after extraction
debug_log(f'Prompt enhance: networks={networks}')
@@ -440,7 +441,7 @@ class Script(scripts_manager.Script):
# Check if vision was requested but no image is available
if use_vision and is_vision_model(model) and current_image is None:
shared.log.error(f'Prompt enhance: model="{model}" error="No input image provided"')
logger.log.error(f'Prompt enhance: model="{model}" error="No input image provided"')
return 'Error: No input image provided. Please upload or select an image.'
# Resize large images to match VQA performance (Qwen3-VL performance is sensitive to resolution)
@@ -466,7 +467,7 @@ class Script(scripts_manager.Script):
if current_image is not None and isinstance(current_image, Image.Image):
if (self.tokenizer is None) or (not self.tokenizer.is_processor):
shared.log.error('Prompt enhance: image not supported by model')
logger.log.error('Prompt enhance: image not supported by model')
return prompt_text # Return original text part if image cannot be processed
if prompt_text is not None and len(prompt_text) > 0:
if not has_system:
@@ -573,7 +574,7 @@ class Script(scripts_manager.Script):
input_len = inputs['input_ids'].shape[1]
debug_log(f'Prompt enhance: input_len={input_len} input_ids_shape={inputs["input_ids"].shape} sample={sample} temp={temperature} penalty={penalty} max_tokens={tokens}')
except Exception as e:
shared.log.error(f'Prompt enhance tokenize: {e}')
logger.log.error(f'Prompt enhance tokenize: {e}')
errors.display(e, 'Prompt enhance')
self.busy = False
return prompt_text # Return original text part on error
@@ -605,7 +606,7 @@ class Script(scripts_manager.Script):
debug_log(f'Prompt enhance: response_before_clean="{response_before_clean}"')
except Exception as e:
outputs = None
shared.log.error(f'Prompt enhance generate: {e}')
logger.log.error(f'Prompt enhance generate: {e}')
errors.display(e, 'Prompt enhance')
self.busy = False
response = f'Error: {str(e)}'
@@ -617,12 +618,12 @@ class Script(scripts_manager.Script):
if not is_censored:
response = self.clean(response, keep_thinking=keep_thinking, prefill_text=prefill_text, keep_prefill=keep_prefill)
response = self.post(response, prefix, suffix, networks)
shared.log.info(f'Prompt enhance: model="{model}" nsfw={nsfw} time={t1-t0:.2f} seed={seed} sample={sample} temperature={temperature} penalty={penalty} thinking={thinking} keep_thinking={keep_thinking} prefill="{prefill_text[:20] if prefill_text else ""}" keep_prefill={keep_prefill} tokens={tokens} inputs={input_len} outputs={outputs.shape[-1] if isinstance(outputs, torch.Tensor) else 0} prompt={len(prompt_text)} response={len(response)}')
logger.log.info(f'Prompt enhance: model="{model}" nsfw={nsfw} time={t1-t0:.2f} seed={seed} sample={sample} temperature={temperature} penalty={penalty} thinking={thinking} keep_thinking={keep_thinking} prefill="{prefill_text[:20] if prefill_text else ""}" keep_prefill={keep_prefill} tokens={tokens} inputs={input_len} outputs={outputs.shape[-1] if isinstance(outputs, torch.Tensor) else 0} prompt={len(prompt_text)} response={len(response)}')
debug_log(f'Prompt enhance: prompt="{prompt_text}"')
debug_log(f'Prompt enhance: response_after_clean="{response}"')
self.busy = False
if is_censored:
shared.log.warning(f'Prompt enhance: censored response="{response}"')
logger.log.warning(f'Prompt enhance: censored response="{response}"')
return prompt # Return original full prompt on censorship
return response
scripts/pulid/pulid_flux.py
+3 -2
View File
@@ -2,11 +2,12 @@ from types import MethodType
import accelerate
from diffusers import FluxPipeline
from modules import shared, sd_models
from modules import logger
def apply_flux(pipe: FluxPipeline):
if not hasattr(pipe, 'transformer') or not 'Nunchaku' in pipe.transformer.__class__.__name__:
shared.log.error('PuLID: flux support requires nunchaku')
logger.log.error('PuLID: flux support requires nunchaku')
return pipe
from nunchaku.pipeline.pipeline_flux_pulid import PuLIDFluxPipeline
@@ -19,7 +20,7 @@ def apply_flux(pipe: FluxPipeline):
pipe.transformer.forward = MethodType(pulid_forward, pipe.transformer)
pipe = sd_models.apply_balanced_offload(pipe)
pipe.pulid_model = sd_models.apply_balanced_offload(pipe.pulid_model)
shared.log.info(f'PuLID: flux applied cls={pipe.__class__.__name__} pipe={pipe.pulid_model.__class__.__name__}')
logger.log.info(f'PuLID: flux applied cls={pipe.__class__.__name__} pipe={pipe.pulid_model.__class__.__name__}')
return pipe
scripts/pulid_ext.py
+16 -15
View File
@@ -5,6 +5,7 @@ import contextlib
import gradio as gr
from PIL import Image
from modules import shared, devices, errors, scripts_manager, processing, processing_helpers, sd_models
from modules import logger
debug = os.environ.get('SD_PULID_DEBUG', None) is not None
@@ -79,7 +80,7 @@ class Script(scripts_manager.Script):
raise ValueError(f'IP adapter unknown input: {file}')
uploaded_images.append(image)
except Exception as e:
shared.log.warning(f'IP adapter failed to load image: {e}')
logger.log.warning(f'IP adapter failed to load image: {e}')
return gr.update(value=uploaded_images, visible=len(uploaded_images) > 0)
# return signature is array of gradio components
@@ -132,15 +133,15 @@ class Script(scripts_manager.Script):
images = gallery
images = [np.array(image) for image in images]
except Exception as e:
shared.log.error(f'PuLID: failed to load images: {e}')
logger.log.error(f'PuLID: failed to load images: {e}')
return None
if len(images) == 0:
shared.log.error('PuLID: no images')
logger.log.error('PuLID: no images')
return None
supported_model_list = ['sdxl', 'f1']
if shared.sd_model_type not in supported_model_list:
shared.log.error(f'PuLID: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.error(f'PuLID: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
if self.pulid is None:
self.dependencies()
@@ -152,20 +153,20 @@ class Script(scripts_manager.Script):
pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING["pulid"] = pulid.StableDiffusionXLPuLIDPipelineImage
pipelines.auto_pipeline.AUTO_INPAINT_PIPELINES_MAPPING["pulid"] = pulid.StableDiffusionXLPuLIDPipelineInpaint
except Exception as e:
shared.log.error(f'PuLID: failed to import library: {e}')
logger.log.error(f'PuLID: failed to import library: {e}')
return None
if self.pulid is None:
shared.log.error('PuLID: failed to load PuLID library')
logger.log.error('PuLID: failed to load PuLID library')
return None
try:
images = [self.pulid.resize(image, 1024) for image in images]
except Exception as e:
shared.log.error(f'PuLID: failed to resize images: {e}')
logger.log.error(f'PuLID: failed to resize images: {e}')
return None
if p.batch_size > 1:
shared.log.warning('PuLID: batch size not supported')
logger.log.warning('PuLID: batch size not supported')
p.batch_size = 1
sdp = shared.opts.cross_attention_optimization == "Scaled-Dot-Product"
@@ -198,7 +199,7 @@ class Script(scripts_manager.Script):
# shared.sd_model.hack_unet_attn_layers(shared.sd_model.pipe.unet) # reapply attention layers
devices.torch_gc()
except Exception as e:
shared.log.error(f'PuLID: failed to create pipeline: {e}')
logger.log.error(f'PuLID: failed to create pipeline: {e}')
errors.display(e, 'PuLID')
return None
elif shared.sd_model_type == 'f1':
@@ -209,7 +210,7 @@ class Script(scripts_manager.Script):
elif shared.sd_model_type == 'f1':
processed = self.run_flux(p, images, strength)
else:
shared.log.error(f'PuLID: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.error(f'PuLID: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
processed = None
return processed
@@ -226,13 +227,13 @@ class Script(scripts_manager.Script):
shared.sd_model.handler_ante = None
shared.sd_model = shared.sd_model.pipe
devices.torch_gc(force=True, reason='pulid')
shared.log.debug(f'PuLID complete: class={shared.sd_model.__class__.__name__} preprocess={self.preprocess:.2f} pipe={"restore" if restore else "cache"}')
logger.log.debug(f'PuLID complete: class={shared.sd_model.__class__.__name__} preprocess={self.preprocess:.2f} pipe={"restore" if restore else "cache"}')
if shared.sd_model_type == "f1":
restore = getattr(p, 'pulid_restore', restore)
if restore:
shared.sd_model = self.pulid.unapply_flux(shared.sd_model)
devices.torch_gc(force=True, reason='pulid')
shared.log.debug(f'PuLID complete: class={shared.sd_model.__class__.__name__} pipe={"restore" if restore else "cache"}')
logger.log.debug(f'PuLID complete: class={shared.sd_model.__class__.__name__} pipe={"restore" if restore else "cache"}')
return processed
def run_sdxl(self, p: processing.StableDiffusionProcessing, images: list, strength: float, zero: int, sampler: str, ortho: str, restore: bool, offload: bool, version: str):
@@ -240,7 +241,7 @@ class Script(scripts_manager.Script):
if sampler_fn is None:
sampler_fn = self.pulid.sampling.sample_dpmpp_2m_sde
shared.sd_model.sampler = sampler_fn
shared.log.info(f'PuLID: class={shared.sd_model.__class__.__name__} version="{version}" strength={strength} zero={zero} ortho={ortho} sampler={sampler_fn} images={[i.shape for i in images]} offload={offload} restore={restore}')
logger.log.info(f'PuLID: class={shared.sd_model.__class__.__name__} version="{version}" strength={strength} zero={zero} ortho={ortho} sampler={sampler_fn} images={[i.shape for i in images]} offload={offload} restore={restore}')
self.pulid.attention.NUM_ZERO = zero
self.pulid.attention.ORTHO = ortho == 'v1'
self.pulid.attention.ORTHO_v2 = ortho == 'v2'
@@ -289,14 +290,14 @@ class Script(scripts_manager.Script):
processed: processing.Processed = processing.process_images(p) # runs processing using main loop
# interim = [Image.fromarray(img) for img in shared.sd_model.debug_img_list]
# shared.log.debug(f'PuLID: time={t1-t0:.2f}')
# logger.log.debug(f'PuLID: time={t1-t0:.2f}')
return processed
def run_flux(self, p: processing.StableDiffusionProcessing, images: list, strength: float):
image = Image.fromarray(images[0]) # takes single pil image
p.task_args['id_image'] = image
p.task_args['id_weight'] = strength
shared.log.info(f'PuLID: class={shared.sd_model.__class__.__name__} strength={strength} image={image}')
logger.log.info(f'PuLID: class={shared.sd_model.__class__.__name__} strength={strength} image={image}')
p.extra_generation_params["PuLID"] = f'Strength={strength}'
processed: processing.Processed = processing.process_images(p) # runs processing using main loop
scripts/regional_prompting.py
+4 -3
View File
@@ -4,6 +4,7 @@
import gradio as gr
from diffusers.pipelines import pipeline_utils
from modules import shared, devices, scripts_manager, processing, sd_models, prompt_parser_diffusers
from modules import logger
def hijack_register_modules(self, **kwargs):
@@ -52,7 +53,7 @@ class Script(scripts_manager.Script):
orig_prompt_attention = shared.opts.prompt_attention
# create pipeline
if shared.sd_model_type != 'sd':
shared.log.error(f'Regional prompting: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'Regional prompting: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
pipeline_utils.DiffusionPipeline.register_modules = hijack_register_modules
@@ -60,7 +61,7 @@ class Script(scripts_manager.Script):
shared.sd_model = sd_models.switch_pipe('regional_prompting_stable_diffusion', shared.sd_model)
if shared.sd_model.__class__.__name__ != 'RegionalPromptingStableDiffusionPipeline': # switch failed
shared.log.error(f'Regional prompting: not a tiling pipeline: {shared.sd_model.__class__.__name__}')
logger.log.error(f'Regional prompting: not a tiling pipeline: {shared.sd_model.__class__.__name__}')
shared.sd_model = orig_pipeline
return None
sd_models.set_diffuser_options(shared.sd_model)
@@ -81,7 +82,7 @@ class Script(scripts_manager.Script):
'rp_args': rp_args,
}
# run pipeline
shared.log.debug(f'Regional: args={p.task_args}')
logger.log.debug(f'Regional: args={p.task_args}')
p.task_args['prompt'] = p.prompt
processed: processing.Processed = processing.process_images(p) # runs processing using main loop
scripts/resadapter.py
+4 -3
View File
@@ -2,6 +2,7 @@ from safetensors.torch import load_file
from huggingface_hub import hf_hub_download
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models, devices
from modules import logger
repo = 'jiaxiangc/res-adapter'
@@ -38,11 +39,11 @@ class Script(scripts_manager.Script):
return None
if shared.sd_model_type == 'sd':
if not model.startswith('SD15'):
shared.log.warning(f'ResAdapter: pipeline={shared.sd_model_type} selected={model}')
logger.log.warning(f'ResAdapter: pipeline={shared.sd_model_type} selected={model}')
return None
if shared.sd_model_type == 'sdxl':
if not model.startswith('SDXL'):
shared.log.warning(f'ResAdapter: pipeline={shared.sd_model_type} selected={model}')
logger.log.warning(f'ResAdapter: pipeline={shared.sd_model_type} selected={model}')
return None
old_pipe = shared.sd_model
@@ -51,7 +52,7 @@ class Script(scripts_manager.Script):
shared.sd_model.unet.load_state_dict(load_file(hf_hub_download(repo_id=repo, subfolder=models[model], filename="diffusion_pytorch_model.safetensors")), strict=False)
sd_models.move_model(shared.sd_model, devices.device) # move pipeline to device
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
shared.log.debug(f'ResAdapter: pipeline={shared.sd_model.__class__.__name__} model="{model}" weight={weight} file="{models[model]}"')
logger.log.debug(f'ResAdapter: pipeline={shared.sd_model.__class__.__name__} model="{model}" weight={weight} file="{models[model]}"')
processed = processing.process_images(p)
shared.sd_model = old_pipe
return processed
scripts/skip_layer_guidance.py
+3 -2
View File
@@ -1,6 +1,7 @@
import sys
import gradio as gr
from modules import scripts_manager, processing, shared
from modules import logger
registered = False
@@ -41,7 +42,7 @@ class Script(scripts_manager.Script):
except Exception:
return
if len(val) > 0:
shared.log.debug(f'SLG: {field}={val}')
logger.log.debug(f'SLG: {field}={val}')
p.task_args[field] = val
return fun
@@ -70,4 +71,4 @@ class Script(scripts_manager.Script):
if len(parsed) == 0:
return
p.task_args['skip_guidance_layers'] = parsed
shared.log.info(f'SLG: layers={parsed} scale={scale} start={start} stop={stop}')
logger.log.info(f'SLG: layers={parsed} scale={scale} start={start} stop={stop}')
scripts/softfill.py
+7 -6
View File
@@ -1605,6 +1605,7 @@ class StableDiffusionXLSoftFillPipeline(
import gradio as gr
from installer import install
from modules import shared, scripts_manager, processing, sd_models
from modules import logger
class Script(scripts_manager.Script):
@@ -1630,13 +1631,13 @@ class Script(scripts_manager.Script):
if not enabled:
return
if shared.sd_model_type not in ['sdxl']:
shared.log.error(f'SoftFill: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'SoftFill: incorrect base model: {shared.sd_model.__class__.__name__}')
return
if not hasattr(p, 'init_images') or len(p.init_images) == 0:
shared.log.error('SoftFill: no input image')
logger.log.error('SoftFill: no input image')
return
if not hasattr(p, 'mask') or p.mask is None:
shared.log.error('SoftFill: no input mask')
logger.log.error('SoftFill: no input mask')
return
try:
@@ -1645,7 +1646,7 @@ class Script(scripts_manager.Script):
import noise as noise_module
pnoise2 = noise_module.pnoise2
except Exception as e:
shared.log.error(f'SoftFill: {e}')
logger.log.error(f'SoftFill: {e}')
return
self.orig_pipeline = shared.sd_model
@@ -1654,7 +1655,7 @@ class Script(scripts_manager.Script):
if shared.sd_model.__class__.__name__ not in sd_models.pipe_switch_task_exclude:
sd_models.pipe_switch_task_exclude.append(shared.sd_model.__class__.__name__)
except Exception as e:
shared.log.error(f'SoftFill: {e}')
logger.log.error(f'SoftFill: {e}')
shared.sd_model = self.orig_pipeline
self.orig_pipeline = None
return
@@ -1663,7 +1664,7 @@ class Script(scripts_manager.Script):
p.task_args['strength'] = strength
p.task_args['image'] = p.init_images[0]
p.task_args['mask'] = p.mask
shared.log.info(f'SoftFill: cls={shared.sd_model.__class__.__name__} {p.task_args}')
logger.log.info(f'SoftFill: cls={shared.sd_model.__class__.__name__} {p.task_args}')
def after(self, p: processing.StableDiffusionProcessingImg2Img, *args, **kwargs): # pylint: disable=unused-argument
if self.orig_pipeline is not None:
scripts/stablevideodiffusion.py
+6 -5
View File
@@ -6,6 +6,7 @@ import os
import torch
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models, images, modelloader
from modules import logger
models = {
@@ -44,7 +45,7 @@ class Script(scripts_manager.Script):
def _encode_image(self, image: torch.Tensor, device, num_videos_per_prompt, do_classifier_free_guidance):
image = image.to(device=device, dtype=shared.sd_model.vae.dtype)
shared.log.debug(f'Video encode: type=svd input={image.shape} dtype={image.dtype} device={image.device}')
logger.log.debug(f'Video encode: type=svd input={image.shape} dtype={image.dtype} device={image.device}')
image_latents = shared.sd_model.vae.encode(image).latent_dist.mode()
image_latents = image_latents.repeat(num_videos_per_prompt, 1, 1, 1)
if do_classifier_free_guidance:
@@ -53,7 +54,7 @@ class Script(scripts_manager.Script):
return image_latents
def _decode_latents(self, latents: torch.Tensor, num_frames: int, decode_chunk_size: int = 14):
shared.log.debug(f'Video decode: type=svd input={latents.shape} dtype={latents.dtype} device={latents.device} chunk={decode_chunk_size} frames={num_frames}')
logger.log.debug(f'Video decode: type=svd input={latents.shape} dtype={latents.dtype} device={latents.device} chunk={decode_chunk_size} frames={num_frames}')
latents = latents.flatten(0, 1)
latents = 1 / shared.sd_model.vae.config.scaling_factor * latents
frames = []
@@ -70,7 +71,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, model, num_frames, override_resolution, min_guidance_scale, max_guidance_scale, decode_chunk_size, motion_bucket_id, noise_aug_strength, video_type, duration, gif_loop, mp4_pad, mp4_interpolate): # pylint: disable=arguments-differ, unused-argument
image = getattr(p, 'init_images', None)
if image is None or len(image) == 0:
shared.log.error('SVD: no init_images')
logger.log.error('SVD: no init_images')
return None
else:
image = image[0]
@@ -80,7 +81,7 @@ class Script(scripts_manager.Script):
model_name = os.path.basename(model_path)
has_checkpoint = sd_models.get_closest_checkpoint_match(model_path)
if has_checkpoint is None:
shared.log.error(f'SVD: no checkpoint for {model_name}')
logger.log.error(f'SVD: no checkpoint for {model_name}')
modelloader.load_reference(model_path, variant='fp16')
c = shared.sd_model.__class__.__name__
model_loaded = shared.sd_model.sd_checkpoint_info.model_name if shared.sd_loaded else None
@@ -115,7 +116,7 @@ class Script(scripts_manager.Script):
p.task_args['num_inference_steps'] = p.steps
p.task_args['min_guidance_scale'] = min_guidance_scale
p.task_args['max_guidance_scale'] = max_guidance_scale
shared.log.debug(f'SVD: args={p.task_args}')
logger.log.debug(f'SVD: args={p.task_args}')
# run processing
processed = processing.process_images(p)
scripts/style_aligned_ext.py
+5 -4
View File
@@ -3,6 +3,7 @@ import torch
import numpy as np
import diffusers
from modules import scripts_manager, processing, shared, devices
from modules import logger
handler = None
@@ -22,7 +23,7 @@ class Script(scripts_manager.Script):
global handler, zts # pylint: disable=global-statement
handler = None
zts = None
shared.log.info('SA: image upload')
logger.log.info('SA: image upload')
def preset(self, preset):
if preset == 'text':
@@ -61,7 +62,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, image, prompt, scheduler, shared_opts, shared_score_scale, shared_score_shift, only_self_level): # pylint: disable=arguments-differ
global handler, zts, orig_prompt_attention # pylint: disable=global-statement
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'SA: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'SA: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
from scripts.style_aligned import sa_handler, inversion # pylint: disable=no-name-in-module
@@ -86,7 +87,7 @@ class Script(scripts_manager.Script):
p.sampler_name = 'None'
if image is not None and zts is None:
shared.log.info(f'SA: inversion image={image} prompt="{prompt}"')
logger.log.info(f'SA: inversion image={image} prompt="{prompt}"')
image = image.resize((1024, 1024))
x0 = np.array(image).astype(np.float32) / 255.0
shared.sd_model.scheduler = diffusers.DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", clip_sample=False, set_alpha_to_one=False)
@@ -107,7 +108,7 @@ class Script(scripts_manager.Script):
p.task_args['latents'] = latents
p.task_args['callback_on_step_end'] = inversion_callback
shared.log.info(f'SA: batch={p.batch_size} type={"image" if zts is not None else "text"} config={sa_args.__dict__}')
logger.log.info(f'SA: batch={p.batch_size} type={"image" if zts is not None else "text"} config={sa_args.__dict__}')
return None
def after(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=unused-argument
scripts/t_gate.py
+3 -2
View File
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models, devices
from modules import logger
from installer import install
@@ -31,14 +32,14 @@ class Script(scripts_manager.Script):
elif shared.sd_model_type == 'sdxl':
cls = tgate.TgateSDXLLoader
else:
shared.log.warning(f'T-Gate: pipeline={shared.sd_model_type} required=sd or sdxl')
logger.log.warning(f'T-Gate: pipeline={shared.sd_model_type} required=sd or sdxl')
return None
old_pipe = shared.sd_model
shared.sd_model = cls(shared.sd_model, gate_step=p.gate_step)
sd_models.copy_diffuser_options(shared.sd_model, old_pipe)
sd_models.move_model(shared.sd_model, devices.device) # move pipeline to device
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
shared.log.debug(f'T-Gate: pipeline={shared.sd_model.__class__.__name__} steps={p.gate_step}')
logger.log.debug(f'T-Gate: pipeline={shared.sd_model.__class__.__name__} steps={p.gate_step}')
processed = processing.process_images(p)
shared.sd_model = old_pipe
del shared.sd_model.tgate
scripts/text2video.py
+8 -7
View File
@@ -8,6 +8,7 @@ TODO text2video items:
import gradio as gr
from modules import scripts_manager, processing, shared, images, sd_models, modelloader
from modules import logger
MODELS = [
@@ -57,20 +58,20 @@ class Script(scripts_manager.Script):
if model_name == 'None':
return None
model = [m for m in MODELS if m['name'] == model_name][0]
shared.log.debug(f'Text2Video: model={model} defaults={use_default} frames={num_frames}, video={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
logger.log.debug(f'Text2Video: model={model} defaults={use_default} frames={num_frames}, video={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
if model['path'] in shared.opts.sd_model_checkpoint:
shared.log.debug(f'Text2Video cached: model={shared.opts.sd_model_checkpoint}')
logger.log.debug(f'Text2Video cached: model={shared.opts.sd_model_checkpoint}')
else:
checkpoint = sd_models.get_closest_checkpoint_match(model['path'])
if checkpoint is None:
shared.log.debug(f'Text2Video downloading: model={model["path"]}')
logger.log.debug(f'Text2Video downloading: model={model["path"]}')
checkpoint = modelloader.download_diffusers_model(hub_id=model['path'])
sd_models.list_models()
if checkpoint is None:
shared.log.error(f'Text2Video: failed to find model={model["path"]}')
logger.log.error(f'Text2Video: failed to find model={model["path"]}')
return None
shared.log.debug(f'Text2Video loading: model={checkpoint}')
logger.log.debug(f'Text2Video loading: model={checkpoint}')
shared.opts.sd_model_checkpoint = checkpoint.name
sd_models.reload_model_weights(op='model')
@@ -83,11 +84,11 @@ class Script(scripts_manager.Script):
elif num_frames > 0:
p.task_args['num_frames'] = num_frames
else:
shared.log.error('Text2Video: invalid number of frames')
logger.log.error('Text2Video: invalid number of frames')
return None
shared.sd_model = sd_models.set_diffuser_pipe(shared.sd_model, sd_models.DiffusersTaskType.TEXT_2_IMAGE)
shared.log.debug(f'Text2Video: args={p.task_args}')
logger.log.debug(f'Text2Video: args={p.task_args}')
processed = processing.process_images(p)
if video_type != 'None':
scripts/tiling.py
+3 -2
View File
@@ -7,6 +7,7 @@ from torch import Tensor
from torch.nn import functional as F
from torch.nn.modules.utils import _pair
from modules import scripts_manager, processing, shared
from modules import logger
modex = 'constant'
@@ -49,7 +50,7 @@ class Script(scripts_manager.Script):
global modex, modey # pylint: disable=global-statement
supported_model_list = ['sd', 'sdxl']
if shared.sd_model_type not in supported_model_list:
shared.log.warning(f'Tiling: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
logger.log.warning(f'Tiling: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
if not tilex and not tiley:
return None
@@ -70,7 +71,7 @@ class Script(scripts_manager.Script):
if hasattr(cl, '_conv_forward'):
cl._orig_conv_forward = cl._conv_forward # pylint: disable=protected-access
cl._conv_forward = asymmetricConv2DConvForward.__get__(cl, torch.nn.Conv2d) # pylint: disable=protected-access, no-value-for-parameter
shared.log.info(f'Tiling: x={tilex}:{numx} y={tiley}:{numy}')
logger.log.info(f'Tiling: x={tilex}:{numx} y={tiley}:{numy}')
return None
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, tilex:bool=False, numx:int=1, tiley:bool=False, numy:int=1): # pylint: disable=arguments-differ, unused-argument
scripts/xadapter_ext.py
+8 -7
View File
@@ -5,6 +5,7 @@ import diffusers
import gradio as gr
import huggingface_hub as hf
from modules import errors, shared, devices, scripts_manager, processing, sd_models, sd_samplers
from modules import logger
adapter = None
@@ -46,11 +47,11 @@ class Script(scripts_manager.Script):
else:
shared.opts.sd_model_refiner = model
if shared.sd_model_type != 'sdxl':
shared.log.error(f'X-Adapter: incorrect base model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'X-Adapter: incorrect base model: {shared.sd_model.__class__.__name__}')
return
if adapter is None:
shared.log.debug('X-Adapter: adapter loading')
logger.log.debug('X-Adapter: adapter loading')
adapter = Adapter_XL()
adapter_path = hf.hf_hub_download(repo_id='Lingmin-Ran/X-Adapter', filename='X_Adapter_v1.bin')
adapter_dict = torch.load(adapter_path)
@@ -61,7 +62,7 @@ class Script(scripts_manager.Script):
except Exception:
pass
if adapter is None:
shared.log.error('X-Adapter: adapter loading failed')
logger.log.error('X-Adapter: adapter loading failed')
return
sd_models.unload_model_weights(op='model')
@@ -75,7 +76,7 @@ class Script(scripts_manager.Script):
diffusers.models.UNet2DConditionModel = orig_unetcondmodel # unpatch diffusers
if shared.sd_refiner_type != 'sd':
shared.log.error(f'X-Adapter: incorrect adapter model: {shared.sd_model.__class__.__name__}')
logger.log.error(f'X-Adapter: incorrect adapter model: {shared.sd_model.__class__.__name__}')
return
# backup pipeline and params
@@ -84,7 +85,7 @@ class Script(scripts_manager.Script):
pipe = None
try:
shared.log.debug('X-Adapter: creating pipeline')
logger.log.debug('X-Adapter: creating pipeline')
pipe = StableDiffusionXLAdapterPipeline(
vae=shared.sd_model.vae,
text_encoder=shared.sd_model.text_encoder,
@@ -125,10 +126,10 @@ class Script(scripts_manager.Script):
pipe.scheduler = diffusers.DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
pipe.scheduler_sd1_5 = diffusers.DPMSolverMultistepScheduler.from_config(pipe.scheduler_sd1_5.config)
pipe.scheduler_sd1_5.config.timestep_spacing = "leading"
shared.log.debug(f'X-Adapter: pipeline={pipe.__class__.__name__} args={p.task_args}')
logger.log.debug(f'X-Adapter: pipeline={pipe.__class__.__name__} args={p.task_args}')
shared.sd_model = pipe
except Exception as e:
shared.log.error(f'X-Adapter: pipeline creation failed: {e}')
logger.log.error(f'X-Adapter: pipeline creation failed: {e}')
errors.display(e, 'X-Adapter: pipeline creation failed')
shared.sd_model = orig_pipeline
scripts/xyz/xyz_grid_draw.py
+7 -6
View File
@@ -2,6 +2,7 @@ import time
from copy import copy
from PIL import Image
from modules import shared, images, processing
from modules import logger
from modules.image.util import draw_text
@@ -18,7 +19,7 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
def process_cell(x, y, z, ix, iy, iz):
nonlocal processed_result, i
i += 1
shared.log.debug(f'XYZ grid process: x={ix+1}/{len(xs)} y={iy+1}/{len(ys)} z={iz+1}/{len(zs)} total={i/list_size:.2f}')
logger.log.debug(f'XYZ grid process: x={ix+1}/{len(xs)} y={iy+1}/{len(ys)} z={iz+1}/{len(zs)} total={i/list_size:.2f}')
def index(ix, iy, iz):
return ix + iy * len(xs) + iz * len(xs) * len(ys)
@@ -29,7 +30,7 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
if processed_result is None:
processed_result = copy(processed)
if processed_result is None:
shared.log.error('XYZ grid: no processing results')
logger.log.error('XYZ grid: no processing results')
return processing.Processed(p, [])
processed_result.images = [None] * list_size
processed_result.all_prompts = [None] * list_size
@@ -97,10 +98,10 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
process_cell(x, y, z, ix, iy, iz)
if not processed_result:
shared.log.error("XYZ grid: failed to initialize processing")
logger.log.error("XYZ grid: failed to initialize processing")
return processing.Processed(p, [])
elif not any(processed_result.images):
shared.log.error("XYZ grid: failed to return processed image")
logger.log.error("XYZ grid: failed to return processed image")
return processing.Processed(p, [])
t1 = time.time()
@@ -111,7 +112,7 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
to_process = processed_result.images[idx0:idx1]
w, h = max(i.width for i in to_process if i is not None), max(i.height for i in to_process if i is not None)
if w is None or h is None or w == 0 or h == 0:
shared.log.error("XYZ grid: failed get valid image")
logger.log.error("XYZ grid: failed get valid image")
continue
if (not no_grid or include_sub_grids) and images.check_grid_size(to_process):
grid = images.image_grid(to_process, rows=len(ys))
@@ -129,6 +130,6 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
processed_result.infotexts.insert(0, processed_result.infotexts[0])
t2 = time.time()
shared.log.info(f'XYZ grid complete: images={list_size} results={len(processed_result.images)} size={grid.size if grid is not None else None} time={t1-t0:.2f} save={t2-t1:.2f}')
logger.log.info(f'XYZ grid complete: images={list_size} results={len(processed_result.images)} size={grid.size if grid is not None else None} time={t1-t0:.2f} save={t2-t1:.2f}')
p.skip_processing = True
return processed_result
scripts/xyz/xyz_grid_shared.py
+38 -37
View File
@@ -3,6 +3,7 @@
import os
import re
from modules import shared, processing, sd_samplers, sd_models, sd_vae, sd_unet
from modules import logger
re_range = re.compile(r'([-+]?[0-9]*\.?[0-9]+)-([-+]?[0-9]*\.?[0-9]+):?([0-9]+)?')
@@ -15,14 +16,14 @@ def restore_comma(val: str):
def apply_field(field):
def fun(p, x, xs):
shared.log.debug(f'XYZ grid apply field: {field}={x}')
logger.log.debug(f'XYZ grid apply field: {field}={x}')
setattr(p, field, x)
return fun
def apply_task_arg(field):
def fun(p, x, xs):
shared.log.debug(f'XYZ grid apply task-arg: {field}={x}')
logger.log.debug(f'XYZ grid apply task-arg: {field}={x}')
p.task_args[field] = x
return fun
@@ -34,7 +35,7 @@ def apply_task_args(p, x, xs):
if v.replace('.','',1).isdigit():
v = float(v) if '.' in v else int(v)
p.task_args[k] = v
shared.log.debug(f'XYZ grid apply task-arg: {k}={type(v)}:{v}')
logger.log.debug(f'XYZ grid apply task-arg: {k}={type(v)}:{v}')
def apply_processing(p, x, xs):
@@ -45,7 +46,7 @@ def apply_processing(p, x, xs):
v = float(v) if '.' in v else int(v)
found = 'existing' if hasattr(p, k) else 'new'
setattr(p, k, v)
shared.log.debug(f'XYZ grid apply processing-arg: type={found} {k}={type(v)}:{v} ')
logger.log.debug(f'XYZ grid apply processing-arg: type={found} {k}={type(v)}:{v} ')
def apply_options(p, x, xs):
@@ -56,7 +57,7 @@ def apply_options(p, x, xs):
v = float(v) if '.' in v else int(v)
found = 'existing' if v in shared.opts.data else 'new'
shared.opts.data[k] = v
shared.log.debug(f'XYZ grid apply options: type={found} {k}={type(v)}:{v} ')
logger.log.debug(f'XYZ grid apply options: type={found} {k}={type(v)}:{v} ')
def apply_setting(field):
@@ -67,7 +68,7 @@ def apply_setting(field):
x = x.lower() in ['true', 't', 'yes', 'y']
if isinstance(x, int) or isinstance(x, float):
x = x > 0
shared.log.debug(f'XYZ grid apply setting: {field}={t}:{x}')
logger.log.debug(f'XYZ grid apply setting: {field}={t}:{x}')
shared.opts.data[field] = x
return fun
@@ -75,12 +76,12 @@ def apply_setting(field):
def apply_seed(p, x, xs):
p.seed = x
p.all_seeds = None
shared.log.debug(f'XYZ grid apply seed: {x}')
logger.log.debug(f'XYZ grid apply seed: {x}')
def apply_prompt(positive, negative, p, x, xs):
for s in xs:
shared.log.debug(f'XYZ grid apply prompt: fields={positive}/{negative} "{s}"="{x}"')
logger.log.debug(f'XYZ grid apply prompt: fields={positive}/{negative} "{s}"="{x}"')
orig_positive = getattr(p, positive)
orig_negative = getattr(p, negative)
if s in orig_positive:
@@ -129,39 +130,39 @@ def apply_order(p, x, xs):
def apply_sampler(p, x, xs):
sampler_name = sd_samplers.samplers_map.get(x.lower(), None)
if sampler_name is None:
shared.log.warning(f"XYZ grid: unknown sampler: {x}")
logger.log.warning(f"XYZ grid: unknown sampler: {x}")
else:
p.sampler_name = sampler_name
shared.log.debug(f'XYZ grid apply sampler: "{x}"')
logger.log.debug(f'XYZ grid apply sampler: "{x}"')
def apply_hr_sampler_name(p, x, xs):
hr_sampler_name = sd_samplers.samplers_map.get(x.lower(), None)
if hr_sampler_name is None:
shared.log.warning(f"XYZ grid: unknown sampler: {x}")
logger.log.warning(f"XYZ grid: unknown sampler: {x}")
else:
p.hr_sampler_name = hr_sampler_name
shared.log.debug(f'XYZ grid apply HR sampler: "{x}"')
logger.log.debug(f'XYZ grid apply HR sampler: "{x}"')
def confirm_samplers(p, xs):
for x in xs:
if x.lower() not in sd_samplers.samplers_map:
shared.log.warning(f"XYZ grid: unknown sampler: {x}")
logger.log.warning(f"XYZ grid: unknown sampler: {x}")
def apply_sdnq_quant(p, x, xs):
shared.opts.sdnq_quantize_weights_mode = x
sd_models.unload_model_weights(op='model')
sd_models.reload_model_weights()
shared.log.debug(f'XYZ grid apply sdnq quant: mode="{x}"')
logger.log.debug(f'XYZ grid apply sdnq quant: mode="{x}"')
def apply_sdnq_quant_te(p, x, xs):
shared.opts.sdnq_quantize_weights_mode_te = x
sd_models.unload_model_weights(op='model')
sd_models.reload_model_weights()
shared.log.debug(f'XYZ grid apply sdnq quant te: mode="{x}"')
logger.log.debug(f'XYZ grid apply sdnq quant te: mode="{x}"')
def apply_checkpoint(p, x, xs):
@@ -169,11 +170,11 @@ def apply_checkpoint(p, x, xs):
return
info = sd_models.get_closest_checkpoint_match(x)
if info is None:
shared.log.warning(f"XYZ grid: apply checkpoint unknown checkpoint: {x}")
logger.log.warning(f"XYZ grid: apply checkpoint unknown checkpoint: {x}")
else:
sd_models.reload_model_weights(shared.sd_model, info)
p.override_settings['sd_model_checkpoint'] = info.name
shared.log.debug(f'XYZ grid apply checkpoint: "{x}"')
logger.log.debug(f'XYZ grid apply checkpoint: "{x}"')
def apply_refiner(p, x, xs):
@@ -183,11 +184,11 @@ def apply_refiner(p, x, xs):
return
info = sd_models.get_closest_checkpoint_match(x)
if info is None:
shared.log.warning(f"XYZ grid: apply refiner unknown checkpoint: {x}")
logger.log.warning(f"XYZ grid: apply refiner unknown checkpoint: {x}")
else:
sd_models.reload_model_weights(shared.sd_refiner, info)
p.override_settings['sd_model_refiner'] = info.name
shared.log.debug(f'XYZ grid apply refiner: "{x}"')
logger.log.debug(f'XYZ grid apply refiner: "{x}"')
def apply_unet(p, x, xs):
@@ -198,12 +199,12 @@ def apply_unet(p, x, xs):
p.override_settings['sd_unet'] = x
shared.opts.data['sd_unet'] = x
sd_unet.load_unet(shared.sd_model)
shared.log.debug(f'XYZ grid apply unet: "{x}"')
logger.log.debug(f'XYZ grid apply unet: "{x}"')
def apply_clip_skip(p, x, xs):
p.clip_skip = x
shared.log.debug(f'XYZ grid apply clip-skip: "{x}"')
logger.log.debug(f'XYZ grid apply clip-skip: "{x}"')
def find_vae(name: str):
@@ -214,7 +215,7 @@ def find_vae(name: str):
else:
choices = [x for x in sorted(sd_vae.vae_dict, key=lambda x: len(x)) if name.lower().strip() in x.lower()]
if len(choices) == 0:
shared.log.warning(f"No VAE found for {name}; using automatic")
logger.log.warning(f"No VAE found for {name}; using automatic")
return sd_vae.unspecified
else:
return sd_vae.vae_dict[choices[0]]
@@ -222,7 +223,7 @@ def find_vae(name: str):
def apply_vae(p, x, xs):
sd_vae.reload_vae_weights(shared.sd_model, vae_file=find_vae(x))
shared.log.debug(f'XYZ grid apply VAE: "{x}"')
logger.log.debug(f'XYZ grid apply VAE: "{x}"')
def list_lora():
@@ -239,11 +240,11 @@ def apply_lora(p, x, xs):
return
x = os.path.basename(x)
p.prompt = p.prompt + f" <lora:{x}:{shared.opts.extra_networks_default_multiplier}>"
shared.log.debug(f'XYZ grid apply LoRA: "{x}"')
logger.log.debug(f'XYZ grid apply LoRA: "{x}"')
def apply_lora_strength(p, x, xs):
shared.log.debug(f'XYZ grid apply LoRA strength: "{x}"')
logger.log.debug(f'XYZ grid apply LoRA strength: "{x}"')
p.prompt = p.prompt.replace(':1.0>', '>')
p.prompt = p.prompt.replace(f':{shared.opts.extra_networks_default_multiplier}>', '>')
p.all_prompts = None
@@ -254,19 +255,19 @@ def apply_lora_strength(p, x, xs):
def apply_te(p, x, xs):
shared.opts.data["sd_text_encoder"] = x
sd_models.reload_text_encoder()
shared.log.debug(f'XYZ grid apply text-encoder: "{x}"')
logger.log.debug(f'XYZ grid apply text-encoder: "{x}"')
def apply_guidance(p, x, xs):
from modules.modular_guiders import guiders
guiders = list(guiders.keys())
p.guidance_name = [g for g in guiders if g.lower().startswith(x.lower())][0]
shared.log.debug(f'XYZ grid apply guidance: "{p.guidance_name}"')
logger.log.debug(f'XYZ grid apply guidance: "{p.guidance_name}"')
def apply_styles(p: processing.StableDiffusionProcessingTxt2Img, x: str, _):
p.styles.extend(x.split(','))
shared.log.debug(f'XYZ grid apply style: "{x}"')
logger.log.debug(f'XYZ grid apply style: "{x}"')
def apply_upscaler(p: processing.StableDiffusionProcessingTxt2Img, opt, x):
@@ -274,25 +275,25 @@ def apply_upscaler(p: processing.StableDiffusionProcessingTxt2Img, opt, x):
p.hr_force = True
p.denoising_strength = 0.0
p.hr_upscaler = opt
shared.log.debug(f'XYZ grid apply upscaler: "{x}"')
logger.log.debug(f'XYZ grid apply upscaler: "{x}"')
def apply_context(p: processing.StableDiffusionProcessingTxt2Img, opt, x):
p.resize_mode = 5
p.resize_context = opt
shared.log.debug(f'XYZ grid apply resize-context: "{x}"')
logger.log.debug(f'XYZ grid apply resize-context: "{x}"')
def apply_detailer(p, opt, x):
p.detailer_enabled = bool(opt)
shared.log.debug(f'XYZ grid apply detailer: "{x}"')
logger.log.debug(f'XYZ grid apply detailer: "{x}"')
def apply_control(field):
def fun(p, x, xs):
init_images = getattr(p, 'orig_init_images', None) or getattr(p, 'init_images', None) or getattr(p, 'orig_init_images', None) or []
if init_images is None or len(init_images) == 0:
shared.log.error('XYZ grid apply control: init image is required')
logger.log.error('XYZ grid apply control: init image is required')
return
if field in ['controlnet', 't2i adapter', 'processor']:
from modules.control import run, processor
@@ -320,7 +321,7 @@ def apply_control(field):
end = getattr(end, 'value', end),
strength = getattr(strength, 'value', strength),
)
shared.log.debug(f'XYZ grid apply control: {field}="{x}" unit={unit}')
logger.log.debug(f'XYZ grid apply control: {field}="{x}" unit={unit}')
if len(run.unit.current) > 0:
if hasattr(run.unit.current[0], 'reset'):
run.unit.current[0].reset()
@@ -335,13 +336,13 @@ def apply_control(field):
if pipe is not None:
shared.sd_model = pipe
elif field == 'control_start':
shared.log.debug(f'XYZ grid apply control: {field}={x}')
logger.log.debug(f'XYZ grid apply control: {field}={x}')
p.task_args['control_guidance_start'] = float(x)
elif field == 'control_end':
shared.log.debug(f'XYZ grid apply control: {field}={x}')
logger.log.debug(f'XYZ grid apply control: {field}={x}')
p.task_args['control_guidance_end'] = float(x)
elif field == 'control_strength':
shared.log.debug(f'XYZ grid apply control: {field}={x}')
logger.log.debug(f'XYZ grid apply control: {field}={x}')
p.task_args['adapter_conditioning_scale'] = float(x)
p.task_args['controlnet_conditioning_scale'] = float(x)
return fun
@@ -350,7 +351,7 @@ def apply_control(field):
def apply_override(field):
def fun(p, x, xs):
p.override_settings[field] = x
shared.log.debug(f'XYZ grid apply override: "{field}"="{x}"')
logger.log.debug(f'XYZ grid apply override: "{field}"="{x}"')
return fun
scripts/xyz_grid.py
+10 -9
View File
@@ -16,9 +16,10 @@ from modules import shared, errors, scripts_manager, images, processing
from modules.ui_components import ToolButton
from modules.ui_sections import create_video_inputs
import modules.ui_symbols as symbols
from modules import logger
debug = shared.log.trace if os.environ.get('SD_XYZ_DEBUG', None) is not None else lambda *args, **kwargs: None
debug = logger.log.trace if os.environ.get('SD_XYZ_DEBUG', None) is not None else lambda *args, **kwargs: None
class Script(scripts_manager.Script):
@@ -186,11 +187,11 @@ class Script(scripts_manager.Script):
end_val = int(m.group(2)) if m.group(2) is not None else val
num = int(m.group(3)) if m.group(3) is not None else int(end_val-start_val)
valslist_ext += [int(x) for x in np.linspace(start=start_val, stop=end_val, num=max(2, num)).tolist()]
shared.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
logger.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
else:
valslist_ext.append(int(val))
except Exception as e:
shared.log.error(f"XYZ grid: value={val} {e}")
logger.log.error(f"XYZ grid: value={val} {e}")
valslist.clear()
valslist = [x for x in valslist_ext if x not in valslist]
elif opt.type == float:
@@ -203,11 +204,11 @@ class Script(scripts_manager.Script):
end_val = float(m.group(2)) if m.group(2) is not None else val
num = int(m.group(3)) if m.group(3) is not None else int(end_val-start_val)
valslist_ext += [round(float(x), 2) for x in np.linspace(start=start_val, stop=end_val, num=max(2, num)).tolist()]
shared.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
logger.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
else:
valslist_ext.append(float(val))
except Exception as e:
shared.log.error(f"XYZ grid: value={val} {e}")
logger.log.error(f"XYZ grid: value={val} {e}")
valslist.clear()
valslist = [x for x in valslist_ext if x not in valslist]
elif opt.type == str_permutations: # pylint: disable=comparison-with-callable
@@ -241,7 +242,7 @@ class Script(scripts_manager.Script):
y_opt, ys = parse_axis(y_type, y_values, y_values_dropdown)
z_opt, zs = parse_axis(z_type, z_values, z_values_dropdown)
except Exception as e:
shared.log.error(f"XYZ grid: invalid axis values {e}")
logger.log.error(f"XYZ grid: invalid axis values {e}")
errors.display(e, 'xyz')
return None
@@ -284,7 +285,7 @@ class Script(scripts_manager.Script):
shared.state.update('Grid', total_steps, total_jobs * p.n_iter)
image_cell_count = p.n_iter * p.batch_size
shared.log.info(f"XYZ grid start: images={len(xs)*len(ys)*len(zs)*image_cell_count} grid={len(zs)} shape={len(xs)}x{len(ys)} cells={len(zs)} steps={total_steps} csv={csv_mode} legend={draw_legend} grid={include_grid} subgrid={include_subgrids} images={include_images} time={include_time} text={include_text}")
logger.log.info(f"XYZ grid start: images={len(xs)*len(ys)*len(zs)*image_cell_count} grid={len(zs)} shape={len(xs)}x{len(ys)} cells={len(zs)} steps={total_steps} csv={csv_mode} legend={draw_legend} grid={include_grid} subgrid={include_subgrids} images={include_images} time={include_time} text={include_text}")
AxisInfo = namedtuple('AxisInfo', ['axis', 'values'])
shared.state.xyz_plot_x = AxisInfo(x_opt, xs)
shared.state.xyz_plot_y = AxisInfo(y_opt, ys)
@@ -326,7 +327,7 @@ class Script(scripts_manager.Script):
try:
processed = processing.process_images(pc)
except Exception as e:
shared.log.error(f"XYZ grid: Failed to process image: {e}")
logger.log.error(f"XYZ grid: Failed to process image: {e}")
errors.display(e, 'XYZ grid')
processed = None
subgrid_index = 1 + iz # Sets subgrid infotexts
@@ -387,7 +388,7 @@ class Script(scripts_manager.Script):
have_subgrids = len(zs) if len(zs) > 1 and include_subgrids else 0
have_images = processed.images[have_grid+have_subgrids:]
processed.infotexts[:have_grid+have_subgrids] = grid_infotext[:have_grid+have_subgrids] # update infotexts with grid and subgrid info
shared.log.debug(f'XYZ grid: grid={have_grid} subgrids={have_subgrids} images={len(have_images)} total={len(processed.images)}')
logger.log.debug(f'XYZ grid: grid={have_grid} subgrids={have_subgrids} images={len(have_images)} total={len(processed.images)}')
if not include_images: # dont need images anymore, drop from list:
processed.images = processed.images[:have_grid+have_subgrids]
scripts/xyz_grid_on.py
+11 -10
View File
@@ -15,11 +15,12 @@ from modules import shared, errors, scripts_manager, images, processing
from modules.ui_components import ToolButton
from modules.ui_sections import create_video_inputs
import modules.ui_symbols as symbols
from modules import logger
active = False
xyz_results_cache = None
debug = shared.log.trace if os.environ.get('SD_XYZ_DEBUG', None) is not None else lambda *args, **kwargs: None
debug = logger.log.trace if os.environ.get('SD_XYZ_DEBUG', None) is not None else lambda *args, **kwargs: None
class Script(scripts_manager.Script):
@@ -202,11 +203,11 @@ class Script(scripts_manager.Script):
end_val = int(m.group(2)) if m.group(2) is not None else val
num = int(m.group(3)) if m.group(3) is not None else int(end_val-start_val)
valslist_ext += [int(x) for x in np.linspace(start=start_val, stop=end_val, num=max(2, num)).tolist()]
shared.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
logger.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
else:
valslist_ext.append(int(val))
except Exception as e:
shared.log.error(f"XYZ grid: value={val} {e}")
logger.log.error(f"XYZ grid: value={val} {e}")
valslist.clear()
valslist = [x for x in valslist_ext if x not in valslist]
elif opt.type == float:
@@ -219,11 +220,11 @@ class Script(scripts_manager.Script):
end_val = float(m.group(2)) if m.group(2) is not None else val
num = int(m.group(3)) if m.group(3) is not None else int(end_val-start_val)
valslist_ext += [round(float(x), 2) for x in np.linspace(start=start_val, stop=end_val, num=max(2, num)).tolist()]
shared.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
logger.log.debug(f'XYZ grid range: start={start_val} end={end_val} num={max(2, num)} list={valslist}')
else:
valslist_ext.append(float(val))
except Exception as e:
shared.log.error(f"XYZ grid: value={val} {e}")
logger.log.error(f"XYZ grid: value={val} {e}")
valslist.clear()
valslist = [x for x in valslist_ext if x not in valslist]
elif opt.type == str_permutations: # pylint: disable=comparison-with-callable
@@ -257,7 +258,7 @@ class Script(scripts_manager.Script):
y_opt, ys = parse_axis(y_type, y_values, y_values_dropdown)
z_opt, zs = parse_axis(z_type, z_values, z_values_dropdown)
except Exception as e:
shared.log.error(f"XYZ grid: invalid axis values {e}")
logger.log.error(f"XYZ grid: invalid axis values {e}")
errors.display(e, 'xyz')
return None
@@ -302,7 +303,7 @@ class Script(scripts_manager.Script):
shared.state.update('Grid', total_steps, total_jobs)
image_cell_count = p.n_iter * p.batch_size
shared.log.info(f"XYZ grid start: images={len(xs)*len(ys)*len(zs)*image_cell_count} grid={len(zs)} shape={len(xs)}x{len(ys)} cells={len(zs)} steps={total_steps} csv={csv_mode} legend={draw_legend} grid={include_grid} subgrid={include_subgrids} images={include_images} time={include_time} text={include_text}")
logger.log.info(f"XYZ grid start: images={len(xs)*len(ys)*len(zs)*image_cell_count} grid={len(zs)} shape={len(xs)}x{len(ys)} cells={len(zs)} steps={total_steps} csv={csv_mode} legend={draw_legend} grid={include_grid} subgrid={include_subgrids} images={include_images} time={include_time} text={include_text}")
AxisInfo = namedtuple('AxisInfo', ['axis', 'values'])
shared.state.xyz_plot_x = AxisInfo(x_opt, xs)
shared.state.xyz_plot_y = AxisInfo(y_opt, ys)
@@ -332,7 +333,7 @@ class Script(scripts_manager.Script):
def cell(x, y, z, ix, iy, iz):
if shared.state.interrupted:
shared.log.warning('XYZ grid: Interrupted')
logger.log.warning('XYZ grid: Interrupted')
return processing.Processed(p, [], p.seed, ""), 0
p.xyz = True
pc = copy(p)
@@ -351,7 +352,7 @@ class Script(scripts_manager.Script):
try:
processed = processing.process_images(pc)
except Exception as e:
shared.log.error(f"XYZ grid: Failed to process image: {e}")
logger.log.error(f"XYZ grid: Failed to process image: {e}")
errors.display(e, 'XYZ grid')
processed = None
@@ -415,7 +416,7 @@ class Script(scripts_manager.Script):
have_subgrids = len(zs) if len(zs) > 1 and include_subgrids else 0
have_images = processed.images[have_grid+have_subgrids:]
processed.infotexts[:have_grid+have_subgrids] = grid_infotext[:have_grid+have_subgrids] # update infotexts with grid and subgrid info
shared.log.debug(f'XYZ grid: grid={have_grid} subgrids={have_subgrids} images={len(have_images)} total={len(processed.images)}')
logger.log.debug(f'XYZ grid: grid={have_grid} subgrids={have_subgrids} images={len(have_images)} total={len(processed.images)}')
if not include_images: # dont need images anymore, drop from list:
processed.images = processed.images[:have_grid+have_subgrids]