], [job_timestamp]; leave empty for default","ui":"settings_saving-paths"},
+ {"id":"","label":"Dark","localized":"","hint":"","ui":"settings_ui"},
+ {"id":"","label":"Disabled UI tabs","localized":"","hint":"","ui":"settings_ui"},
+ {"id":"","label":"Disable variable aspect ratio","localized":"","hint":"","ui":"settings_ui"},
+ {"id":"","label":"Desktop","localized":"","hint":"","ui":"settings_ui"},
+ {"id":"","label":"Downscale high resolution live previews","localized":"","hint":"","ui":"settings_live-preview"},
+ {"id":"","label":"Detailer use model augment","localized":"","hint":"Run detailer detection models at extra precision","ui":"settings_postprocessing"},
+ {"id":"","label":"Default strength","localized":"","hint":"When adding extra network such as Lora to prompt, use this multiplier for it","ui":"settings_extra_networks"},
+ {"id":"","label":"Do not change selected model when reading generation parameters","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Do conditional and unconditional denoising in one batch","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Disable NaN check","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Disallow models in ckpt format","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Default upscaler for image resize operations","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Debug info","localized":"","hint":"","ui":"models_replace_tab"},
+ {"id":"","label":"Download folder","localized":"","hint":"","ui":"models_civitai_tab"},
+ {"id":"","label":"DWPose","localized":"","hint":"","ui":"control"},
+ {"id":"","label":"Depth Anything","localized":"","hint":"","ui":"control"},
+ {"id":"","label":"Depth Pro","localized":"","hint":"","ui":"control"},
+ {"id":"","label":"Decode","localized":"","hint":"","ui":"video"}
],
- "e":
- [
- {"id":"component-843","label":"Enhance prompt","localized":"","hint":"","ui":"script_flux_prompt_enhance_(legacy)"},
- {"id":"prompt_enhance_apply","label":"Enhance now","localized":"","hint":"Run prompt enhancement using the selected LLM model","ui":"script_prompt_enhance"},
- {"id":"btn_extensions","label":"Extensions","localized":"","hint":"Application extensions"},
- {"id":"","label":"Extract LoRA","localized":"","hint":""},
- {"id":"","label":"Embedded metadata","localized":"","hint":""},
- {"id":"","label":"Extension list","localized":"","hint":"","ui":"component-8571"},
- {"id":"","label":"Execution Precision","localized":"","hint":"","ui":"settings_cuda"},
- {"id":"","label":"Embeddings","localized":"","hint":"","ui":"settings_extra_networks"},
- {"id":"","label":"Extract currently loaded LoRA(s)","localized":"","hint":"","ui":"component-5745"},
- {"id":"","label":"Enable LayerSkipConfig","localized":"","hint":"","ui":"txt2img"},
- {"id":"","label":"Enable refine pass","localized":"","hint":"Use a similar process as image to image to upscale and/or add detail to the final image. Optionally uses refiner model to enhance image details.","ui":"txt2img"},
- {"id":"","label":"Enable detailer pass","localized":"","hint":"Detect target objects such as face and reprocess it at higher resolution","ui":"txt2img"},
- {"id":"","label":"Edge padding","localized":"","hint":"Expand edge of masked area by this percentage","ui":"txt2img"},
- {"id":"","label":"Edge blur","localized":"","hint":"Blur edge of masked area by this percentage","ui":"txt2img"},
- {"id":"","label":"End","localized":"","hint":"","ui":"txt2img"},
- {"id":"","label":"ETA","localized":"","hint":"","ui":"script_apg"},
- {"id":"","label":"Enable FreeU","localized":"","hint":"","ui":"script_consistory"},
- {"id":"","label":"Enable tonemap","localized":"","hint":"","ui":"script_hdr"},
- {"id":"","label":"Enabled","localized":"","hint":"","ui":"script_kohya_hires_fix"},
- {"id":"","label":"Exposure","localized":"","hint":"","ui":"script_lut_color_grading"},
- {"id":"","label":"Encoder","localized":"","hint":"","ui":"script_mulan"},
- {"id":"","label":"Enhanced prompt","localized":"","hint":"The enhanced prompt output from the LLM","ui":"script_prompt_enhance"},
- {"id":"","label":"Edit start","localized":"","hint":"","ui":"script_ledits"},
- {"id":"","label":"Edit stop","localized":"","hint":"","ui":"script_ledits"},
- {"id":"","label":"Erode","localized":"","hint":"","ui":"control"},
- {"id":"","label":"edge","localized":"","hint":"","ui":"control"},
- {"id":"","label":"Ensemble size","localized":"","hint":"","ui":"control"},
- {"id":"","label":"Enable","localized":"","hint":"","ui":"video"},
- {"id":"","label":"Erode size","localized":"","hint":"","ui":"extras"},
- {"id":"","label":"Enable PixelArt","localized":"","hint":"","ui":"extras"},
- {"id":"","label":"Enable edge detection","localized":"","hint":"","ui":"extras"},
- {"id":"","label":"Edge block size","localized":"","hint":"","ui":"extras"},
- {"id":"","label":"Edge image weight","localized":"","hint":"","ui":"extras"},
- {"id":"","label":"Escape brackets","localized":"","hint":"Escape parentheses and brackets in tags with backslashes.seq, uuid ","ui":"settings_saving-paths"},
- {"id":"","label":"inline","localized":"","hint":"inline with all additional elements (scrollable)","ui":"settings_ui"},
- {"id":"","label":"Inpainting include greyscale mask in results","localized":"","hint":"","ui":"settings_ui"},
- {"id":"","label":"Inpainting include masked composite in results","localized":"","hint":"","ui":"settings_ui"},
- {"id":"","label":"Image transparent color fill","localized":"","hint":"","ui":"settings_postprocessing"},
- {"id":"","label":"Inpainting conditioning mask strength","localized":"","hint":"Determines how strongly to mask off the original image for inpainting and img2img. 1.0 means fully masked (default). 0.0 means a fully unmasked conditioning. Lower values will help preserve the overall composition of the image, but will struggle with large changes","ui":"settings_postprocessing"},
- {"id":"","label":"Image resize algorithm","localized":"","hint":"","ui":"settings_postprocessing"},
- {"id":"","label":"Image repeats per epoch","localized":"","hint":"","ui":"settings_legacy_options"},
- {"id":"","label":"Interpolation Method","localized":"","hint":"","ui":"models_merge_tab"},
- {"id":"","label":"In Blocks","localized":"","hint":"Downsampling Blocks of the UNet (12 values for SD1.5, 9 values for SDXL)","ui":"component-5574"},
- {"id":"","label":"Input model","localized":"","hint":"","ui":"models_replace_tab"},
- {"id":"","label":"Info object","localized":"","hint":"","ui":"component-8625"}
+ "i": [
+ {"id":"control_nav","label":"Images","localized":"","hint":"Create imagesseq, uuid ","ui":"settings_saving-paths"},
+ {"id":"","label":"inline","localized":"","hint":"inline with all additional elements (scrollable)","ui":"settings_ui"},
+ {"id":"","label":"Inpainting include greyscale mask in results","localized":"","hint":"","ui":"settings_ui"},
+ {"id":"","label":"Inpainting include masked composite in results","localized":"","hint":"","ui":"settings_ui"},
+ {"id":"","label":"Image transparent color fill","localized":"","hint":"","ui":"settings_postprocessing"},
+ {"id":"","label":"Inpainting conditioning mask strength","localized":"","hint":"Determines how strongly to mask off the original image for inpainting and img2img. 1.0 means fully masked (default). 0.0 means a fully unmasked conditioning. Lower values will help preserve the overall composition of the image, but will struggle with large changes","ui":"settings_postprocessing"},
+ {"id":"","label":"Image resize algorithm","localized":"","hint":"","ui":"settings_postprocessing"},
+ {"id":"","label":"Image repeats per epoch","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Interpolation Method","localized":"","hint":"","ui":"models_merge_tab"},
+ {"id":"","label":"In Blocks","localized":"","hint":"Downsampling Blocks of the UNet (12 values for SD1.5, 9 values for SDXL)","ui":"component-5674"},
+ {"id":"","label":"Input model","localized":"","hint":"","ui":"models_replace_tab"},
+ {"id":"","label":"Info object","localized":"","hint":"","ui":"component-8779"}
],
- "k":
- [
- {"id":"kanvas-change-button","label":"Kanvas change","localized":"","hint":"","ui":"control"},
- {"id":"","label":"Kanvas Settings","localized":"","hint":"","ui":"control"},
- {"id":"","label":"Keep Thinking Trace","localized":"","hint":"Include the model's reasoning process in the final output.Warning: After removing or switching a LoRA, you may still see its style in generated images. To get a clean model, reload it from the model selector.","ui":"settings_extra_networks"},
- {"id":"","label":"LoRA diffusers fuse with model","localized":"","hint":"Merge LoRA into the model for lower memory usage and torch.compile compatibility.Warning: After removing or switching a LoRA, you may still see its style in generated images. To get a clean model, reload it from the model selector.","ui":"settings_extra_networks"},
- {"id":"","label":"LoRA auto-apply tags","localized":"","hint":"Automatically add trigger words/tags from LoRA metadata to your prompt.Warning: After removing or switching a LoRA, you may still see its style in generated images. To get a clean model, reload it from the model selector.","ui":"settings_extra_networks"},
+ {"id":"","label":"LoRA diffusers fuse with model","localized":"","hint":"Merge LoRA into the model for lower memory usage and torch.compile compatibility.Warning: After removing or switching a LoRA, you may still see its style in generated images. To get a clean model, reload it from the model selector.","ui":"settings_extra_networks"},
+ {"id":"","label":"LoRA auto-apply tags","localized":"","hint":"Automatically add trigger words/tags from LoRA metadata to your prompt.Fast : Quick caption with minimal flavor terms.Classic : Standard interrogation with balanced quality and speed.Best : Most thorough analysis, slowest but highest quality.Negative : Generate terms to use as negative prompt.","ui":"script_face"},
- {"id":"","label":"Method","localized":"","hint":"","ui":"script_video"},
- {"id":"","label":"Model repo","localized":"","hint":"HuggingFace repository ID for the model","ui":"script_prompt_enhance"},
- {"id":"","label":"Model gguf","localized":"","hint":"Optional GGUF quantized model repository on HuggingFace","ui":"script_prompt_enhance"},
- {"id":"","label":"Model type","localized":"","hint":"Optional GGUF model quantization type","ui":"script_prompt_enhance"},
- {"id":"","label":"Model file","localized":"","hint":"Optional specific GGUF model file inside the repository","ui":"script_prompt_enhance"},
- {"id":"","label":"Max tokens","localized":"","hint":"Maximum number of tokens the model can generate in its response.Fast : Quick caption with minimal flavor terms.Classic : Standard interrogation with balanced quality and speed.Best : Most thorough analysis, slowest but highest quality.Negative : Generate terms to use as negative prompt.","ui":"script_face"},
+ {"id":"","label":"Method","localized":"","hint":"","ui":"script_video"},
+ {"id":"","label":"Model repo","localized":"","hint":"HuggingFace repository ID for the model","ui":"script_prompt_enhance"},
+ {"id":"","label":"Model gguf","localized":"","hint":"Optional GGUF quantized model repository on HuggingFace","ui":"script_prompt_enhance"},
+ {"id":"","label":"Model type","localized":"","hint":"Optional GGUF model quantization type","ui":"script_prompt_enhance"},
+ {"id":"","label":"Model file","localized":"","hint":"Optional specific GGUF model file inside the repository","ui":"script_prompt_enhance"},
+ {"id":"","label":"Max tokens","localized":"","hint":"Maximum number of tokens the model can generate in its response.Use Prompt .Prompt field for guidance.","ui":"caption"},
- {"id":"","label":"Tagger Model","localized":"","hint":"Model to use for image tagging.WaifuDiffusion models (wd-*): Modern taggers with separate general and character thresholds.DeepBooru : Legacy tagger, uses only general threshold.","ui":"caption"},
- {"id":"","label":"Torch","localized":"","hint":"","ui":"component-8625"},
- {"id":"","label":"Transformers load using Run:ai streamer","localized":"","hint":"","ui":"settings_sd"},
- {"id":"","label":"Temporal steps","localized":"","hint":"","ui":"settings_model_options"},
- {"id":"","label":"TE","localized":"","hint":"","ui":"settings_quantization"},
- {"id":"","label":"true","localized":"","hint":"","ui":"settings_vae_encoder"},
- {"id":"","label":"Text encoder model","localized":"","hint":"","ui":"settings_text_encoder"},
- {"id":"","label":"Text encoder cache size","localized":"","hint":"","ui":"settings_text_encoder"},
- {"id":"","label":"T5: Use shared instance of text encoder","localized":"","hint":"","ui":"settings_text_encoder"},
- {"id":"","label":"Tunable ops limit","localized":"","hint":"","ui":"settings_backends"},
- {"id":"","label":"ToMe","localized":"","hint":"","ui":"settings_advanced"},
- {"id":"","label":"ToDo","localized":"","hint":"","ui":"settings_advanced"},
- {"id":"","label":"ToMe token merging ratio","localized":"","hint":"Enable redundant token merging via tomesd for speed and memory improvements, 0=disabled","ui":"settings_advanced"},
- {"id":"","label":"ToDo token merging ratio","localized":"","hint":"Enable redundant token merging via todo for speed and memory improvements, 0=disabled","ui":"settings_advanced"},
- {"id":"","label":"TaylorSeer","localized":"","hint":"","ui":"settings_advanced"},
- {"id":"","label":"TeaCache cache enabled","localized":"","hint":"","ui":"settings_advanced"},
- {"id":"","label":"TeaCache L1 threshold","localized":"","hint":"","ui":"settings_advanced"},
- {"id":"","label":"TAESD","localized":"","hint":"","ui":"settings_live-preview"},
- {"id":"","label":"TAESD variant","localized":"","hint":"","ui":"settings_live-preview"},
- {"id":"","label":"TAESD decode layers","localized":"","hint":"","ui":"settings_live-preview"},
- {"id":"","label":"Tensorboard flush period","localized":"","hint":"","ui":"settings_legacy_options"},
- {"id":"","label":"Tertiary model","localized":"","hint":"","ui":"models_merge_tab"},
- {"id":"","label":"Target model type","localized":"","hint":"","ui":"models_civitai_tab"},
- {"id":"","label":"T2I-Adapter unit 1","localized":"","hint":"","ui":"control"},
- {"id":"","label":"T2I-Adapter unit 2","localized":"","hint":"","ui":"control"},
- {"id":"","label":"T2I-Adapter unit 3","localized":"","hint":"","ui":"control"},
- {"id":"","label":"T2I-Adapter unit 4","localized":"","hint":"","ui":"control"}
+ "t": [
+ {"id":"txt2img_nav","label":"T2I","localized":"","hint":"Create image from textUse Prompt .Prompt field for guidance.","ui":"caption"},
+ {"id":"","label":"Tagger Model","localized":"","hint":"Model to use for image tagging.WaifuDiffusion models (wd-*): Modern taggers with separate general and character thresholds.DeepBooru : Legacy tagger, uses only general threshold.","ui":"caption"},
+ {"id":"","label":"Torch","localized":"","hint":"","ui":"component-8779"},
+ {"id":"","label":"Transformers load using Run:ai streamer","localized":"","hint":"","ui":"settings_sd"},
+ {"id":"","label":"Temporal steps","localized":"","hint":"","ui":"settings_model_options"},
+ {"id":"","label":"TE","localized":"","hint":"","ui":"settings_quantization"},
+ {"id":"","label":"true","localized":"","hint":"","ui":"settings_vae_encoder"},
+ {"id":"","label":"Text encoder model","localized":"","hint":"","ui":"settings_text_encoder"},
+ {"id":"","label":"Text encoder cache size","localized":"","hint":"","ui":"settings_text_encoder"},
+ {"id":"","label":"T5: Use shared instance of text encoder","localized":"","hint":"","ui":"settings_text_encoder"},
+ {"id":"","label":"Tunable ops limit","localized":"","hint":"","ui":"settings_backends"},
+ {"id":"","label":"ToMe","localized":"","hint":"","ui":"settings_advanced"},
+ {"id":"","label":"ToDo","localized":"","hint":"","ui":"settings_advanced"},
+ {"id":"","label":"ToMe token merging ratio","localized":"","hint":"Enable redundant token merging via tomesd for speed and memory improvements, 0=disabled","ui":"settings_advanced"},
+ {"id":"","label":"ToDo token merging ratio","localized":"","hint":"Enable redundant token merging via todo for speed and memory improvements, 0=disabled","ui":"settings_advanced"},
+ {"id":"","label":"TaylorSeer","localized":"","hint":"","ui":"settings_advanced"},
+ {"id":"","label":"TeaCache cache enabled","localized":"","hint":"","ui":"settings_advanced"},
+ {"id":"","label":"TeaCache L1 threshold","localized":"","hint":"","ui":"settings_advanced"},
+ {"id":"","label":"TAESD","localized":"","hint":"","ui":"settings_live-preview"},
+ {"id":"","label":"TAESD variant","localized":"","hint":"","ui":"settings_live-preview"},
+ {"id":"","label":"TAESD decode layers","localized":"","hint":"","ui":"settings_live-preview"},
+ {"id":"","label":"Tensorboard flush period","localized":"","hint":"","ui":"settings_legacy_options"},
+ {"id":"","label":"Tertiary model","localized":"","hint":"","ui":"models_merge_tab"},
+ {"id":"","label":"Time period","localized":"","hint":"","ui":"models_civitai_tab"},
+ {"id":"","label":"T2I-Adapter unit 1","localized":"","hint":"","ui":"control"},
+ {"id":"","label":"T2I-Adapter unit 2","localized":"","hint":"","ui":"control"},
+ {"id":"","label":"T2I-Adapter unit 3","localized":"","hint":"","ui":"control"},
+ {"id":"","label":"T2I-Adapter unit 4","localized":"","hint":"","ui":"control"}
],
- "u":
- [
- {"id":"prompt_enhance_unload","label":"Unload model","localized":"","hint":"Unload currently loaded model","ui":"script_prompt_enhance"},
- {"id":"","label":"Upload","localized":"","hint":"","ui":"img2img"},
- {"id":"vlm_unload","label":"Unload","localized":"","hint":"","ui":"caption"},
- {"id":"component-8586","label":"Update all installed","localized":"","hint":"Update installed extensions to their latest available version","ui":"component-8571"},
- {"id":"","label":"Update","localized":"","hint":""},
- {"id":"","label":"User interface","localized":"","hint":"Review and set user interface preferences"},
- {"id":"component-5511","label":"Update all","localized":"","hint":"","ui":"models_metadata_tab"},
- {"id":"","label":"Upscale","localized":"","hint":"Upscale image","ui":"extras"},
- {"id":"","label":"UI Tabs","localized":"","hint":"","ui":"settings_ui"},
- {"id":"","label":"Upscaling","localized":"","hint":"","ui":"settings_postprocessing"},
- {"id":"","label":"Use segmentation","localized":"","hint":"Run detailer using segmentation mask","ui":"txt2img"},
- {"id":"","label":"Unload adapter","localized":"","hint":"Unload IP adapter immediately after generate. Otherwise IP adapter will remain loaded for faster use in next generate process","ui":"txt2img"},
- {"id":"","label":"Use same seed","localized":"","hint":"","ui":"script_prompts_from_file"},
- {"id":"","label":"Use defaults","localized":"","hint":"","ui":"script_video"},
- {"id":"","label":"Use text inputs","localized":"","hint":"","ui":"script_xyz_grid_script"},
- {"id":"","label":"Use random seeds","localized":"","hint":"","ui":"script_xyz_grid_script"},
- {"id":"","label":"Use vision","localized":"","hint":"Include input image when enhancing prompt.
@@ -186,14 +186,16 @@ def update_model_hashes():
log.error(f'Model list: row={row} {e}')
return html.format(tbody=tbody)
- lst = [ckpt for ckpt in checkpoints_list.values() if ckpt.hash is None]
+ if model_list is None:
+ model_list = checkpoints_list
+ lst = [ckpt for ckpt in model_list.values() if ckpt.hash is None]
for ckpt in lst:
ckpt.hash = model_hash(ckpt.filename)
- lst = [ckpt for ckpt in checkpoints_list.values() if ckpt.sha256 is None or ckpt.shorthash is None]
- log.info(f'Models list: hash missing={len(lst)} total={len(checkpoints_list)}')
+ lst = [ckpt for ckpt in model_list.values() if ckpt.sha256 is None or ckpt.shorthash is None]
+ log.info(f'Models list: hash missing={len(lst)} total={len(model_list)}')
updated = []
for ckpt in lst:
- ckpt.sha256 = hashes.sha256(ckpt.filename, f"checkpoint/{ckpt.name}")
+ ckpt.sha256 = hashes.sha256(ckpt.filename, f"{model_type}/{ckpt.name}")
ckpt.shorthash = ckpt.sha256[0:10] if ckpt.sha256 is not None else None
updated.append(ckpt)
yield update_model_hashes_table(updated)
diff --git a/modules/sd_models.py b/modules/sd_models.py
index 57fd85ff8..f7b224f9e 100644
--- a/modules/sd_models.py
+++ b/modules/sd_models.py
@@ -798,8 +798,8 @@ def load_diffuser(checkpoint_info=None, op='model', revision=None): # pylint: di
"requires_safety_checker": False, # sd15 specific but we cant know ahead of time
# "use_safetensors": True,
}
- if shared.opts.huggingface_token and len(shared.opts.huggingface_token) > 0:
- diffusers_load_config['token'] = shared.opts.huggingface_token
+ # if shared.opts.huggingface_token and len(shared.opts.huggingface_token) > 0:
+ # diffusers_load_config['token'] = shared.opts.huggingface_token
if revision is not None:
diffusers_load_config['revision'] = revision
if shared.opts.diffusers_model_load_variant != 'default':
diff --git a/modules/sd_unet.py b/modules/sd_unet.py
index 6b5d94545..344164cb4 100644
--- a/modules/sd_unet.py
+++ b/modules/sd_unet.py
@@ -102,3 +102,4 @@ def refresh_unet_list():
name = os.path.splitext(basename)[0] if ".safetensors" in basename else basename
unet_dict[name] = file
log.info(f'Available UNets: path="{shared.opts.unet_dir}" items={len(unet_dict)}')
+ return unet_dict
diff --git a/modules/shared.py b/modules/shared.py
index 2bd4cdc53..0a9a20a9a 100644
--- a/modules/shared.py
+++ b/modules/shared.py
@@ -151,6 +151,7 @@ def list_samplers():
modules.sd_samplers.set_samplers()
return modules.sd_samplers.all_samplers
+
log.debug('Initializing: default modes')
startup_offload_mode, startup_offload_min_gpu, startup_offload_max_gpu, startup_cross_attention, startup_sdp_options, startup_sdp_choices, startup_sdp_override_options, startup_sdp_override_choices, startup_offload_always, startup_offload_never = get_default_modes(cmd_opts=cmd_opts, mem_stat=mem_stat)
diff --git a/modules/ui_common.py b/modules/ui_common.py
index 133136d8d..e4957e1df 100644
--- a/modules/ui_common.py
+++ b/modules/ui_common.py
@@ -439,6 +439,7 @@ def update_token_counter(text: str):
from modules.extra_networks import parse_prompt
count_formatted = '0'
+ max_length = 0
visible = False
prompt, _ = parse_prompt(text)
@@ -475,7 +476,7 @@ def update_token_counter(text: str):
token_counts = [len(group) - int(has_bos_token) - int(has_eos_token) for group in ids]
if len(token_counts) > 1:
visible = True
- count_formatted = f"{token_counts} {sum(token_counts)}" if shared.opts.prompt_detailed_tokens else str(sum(token_counts))
+ count_formatted = f"{token_counts}/{sum(token_counts)}"
elif len(token_counts) == 1 and token_counts[0] > 0:
visible = True
count_formatted = str(token_counts[0])
diff --git a/modules/ui_definitions.py b/modules/ui_definitions.py
index a4a9c8e3d..62b42273c 100644
--- a/modules/ui_definitions.py
+++ b/modules/ui_definitions.py
@@ -166,26 +166,6 @@ def create_settings(cmd_opts):
"nunchaku_attention": OptionInfo(False, "Nunchaku attention", gr.Checkbox),
"nunchaku_offload": OptionInfo(False, "Nunchaku offloading", gr.Checkbox),
- "bnb_quantization_sep": OptionInfo("BitsAndBytes ", "", gr.HTML),
- "bnb_quantization": OptionInfo([], "Quantization enabled", gr.CheckboxGroup, {"choices": ["Model", "TE", "LLM", "VAE"]}),
- "bnb_quantization_type": OptionInfo("nf4", "Quantization type", gr.Dropdown, {"choices": ["nf4", "fp8", "fp4"]}),
- "bnb_quantization_storage": OptionInfo("uint8", "Backend storage", gr.Dropdown, {"choices": ["float16", "float32", "int8", "uint8", "float64", "bfloat16"]}),
-
- "quanto_quantization_sep": OptionInfo("Optimum Quanto ", "", gr.HTML),
- "quanto_quantization": OptionInfo([], "Quantization enabled", gr.CheckboxGroup, {"choices": ["Model", "TE", "LLM"]}),
- "quanto_quantization_type": OptionInfo("int8", "Quantization weights type", gr.Dropdown, {"choices": ["float8", "int8", "int4", "int2"]}),
-
- "optimum_quanto_sep": OptionInfo("Optimum Quanto: post-load ", "", gr.HTML),
- "optimum_quanto_weights": OptionInfo([], "Quantization enabled", gr.CheckboxGroup, {"choices": ["Model", "TE", "Control", "VAE"]}),
- "optimum_quanto_weights_type": OptionInfo("qint8", "Quantization weights type", gr.Dropdown, {"choices": ["qint8", "qfloat8_e4m3fn", "qfloat8_e5m2", "qint4", "qint2"]}),
- "optimum_quanto_activations_type": OptionInfo("none", "Quantization activations type ", gr.Dropdown, {"choices": ["none", "qint8", "qfloat8_e4m3fn", "qfloat8_e5m2"]}),
- "optimum_quanto_shuffle_weights": OptionInfo(False, "Shuffle weights in post mode", gr.Checkbox),
-
- "torchao_sep": OptionInfo("TorchAO ", "", gr.HTML),
- "torchao_quantization": OptionInfo([], "Quantization enabled", gr.CheckboxGroup, {"choices": ["Model", "TE", "LLM", "Control", "VAE"]}),
- "torchao_quantization_mode": OptionInfo("auto", "Quantization mode", gr.Dropdown, {"choices": ["auto", "pre", "post"]}),
- "torchao_quantization_type": OptionInfo("int8_weight_only", "Quantization type", gr.Dropdown, {"choices": ["int4_weight_only", "int8_dynamic_activation_int4_weight", "int8_weight_only", "int8_dynamic_activation_int8_weight", "float8_weight_only", "float8_dynamic_activation_float8_weight", "float8_static_activation_float8_weight"]}),
-
"layerwise_quantization_sep": OptionInfo("Layerwise Casting ", "", gr.HTML),
"layerwise_quantization": OptionInfo([], "Layerwise casting enabled", gr.CheckboxGroup, {"choices": ["Model", "TE"]}),
"layerwise_quantization_storage": OptionInfo("float8_e4m3fn", "Layerwise casting storage", gr.Dropdown, {"choices": ["float8_e4m3fn", "float8_e5m2"]}),
@@ -194,14 +174,6 @@ def create_settings(cmd_opts):
"trt_quantization_sep": OptionInfo("TensorRT ", "", gr.HTML),
"trt_quantization": OptionInfo([], "Quantization enabled", gr.CheckboxGroup, {"choices": ["Model"]}),
"trt_quantization_type": OptionInfo("int8", "Quantization type", gr.Dropdown, {"choices": ["int8", "int4", "fp8", "nf4", "nvfp4"]}),
-
- "nncf_compress_sep": OptionInfo("NNCF: Neural Network Compression Framework ", "", gr.HTML, {"visible": cmd_opts.use_openvino}),
- "nncf_compress_weights": OptionInfo([], "Quantization enabled", gr.CheckboxGroup, {"choices": ["Model", "TE", "VAE"], "visible": cmd_opts.use_openvino}),
- "nncf_compress_weights_mode": OptionInfo("INT8_SYM", "Quantization type", gr.Dropdown, {"choices": ["INT8", "INT8_SYM", "FP8", "MXFP8", "INT4_ASYM", "INT4_SYM", "FP4", "MXFP4", "NF4"], "visible": cmd_opts.use_openvino}),
- "nncf_compress_weights_raito": OptionInfo(0, "Compress ratio", gr.Slider, {"minimum": 0, "maximum": 1, "step": 0.01, "visible": cmd_opts.use_openvino}),
- "nncf_compress_weights_group_size": OptionInfo(0, "Group size", gr.Slider, {"minimum": -1, "maximum": 4096, "step": 1, "visible": cmd_opts.use_openvino}),
- "nncf_quantize": OptionInfo([], "Static Quantization enabled", gr.CheckboxGroup, {"choices": ["Model", "TE", "VAE"], "visible": cmd_opts.use_openvino}),
- "nncf_quantize_mode": OptionInfo("INT8", "OpenVINO activations mode", gr.Dropdown, {"choices": ["INT8", "FP8_E4M3", "FP8_E5M2"], "visible": cmd_opts.use_openvino}),
}))
# --- VAE & Text Encoder ---
options_templates.update(options_section(('vae_encoder', "Variational Auto Encoder"), {
diff --git a/modules/ui_extra_networks.py b/modules/ui_extra_networks.py
index d80ff9573..17a1c5b7e 100644
--- a/modules/ui_extra_networks.py
+++ b/modules/ui_extra_networks.py
@@ -584,6 +584,8 @@ def register_pages():
register_page(ExtraNetworksPageLora())
from modules.ui_extra_networks_wildcards import ExtraNetworksPageWildcards
register_page(ExtraNetworksPageWildcards())
+ from modules.ui_extra_networks_unet import ExtraNetworksPageUNets
+ register_page(ExtraNetworksPageUNets())
if shared.opts.latent_history > 0:
from modules.ui_extra_networks_history import ExtraNetworksPageHistory
register_page(ExtraNetworksPageHistory())
@@ -596,7 +598,7 @@ def get_pages(title=None):
visible = shared.opts.extra_networks
pages: list[ExtraNetworksPage] = []
if 'All' in visible or visible == []: # default en sort order
- visible = ['Model', 'Lora', 'Style', 'Wildcards', 'Embedding', 'VAE', 'History', 'Hypernetwork']
+ visible = ['Model', 'Lora', 'UNet/DiT', 'Style', 'Wildcards', 'Embedding', 'VAE', 'History', 'Hypernetwork']
titles = [page.title for page in shared.extra_networks]
if title is None:
@@ -743,7 +745,7 @@ def create_ui(container, button_parent, tabname, skip_indexing = False):
with ui.tabs:
def ui_tab_change(page):
- scan_visible = page in ['Model', 'Lora', 'VAE', 'Hypernetwork', 'Embedding']
+ scan_visible = page in ['Model', 'Lora', 'VAE', 'UNet/DiT', 'Hypernetwork', 'Embedding']
save_visible = page in ['Style']
model_visible = page in ['Model']
return [gr.update(visible=scan_visible), gr.update(visible=save_visible), gr.update(visible=model_visible)]
diff --git a/modules/ui_extra_networks_unet.py b/modules/ui_extra_networks_unet.py
new file mode 100644
index 000000000..7d6e016d6
--- /dev/null
+++ b/modules/ui_extra_networks_unet.py
@@ -0,0 +1,43 @@
+import html
+import json
+import os
+from modules import shared, ui_extra_networks, sd_unet, hashes, modelstats
+from modules.logger import log
+
+
+class ExtraNetworksPageUNets(ui_extra_networks.ExtraNetworksPage):
+ def __init__(self):
+ super().__init__('UNet/DiT')
+
+ def refresh(self):
+ return sd_unet.refresh_unet_list()
+
+ def list_items(self):
+ for name, filename in sd_unet.unet_dict.items():
+ try:
+ size, mtime = modelstats.stat(filename)
+ info = self.find_info(filename)
+ version = self.find_version(None, info)
+ record = {
+ "type": 'UNet/DiT',
+ "name": name,
+ "alias": os.path.splitext(os.path.basename(filename))[0],
+ "title": name,
+ "filename": filename,
+ "hash": hashes.sha256_from_cache(filename, f"unet/{name}"),
+ "preview": self.find_preview(filename),
+ "local_preview": f"{os.path.splitext(filename)[0]}.{shared.opts.samples_format}",
+ "metadata": {},
+ "onclick": '"' + html.escape(f"""return selectUNet({json.dumps(name)})""") + '"',
+ "mtime": mtime,
+ "size": size,
+ "info": info,
+ "description": self.find_description(filename, info),
+ "version": version.get("baseModel", "N/A") if info else "N/A",
+ }
+ yield record
+ except Exception as e:
+ log.debug(f'Networks error: type=vae file="{filename}" {e}')
+
+ def allowed_directories_for_previews(self):
+ return [v for v in [shared.opts.unet_dir] if v is not None]
diff --git a/modules/ui_models.py b/modules/ui_models.py
index 881c11649..c8a981261 100644
--- a/modules/ui_models.py
+++ b/modules/ui_models.py
@@ -12,6 +12,15 @@ from modules.shared import opts, log
extra_ui = []
+def update_model_hashes():
+ from modules import sd_unet, sd_checkpoint
+ unets = {}
+ for k, v in sd_unet.unet_dict.items():
+ unets[k] = sd_checkpoint.CheckpointInfo(name=k, filename=v, model_type='unet')
+ yield from sd_models.update_model_hashes(unets, model_type='unet')
+ yield from sd_models.update_model_hashes(model_type='checkpoint')
+
+
def create_ui():
log.debug('UI initialize: tab=models')
dummy_component = gr.Label(visible=False)
@@ -143,7 +152,7 @@ def create_ui():
with gr.Row():
model_table = gr.HTML(value='', elem_id="model_list_table")
- model_checkhash_btn.click(fn=sd_models.update_model_hashes, inputs=[], outputs=[model_table])
+ model_checkhash_btn.click(fn=update_model_hashes, inputs=[], outputs=[model_table])
model_list_btn.click(fn=lambda: create_models_table(list(sd_models.checkpoints_list.values())), inputs=[], outputs=[model_table])
with gr.Tab(label="Metadata", elem_id="models_metadata_tab"):
diff --git a/modules/ui_sections.py b/modules/ui_sections.py
index 32b71b193..09108d716 100644
--- a/modules/ui_sections.py
+++ b/modules/ui_sections.py
@@ -172,15 +172,15 @@ def create_latent_inputs(tab):
hdr_sharpen = gr.Slider(minimum=-4.0, maximum=4.0, step=0.05, value=0, label="Latent sharpen", elem_id=f"{tab}_hdr_sharpen")
hdr_color = gr.Slider(minimum=0.0, maximum=16.0, step=0.1, value=0.0, label="Latent color", elem_id=f"{tab}_hdr_color")
with gr.Row(elem_id=f"{tab}_hdr_clamp_row"):
- hdr_clamp = gr.Checkbox(label="Clamp", value=False, elem_id=f"{tab}_hdr_clamp")
- hdr_boundary = gr.Slider(minimum=0.0, maximum=10.0, step=0.1, value=4.0, label="Range", elem_id=f"{tab}_hdr_boundary")
- hdr_threshold = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.95, label="Threshold", elem_id=f"{tab}_hdr_threshold")
+ hdr_clamp = gr.Checkbox(label="Latent clamp", value=False, elem_id=f"{tab}_hdr_clamp")
+ hdr_boundary = gr.Slider(minimum=0.0, maximum=10.0, step=0.1, value=4.0, label="Latent range", elem_id=f"{tab}_hdr_boundary")
+ hdr_threshold = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.95, label="Latent threshold", elem_id=f"{tab}_hdr_threshold")
with gr.Row(elem_id=f"{tab}_hdr_max_row"):
- hdr_maximize = gr.Checkbox(label="Maximize", value=False, elem_id=f"{tab}_hdr_maximize")
- hdr_max_center = gr.Slider(minimum=0.0, maximum=2.0, step=0.1, value=0.6, label="Center", elem_id=f"{tab}_hdr_max_center")
- hdr_max_boundary = gr.Slider(minimum=0.5, maximum=2.0, step=0.1, value=1.0, label="Max range", elem_id=f"{tab}_hdr_max_boundary")
+ hdr_maximize = gr.Checkbox(label="Latent maximize", value=False, elem_id=f"{tab}_hdr_maximize")
+ hdr_max_center = gr.Slider(minimum=0.0, maximum=2.0, step=0.1, value=0.6, label="Latent center", elem_id=f"{tab}_hdr_max_center")
+ hdr_max_boundary = gr.Slider(minimum=0.5, maximum=2.0, step=0.1, value=1.0, label="Latent max range", elem_id=f"{tab}_hdr_max_boundary")
with gr.Row(elem_id=f"{tab}_hdr_color_row"):
- hdr_color_picker = gr.ColorPicker(label="Tint color", show_label=True, container=False, value=None, elem_id=f"{tab}_hdr_color_picker")
+ hdr_color_picker = gr.ColorPicker(label="Latent tint", show_label=True, container=False, value=None, elem_id=f"{tab}_hdr_color_picker")
hdr_tint_ratio = gr.Slider(label="Tint strength", minimum=-4.0, maximum=4.0, step=0.05, value=0.0, elem_id=f"{tab}_hdr_tint_ratio")
return hdr_mode, hdr_brightness, hdr_color, hdr_sharpen, hdr_clamp, hdr_boundary, hdr_threshold, hdr_maximize, hdr_max_center, hdr_max_boundary, hdr_color_picker, hdr_tint_ratio, hdr_apply_hires
@@ -197,7 +197,7 @@ def create_color_inputs(tab):
grading_hue = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=0, label='Hue', elem_id=f"{tab}_grading_hue")
grading_gamma = gr.Slider(minimum=0.1, maximum=10.0, step=0.1, value=1.0, label='Gamma', elem_id=f"{tab}_grading_gamma")
grading_sharpness = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, value=0, label='Sharpness', elem_id=f"{tab}_grading_sharpness")
- grading_color_temp = gr.Slider(minimum=2000, maximum=12000, step=100, value=6500, label='Color temp (K)', elem_id=f"{tab}_grading_color_temp")
+ grading_color_temp = gr.Slider(minimum=2000, maximum=12000, step=100, value=6500, label='Color temp', elem_id=f"{tab}_grading_color_temp")
with gr.Group():
gr.HTML('Tone ')
with gr.Row(elem_id=f"{tab}_grading_tone_row"):
@@ -211,7 +211,7 @@ def create_color_inputs(tab):
with gr.Row(elem_id=f"{tab}_grading_split_row"):
grading_shadows_tint = gr.ColorPicker(label="Shadows tint", value="#000000", elem_id=f"{tab}_grading_shadows_tint")
grading_highlights_tint = gr.ColorPicker(label="Highlights tint", value="#ffffff", elem_id=f"{tab}_grading_highlights_tint")
- grading_split_tone_balance = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=0.5, label='Balance', elem_id=f"{tab}_grading_split_tone_balance")
+ grading_split_tone_balance = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=0.5, label='Split tone balance', elem_id=f"{tab}_grading_split_tone_balance")
with gr.Group():
gr.HTML('Effects ')
with gr.Row(elem_id=f"{tab}_grading_effects_row"):
@@ -220,9 +220,9 @@ def create_color_inputs(tab):
with gr.Group():
gr.HTML('LUT ')
with gr.Row(elem_id=f"{tab}_grading_lut_row"):
- grading_lut_file = gr.File(label='LUT .cube file', file_types=['.cube'], elem_id=f"{tab}_grading_lut_file")
+ grading_lut_cube_file = gr.File(label='LUT .cube file', file_types=['.cube'], elem_id=f"{tab}_grading_lut_file")
grading_lut_strength = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, value=1.0, label='LUT strength', elem_id=f"{tab}_grading_lut_strength")
- return grading_brightness, grading_contrast, grading_saturation, grading_hue, grading_gamma, grading_sharpness, grading_color_temp, grading_shadows, grading_midtones, grading_highlights, grading_clahe_clip, grading_clahe_grid, grading_shadows_tint, grading_highlights_tint, grading_split_tone_balance, grading_vignette, grading_grain, grading_lut_file, grading_lut_strength
+ return grading_brightness, grading_contrast, grading_saturation, grading_hue, grading_gamma, grading_sharpness, grading_color_temp, grading_shadows, grading_midtones, grading_highlights, grading_clahe_clip, grading_clahe_grid, grading_shadows_tint, grading_highlights_tint, grading_split_tone_balance, grading_vignette, grading_grain, grading_lut_cube_file, grading_lut_strength
def create_sampler_and_steps_selection(choices, tabname, default_steps:int=20):
diff --git a/modules/ui_settings.py b/modules/ui_settings.py
index 317186343..80c310e5b 100644
--- a/modules/ui_settings.py
+++ b/modules/ui_settings.py
@@ -396,6 +396,13 @@ def create_quicksettings(interfaces):
inputs=[shared.settings_components['sd_vae'], dummy_component],
outputs=[shared.settings_components['sd_vae'], text_settings],
)
+ button_set_unet = gr.Button("Change UNet", elem_id="change_unet", visible=False)
+ button_set_unet.click(
+ fn=lambda value, _: run_settings_single(value, key="sd_unet"),
+ _js="function(v){ var res = desiredUNetName; desiredUNetName = ''; return [res || v, null]; }",
+ inputs=[shared.settings_components["sd_unet"], dummy_component],
+ outputs=[shared.settings_components["sd_unet"], text_settings],
+ )
def reference_submit(model):
if '@' not in model: # diffusers
diff --git a/package.json b/package.json
index e3e948c65..9fe57fd1a 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,7 @@
"venv": ". venv/bin/activate",
"start": ". venv/bin/activate; python launch.py --debug",
"localize": "node cli/localize.js",
- "packages": ". venv/bin/activate && pip install --upgrade transformers accelerate huggingface_hub safetensors tokenizers peft pytorch_lightning pylint ruff",
+ "packages": ". venv/bin/activate && pip install --upgrade accelerate huggingface_hub safetensors tokenizers peft pytorch_lightning pylint ruff",
"format": ". venv/bin/activate && pre-commit run --all-files",
"format-win": "venv\\scripts\\activate && pre-commit run --all-files",
"eslint": "eslint . javascript/",
diff --git a/pipelines/flux/flux2_lora.py b/pipelines/flux/flux2_lora.py
new file mode 100644
index 000000000..a2d433992
--- /dev/null
+++ b/pipelines/flux/flux2_lora.py
@@ -0,0 +1,216 @@
+"""Flux2/Klein-specific LoRA loading.
+
+Handles:
+- Bare BFL-format keys in state dicts (adds diffusion_model. prefix for converter)
+- LoKR adapters via native module loading (bypasses diffusers PEFT system)
+
+Installed via apply_patch() during pipeline loading.
+"""
+
+import os
+import time
+from modules import shared, sd_models
+from modules.logger import log
+from modules.lora import network, network_lokr, lora_convert
+from modules.lora import lora_common as l
+
+
+BARE_FLUX_PREFIXES = ("single_blocks.", "double_blocks.", "img_in.", "txt_in.",
+ "final_layer.", "time_in.", "single_stream_modulation.",
+ "double_stream_modulation_")
+
+# BFL -> diffusers module path mapping for Flux2/Klein
+F2_SINGLE_MAP = {
+ 'linear1': 'attn.to_qkv_mlp_proj',
+ 'linear2': 'attn.to_out',
+}
+F2_DOUBLE_MAP = {
+ 'img_attn.proj': 'attn.to_out.0',
+ 'txt_attn.proj': 'attn.to_add_out',
+ 'img_mlp.0': 'ff.linear_in',
+ 'img_mlp.2': 'ff.linear_out',
+ 'txt_mlp.0': 'ff_context.linear_in',
+ 'txt_mlp.2': 'ff_context.linear_out',
+}
+F2_QKV_MAP = {
+ 'img_attn.qkv': ('attn', ['to_q', 'to_k', 'to_v']),
+ 'txt_attn.qkv': ('attn', ['add_q_proj', 'add_k_proj', 'add_v_proj']),
+}
+
+
+def apply_lora_alphas(state_dict):
+ """Bake kohya-format .alpha scaling into lora_down weights and remove alpha keys.
+
+ Diffusers' Flux2 converter only handles lora_A/lora_B (or lora_down/lora_up) keys.
+ Kohya-format LoRAs store per-layer alpha values as separate .alpha keys that the
+ converter doesn't consume, causing a ValueError on leftover keys. This matches the
+ approach used by _convert_kohya_flux_lora_to_diffusers for Flux 1.
+ """
+ alpha_keys = [k for k in state_dict if k.endswith('.alpha')]
+ if not alpha_keys:
+ return state_dict
+ for alpha_key in alpha_keys:
+ base = alpha_key[:-len('.alpha')]
+ down_key = f'{base}.lora_down.weight'
+ if down_key not in state_dict:
+ continue
+ down_weight = state_dict[down_key]
+ rank = down_weight.shape[0]
+ alpha = state_dict.pop(alpha_key).item()
+ scale = alpha / rank
+ scale_down = scale
+ scale_up = 1.0
+ while scale_down * 2 < scale_up:
+ scale_down *= 2
+ scale_up /= 2
+ state_dict[down_key] = down_weight * scale_down
+ up_key = f'{base}.lora_up.weight'
+ if up_key in state_dict:
+ state_dict[up_key] = state_dict[up_key] * scale_up
+ remaining = [k for k in state_dict if k.endswith('.alpha')]
+ if remaining:
+ log.debug(f'Network load: type=LoRA stripped {len(remaining)} orphaned alpha keys')
+ for k in remaining:
+ del state_dict[k]
+ return state_dict
+
+
+def preprocess_f2_keys(state_dict):
+ """Add 'diffusion_model.' prefix to bare BFL-format keys so
+ Flux2LoraLoaderMixin's format detection routes them to the converter."""
+ if any(k.startswith("diffusion_model.") or k.startswith("base_model.model.") for k in state_dict):
+ return state_dict
+ if any(k.startswith(p) for k in state_dict for p in BARE_FLUX_PREFIXES):
+ log.debug('Network load: type=LoRA adding diffusion_model prefix for bare BFL-format keys')
+ state_dict = {f"diffusion_model.{k}": v for k, v in state_dict.items()}
+ return state_dict
+
+
+def try_load_lokr(name, network_on_disk, lora_scale):
+ """Try loading a Flux2/Klein LoRA as LoKR native modules.
+
+ Returns a Network with native modules if the state dict contains LoKR keys,
+ or None to fall through to the generic diffusers path.
+ """
+ t0 = time.time()
+ state_dict = sd_models.read_state_dict(network_on_disk.filename, what='network')
+ if not any('.lokr_w1' in k for k in state_dict):
+ return None
+ net = load_lokr_native(name, network_on_disk, state_dict)
+ if len(net.modules) == 0:
+ log.error(f'Network load: type=LoKR name="{name}" no modules matched')
+ return None
+ log.debug(f'Network load: type=LoKR name="{name}" native modules={len(net.modules)} scale={lora_scale}')
+ l.timer.activate += time.time() - t0
+ return net
+
+
+def load_lokr_native(name, network_on_disk, state_dict):
+ """Load Flux2 LoKR as native modules applied at inference time.
+
+ Stores only the compact LoKR factors (w1, w2) and computes kron(w1, w2)
+ on-the-fly during weight application. For fused QKV modules in double
+ blocks, NetworkModuleLokrChunk computes the full Kronecker product and
+ returns only its designated Q/K/V chunk, then frees the temporary.
+ """
+ prefix = "diffusion_model."
+ sd_model = getattr(shared.sd_model, "pipe", shared.sd_model)
+ lora_convert.assign_network_names_to_compvis_modules(sd_model)
+ net = network.Network(name, network_on_disk)
+ net.mtime = os.path.getmtime(network_on_disk.filename)
+
+ for key in list(state_dict.keys()):
+ if not key.endswith('.lokr_w1'):
+ continue
+ if not key.startswith(prefix):
+ continue
+
+ base = key[len(prefix):].rsplit('.lokr_w1', 1)[0]
+ lokr_weights = {}
+ for suffix in ['lokr_w1', 'lokr_w2', 'lokr_w1_a', 'lokr_w1_b', 'lokr_w2_a', 'lokr_w2_b', 'lokr_t2', 'alpha']:
+ full_key = f'{prefix}{base}.{suffix}'
+ if full_key in state_dict:
+ lokr_weights[suffix] = state_dict[full_key]
+
+ parts = base.split('.')
+ block_type, block_idx, module_suffix = parts[0], parts[1], '.'.join(parts[2:])
+
+ targets = [] # (module_path, chunk_index, num_chunks)
+ if block_type == 'single_blocks' and module_suffix in F2_SINGLE_MAP:
+ path = f'single_transformer_blocks.{block_idx}.{F2_SINGLE_MAP[module_suffix]}'
+ targets.append((path, None, None))
+ elif block_type == 'double_blocks':
+ if module_suffix in F2_DOUBLE_MAP:
+ path = f'transformer_blocks.{block_idx}.{F2_DOUBLE_MAP[module_suffix]}'
+ targets.append((path, None, None))
+ elif module_suffix in F2_QKV_MAP:
+ attn_prefix, proj_keys = F2_QKV_MAP[module_suffix]
+ for i, proj_key in enumerate(proj_keys):
+ path = f'transformer_blocks.{block_idx}.{attn_prefix}.{proj_key}'
+ targets.append((path, i, len(proj_keys)))
+
+ for module_path, chunk_index, num_chunks in targets:
+ network_key = "lora_transformer_" + module_path.replace(".", "_")
+ sd_module = sd_model.network_layer_mapping.get(network_key)
+ if sd_module is None:
+ log.warning(f'Network load: type=LoKR module not found in mapping: {network_key}')
+ continue
+ weights = network.NetworkWeights(
+ network_key=network_key,
+ sd_key=network_key,
+ w=dict(lokr_weights),
+ sd_module=sd_module,
+ )
+ if chunk_index is not None:
+ net.modules[network_key] = network_lokr.NetworkModuleLokrChunk(net, weights, chunk_index, num_chunks)
+ else:
+ net.modules[network_key] = network_lokr.NetworkModuleLokr(net, weights)
+
+ return net
+
+
+patched = False
+
+
+def apply_patch():
+ """Patch Flux2LoraLoaderMixin.lora_state_dict to handle bare BFL-format keys.
+
+ When a LoRA file has bare BFL keys (no diffusion_model. prefix), the original
+ lora_state_dict won't detect them as AI toolkit format. This patch checks for
+ bare keys after the original returns and adds the prefix + re-runs conversion.
+ """
+ global patched # pylint: disable=global-statement
+ if patched:
+ return
+ patched = True
+
+ from diffusers.loaders.lora_pipeline import Flux2LoraLoaderMixin
+ original_lora_state_dict = Flux2LoraLoaderMixin.lora_state_dict.__func__
+
+ @classmethod # pylint: disable=no-self-argument
+ def patched_lora_state_dict(cls, pretrained_model_name_or_path_or_dict, **kwargs):
+ if isinstance(pretrained_model_name_or_path_or_dict, dict):
+ pretrained_model_name_or_path_or_dict = preprocess_f2_keys(pretrained_model_name_or_path_or_dict)
+ pretrained_model_name_or_path_or_dict = apply_lora_alphas(pretrained_model_name_or_path_or_dict)
+ elif isinstance(pretrained_model_name_or_path_or_dict, (str, os.PathLike)):
+ path = str(pretrained_model_name_or_path_or_dict)
+ if path.endswith('.safetensors'):
+ try:
+ from safetensors import safe_open
+ with safe_open(path, framework="pt") as f:
+ keys = list(f.keys())
+ needs_load = (
+ any(k.endswith('.alpha') for k in keys)
+ or (not any(k.startswith("diffusion_model.") or k.startswith("base_model.model.") for k in keys)
+ and any(k.startswith(p) for k in keys for p in BARE_FLUX_PREFIXES))
+ )
+ if needs_load:
+ from safetensors.torch import load_file
+ sd = load_file(path)
+ sd = preprocess_f2_keys(sd)
+ pretrained_model_name_or_path_or_dict = apply_lora_alphas(sd)
+ except Exception:
+ pass
+ return original_lora_state_dict(cls, pretrained_model_name_or_path_or_dict, **kwargs)
+
+ Flux2LoraLoaderMixin.lora_state_dict = patched_lora_state_dict
diff --git a/pipelines/flux/flux_bnb.py b/pipelines/flux/flux_bnb.py
deleted file mode 100644
index 777678af1..000000000
--- a/pipelines/flux/flux_bnb.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import diffusers
-import transformers
-from modules import devices, model_quant
-
-
-def load_flux_bnb(checkpoint_info, diffusers_load_config): # pylint: disable=unused-argument
- transformer = None
- if isinstance(checkpoint_info, str):
- repo_path = checkpoint_info
- else:
- repo_path = checkpoint_info.path
- model_quant.load_bnb('Load model: type=FLUX')
- quant = model_quant.get_quant(repo_path)
- if quant == 'fp8':
- quantization_config = transformers.BitsAndBytesConfig(load_in_8bit=True, bnb_4bit_compute_dtype=devices.dtype)
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config, quantization_config=quantization_config)
- elif quant == 'fp4':
- quantization_config = transformers.BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=devices.dtype, bnb_4bit_quant_type= 'fp4')
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config, quantization_config=quantization_config)
- elif quant == 'nf4':
- quantization_config = transformers.BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=devices.dtype, bnb_4bit_quant_type= 'nf4')
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config, quantization_config=quantization_config)
- else:
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config)
- return transformer
diff --git a/pipelines/flux/flux_legacy_loader.py b/pipelines/flux/flux_legacy_loader.py
deleted file mode 100644
index c3da3eb8f..000000000
--- a/pipelines/flux/flux_legacy_loader.py
+++ /dev/null
@@ -1,361 +0,0 @@
-import os
-import json
-import torch
-import diffusers
-import transformers
-from safetensors.torch import load_file
-from huggingface_hub import hf_hub_download
-from modules import shared, errors, devices, sd_models, sd_unet, model_te, model_quant, sd_hijack_te
-from modules.logger import log
-
-
-debug = log.trace if os.environ.get('SD_LOAD_DEBUG', None) is not None else lambda *args, **kwargs: None
-
-
-def load_flux_quanto(checkpoint_info):
- transformer, text_encoder_2 = None, None
- quanto = model_quant.load_quanto('Load model: type=FLUX')
-
- if isinstance(checkpoint_info, str):
- repo_path = checkpoint_info
- else:
- repo_path = checkpoint_info.path
-
- try:
- quantization_map = os.path.join(repo_path, "transformer", "quantization_map.json")
- debug(f'Load model: type=FLUX quantization map="{quantization_map}" repo="{checkpoint_info.name}" component="transformer"')
- if not os.path.exists(quantization_map):
- repo_id = sd_models.path_to_repo(checkpoint_info)
- quantization_map = hf_hub_download(repo_id, subfolder='transformer', filename='quantization_map.json', cache_dir=shared.opts.diffusers_dir)
- with open(quantization_map, "r", encoding='utf8') as f:
- quantization_map = json.load(f)
- state_dict = load_file(os.path.join(repo_path, "transformer", "diffusion_pytorch_model.safetensors"))
- dtype = state_dict['context_embedder.bias'].dtype
- with torch.device("meta"):
- transformer = diffusers.FluxTransformer2DModel.from_config(os.path.join(repo_path, "transformer", "config.json")).to(dtype=dtype)
- quanto.requantize(transformer, state_dict, quantization_map, device=torch.device("cpu"))
- transformer_dtype = transformer.dtype
- if transformer_dtype != devices.dtype:
- try:
- transformer = transformer.to(dtype=devices.dtype)
- except Exception:
- log.error(f"Load model: type=FLUX Failed to cast transformer to {devices.dtype}, set dtype to {transformer_dtype}")
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load Quanto transformer: {e}")
- if debug:
- errors.display(e, 'FLUX Quanto:')
-
- try:
- quantization_map = os.path.join(repo_path, "text_encoder_2", "quantization_map.json")
- debug(f'Load model: type=FLUX quantization map="{quantization_map}" repo="{checkpoint_info.name}" component="text_encoder_2"')
- if not os.path.exists(quantization_map):
- repo_id = sd_models.path_to_repo(checkpoint_info)
- quantization_map = hf_hub_download(repo_id, subfolder='text_encoder_2', filename='quantization_map.json', cache_dir=shared.opts.diffusers_dir)
- with open(quantization_map, "r", encoding='utf8') as f:
- quantization_map = json.load(f)
- with open(os.path.join(repo_path, "text_encoder_2", "config.json"), encoding='utf8') as f:
- t5_config = transformers.T5Config(**json.load(f))
- state_dict = load_file(os.path.join(repo_path, "text_encoder_2", "model.safetensors"))
- dtype = state_dict['encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight'].dtype
- with torch.device("meta"):
- text_encoder_2 = transformers.T5EncoderModel(t5_config).to(dtype=dtype)
- quanto.requantize(text_encoder_2, state_dict, quantization_map, device=torch.device("cpu"))
- text_encoder_2_dtype = text_encoder_2.dtype
- if text_encoder_2_dtype != devices.dtype:
- try:
- text_encoder_2 = text_encoder_2.to(dtype=devices.dtype)
- except Exception:
- log.error(f"Load model: type=FLUX Failed to cast text encoder to {devices.dtype}, set dtype to {text_encoder_2_dtype}")
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load Quanto text encoder: {e}")
- if debug:
- errors.display(e, 'FLUX Quanto:')
-
- return transformer, text_encoder_2
-
-
-def load_flux_bnb(checkpoint_info, diffusers_load_config): # pylint: disable=unused-argument
- transformer, text_encoder_2 = None, None
- if isinstance(checkpoint_info, str):
- repo_path = checkpoint_info
- else:
- repo_path = checkpoint_info.path
- model_quant.load_bnb('Load model: type=FLUX')
- quant = model_quant.get_quant(repo_path)
- try:
- if quant == 'fp8':
- quantization_config = transformers.BitsAndBytesConfig(load_in_8bit=True, bnb_4bit_compute_dtype=devices.dtype)
- debug(f'Quantization: {quantization_config}')
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config, quantization_config=quantization_config)
- elif quant == 'fp4':
- quantization_config = transformers.BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=devices.dtype, bnb_4bit_quant_type= 'fp4')
- debug(f'Quantization: {quantization_config}')
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config, quantization_config=quantization_config)
- elif quant == 'nf4':
- quantization_config = transformers.BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=devices.dtype, bnb_4bit_quant_type= 'nf4')
- debug(f'Quantization: {quantization_config}')
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config, quantization_config=quantization_config)
- else:
- transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config)
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load BnB transformer: {e}")
- transformer, text_encoder_2 = None, None
- if debug:
- errors.display(e, 'FLUX:')
- return transformer, text_encoder_2
-
-
-def load_quants(kwargs, repo_id, cache_dir, allow_quant): # pylint: disable=unused-argument
- try:
- diffusers_load_config = {
- "torch_dtype": devices.dtype,
- "cache_dir": cache_dir,
- }
- if 'transformer' not in kwargs and model_quant.check_nunchaku('Model'):
- import nunchaku
- nunchaku_precision = nunchaku.utils.get_precision()
- nunchaku_repo = None
- if 'flux.1-kontext' in repo_id.lower():
- nunchaku_repo = f"mit-han-lab/nunchaku-flux.1-kontext-dev/svdq-{nunchaku_precision}_r32-flux.1-kontext-dev.safetensors"
- elif 'flux.1-dev' in repo_id.lower():
- nunchaku_repo = f"mit-han-lab/nunchaku-flux.1-dev/svdq-{nunchaku_precision}_r32-flux.1-dev.safetensors"
- elif 'flux.1-schnell' in repo_id.lower():
- nunchaku_repo = f"mit-han-lab/nunchaku-flux.1-schnell/svdq-{nunchaku_precision}_r32-flux.1-schnell.safetensors"
- elif 'flux.1-fill' in repo_id.lower():
- nunchaku_repo = f"mit-han-lab/svdq-fp4-flux.1-fill-dev/svdq-{nunchaku_precision}_r32-flux.1-schnell.safetensors"
- elif 'flux.1-depth' in repo_id.lower():
- nunchaku_repo = f"mit-han-lab/svdq-int4-flux.1-depth-dev/svdq-{nunchaku_precision}_r32-flux.1-schnell.safetensors"
- elif 'shuttle' in repo_id.lower():
- nunchaku_repo = f"mit-han-lab/nunchaku-shuttle-jaguar/svdq-{nunchaku_precision}_r32-shuttle-jaguar.safetensors"
- else:
- log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
- if nunchaku_repo is not None:
- log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
- kwargs['transformer'] = nunchaku.NunchakuFluxTransformer2dModel.from_pretrained(nunchaku_repo, offload=shared.opts.nunchaku_offload, torch_dtype=devices.dtype, cache_dir=cache_dir)
- kwargs['transformer'].quantization_method = 'SVDQuant'
- if shared.opts.nunchaku_attention:
- kwargs['transformer'].set_attention_impl("nunchaku-fp16")
- if 'transformer' not in kwargs and model_quant.check_quant('Model'):
- load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='Model', device_map=True)
- kwargs['transformer'] = diffusers.FluxTransformer2DModel.from_pretrained(repo_id, subfolder="transformer", **load_args, **quant_args)
- if 'text_encoder_2' not in kwargs and model_quant.check_nunchaku('TE'):
- import nunchaku
- nunchaku_precision = nunchaku.utils.get_precision()
- nunchaku_repo = 'mit-han-lab/nunchaku-t5/awq-int4-flux.1-t5xxl.safetensors'
- log.debug(f'Load module: quant=Nunchaku module=t5 repo="{nunchaku_repo}" precision={nunchaku_precision}')
- kwargs['text_encoder_2'] = nunchaku.NunchakuT5EncoderModel.from_pretrained(nunchaku_repo, torch_dtype=devices.dtype, cache_dir=cache_dir)
- kwargs['text_encoder_2'].quantization_method = 'SVDQuant'
- if 'text_encoder_2' not in kwargs and model_quant.check_quant('TE'):
- load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='TE', device_map=True)
- kwargs['text_encoder_2'] = transformers.T5EncoderModel.from_pretrained(repo_id, subfolder="text_encoder_2", **load_args, **quant_args)
- except Exception as e:
- log.error(f'Quantization: {e}')
- errors.display(e, 'Quantization:')
- return kwargs
-
-
-def load_transformer(file_path): # triggered by opts.sd_unet change
- if file_path is None or not os.path.exists(file_path):
- return None
- transformer = None
- quant = model_quant.get_quant(file_path)
- diffusers_load_config = {
- "torch_dtype": devices.dtype,
- "cache_dir": shared.opts.hfcache_dir,
- }
- if quant is not None and quant != 'none':
- log.info(f'Load module: type=UNet/Transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} prequant={quant} dtype={devices.dtype}')
- if 'gguf' in file_path.lower():
- from modules import ggml
- _transformer = ggml.load_gguf(file_path, cls=diffusers.FluxTransformer2DModel, compute_dtype=devices.dtype)
- if _transformer is not None:
- transformer = _transformer
- elif quant == "fp8":
- _transformer = model_quant.load_fp8_model_layerwise(file_path, diffusers.FluxTransformer2DModel.from_single_file, diffusers_load_config)
- if _transformer is not None:
- transformer = _transformer
- elif quant in {'qint8', 'qint4'}:
- _transformer, _text_encoder_2 = load_flux_quanto(file_path)
- if _transformer is not None:
- transformer = _transformer
- elif quant in {'fp8', 'fp4', 'nf4'}:
- _transformer, _text_encoder_2 = load_flux_bnb(file_path, diffusers_load_config)
- if _transformer is not None:
- transformer = _transformer
- elif 'nf4' in quant:
- from pipelines.flux.flux_nf4 import load_flux_nf4
- _transformer, _text_encoder_2 = load_flux_nf4(file_path, prequantized=True)
- if _transformer is not None:
- transformer = _transformer
- else:
- quant_args = model_quant.create_bnb_config({})
- if quant_args:
- log.info(f'Load module: type=Flux transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} quant=bnb dtype={devices.dtype}')
- from pipelines.flux.flux_nf4 import load_flux_nf4
- transformer, _text_encoder_2 = load_flux_nf4(file_path, prequantized=False)
- if transformer is not None:
- return transformer
- load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='Model', device_map=True)
- log.debug(f'Load model: type=Flux transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} args={load_args}')
- transformer = diffusers.FluxTransformer2DModel.from_single_file(file_path, **load_args, **quant_args)
- if transformer is None:
- log.error('Failed to load UNet model')
- shared.opts.sd_unet = 'Default'
- return transformer
-
-
-def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_checkpoint change
- repo_id = sd_models.path_to_repo(checkpoint_info)
- sd_models.hf_auth_check(checkpoint_info)
- allow_post_quant = False
-
- prequantized = model_quant.get_quant(checkpoint_info.path)
- log.debug(f'Load model: type=FLUX model="{checkpoint_info.name}" repo="{repo_id}" unet="{shared.opts.sd_unet}" te="{shared.opts.sd_text_encoder}" vae="{shared.opts.sd_vae}" quant={prequantized} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype}')
- debug(f'Load model: type=FLUX config={diffusers_load_config}')
-
- transformer = None
- text_encoder_1 = None
- text_encoder_2 = None
- vae = None
-
- # unload current model
- sd_models.unload_model_weights()
- shared.sd_model = None
- devices.torch_gc(force=True, reason='load')
-
- if shared.opts.teacache_enabled:
- from modules import teacache
- log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.FluxTransformer2DModel.__name__}')
- diffusers.FluxTransformer2DModel.forward = teacache.teacache_flux_forward # patch must be done before transformer is loaded
-
- # load overrides if any
- if shared.opts.sd_unet != 'Default':
- try:
- debug(f'Load model: type=FLUX unet="{shared.opts.sd_unet}"')
- transformer = load_transformer(sd_unet.unet_dict[shared.opts.sd_unet])
- if transformer is None:
- shared.opts.sd_unet = 'Default'
- sd_unet.failed_unet.append(shared.opts.sd_unet)
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load UNet: {e}")
- shared.opts.sd_unet = 'Default'
- if debug:
- errors.display(e, 'FLUX UNet:')
- if shared.opts.sd_text_encoder != 'Default':
- try:
- debug(f'Load model: type=FLUX te="{shared.opts.sd_text_encoder}"')
- from modules.model_te import load_t5, load_vit_l
- if 'vit-l' in shared.opts.sd_text_encoder.lower():
- text_encoder_1 = load_vit_l()
- else:
- text_encoder_2 = load_t5(name=shared.opts.sd_text_encoder, cache_dir=shared.opts.diffusers_dir)
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load T5: {e}")
- shared.opts.sd_text_encoder = 'Default'
- if debug:
- errors.display(e, 'FLUX T5:')
- if shared.opts.sd_vae != 'Default' and shared.opts.sd_vae != 'Automatic':
- try:
- debug(f'Load model: type=FLUX vae="{shared.opts.sd_vae}"')
- from modules import sd_vae
- # vae = sd_vae.load_vae_diffusers(None, sd_vae.vae_dict[shared.opts.sd_vae], 'override')
- vae_file = sd_vae.vae_dict[shared.opts.sd_vae]
- if os.path.exists(vae_file):
- vae_config = os.path.join('configs', 'flux', 'vae', 'config.json')
- vae = diffusers.AutoencoderKL.from_single_file(vae_file, config=vae_config, **diffusers_load_config)
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load VAE: {e}")
- shared.opts.sd_vae = 'Default'
- if debug:
- errors.display(e, 'FLUX VAE:')
-
- # load quantized components if any
- if prequantized == 'nf4':
- try:
- from pipelines.flux.flux_nf4 import load_flux_nf4
- _transformer, _text_encoder = load_flux_nf4(checkpoint_info)
- if _transformer is not None:
- transformer = _transformer
- if _text_encoder is not None:
- text_encoder_2 = _text_encoder
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load NF4 components: {e}")
- if debug:
- errors.display(e, 'FLUX NF4:')
- if prequantized == 'qint8' or prequantized == 'qint4':
- try:
- _transformer, _text_encoder = load_flux_quanto(checkpoint_info)
- if _transformer is not None:
- transformer = _transformer
- if _text_encoder is not None:
- text_encoder_2 = _text_encoder
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load Quanto components: {e}")
- if debug:
- errors.display(e, 'FLUX Quanto:')
-
- # initialize pipeline with pre-loaded components
- kwargs = {}
- if transformer is not None:
- kwargs['transformer'] = transformer
- sd_unet.loaded_unet = shared.opts.sd_unet
- if text_encoder_1 is not None:
- kwargs['text_encoder'] = text_encoder_1
- model_te.loaded_te = shared.opts.sd_text_encoder
- if text_encoder_2 is not None:
- kwargs['text_encoder_2'] = text_encoder_2
- model_te.loaded_te = shared.opts.sd_text_encoder
- if vae is not None:
- kwargs['vae'] = vae
- if repo_id == 'sayakpaul/flux.1-dev-nf4':
- repo_id = 'black-forest-labs/FLUX.1-dev' # workaround since sayakpaul model is missing model_index.json
- if 'Fill' in repo_id:
- cls = diffusers.FluxFillPipeline
- elif 'Canny' in repo_id:
- cls = diffusers.FluxControlPipeline
- elif 'Depth' in repo_id:
- cls = diffusers.FluxControlPipeline
- elif 'Kontext' in repo_id:
- cls = diffusers.FluxKontextPipeline
- from diffusers import pipelines
- pipelines.auto_pipeline.AUTO_TEXT2IMAGE_PIPELINES_MAPPING["flux1kontext"] = diffusers.FluxKontextPipeline
- pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING["flux1kontext"] = diffusers.FluxKontextPipeline
- pipelines.auto_pipeline.AUTO_INPAINT_PIPELINES_MAPPING["flux1kontext"] = diffusers.FluxKontextInpaintPipeline
-
- else:
- cls = diffusers.FluxPipeline
- log.debug(f'Load model: type=FLUX cls={cls.__name__} preloaded={list(kwargs)} revision={diffusers_load_config.get("revision", None)}')
- for c in kwargs:
- if getattr(kwargs[c], 'quantization_method', None) is not None or getattr(kwargs[c], 'gguf', None) is not None:
- log.debug(f'Load model: type=FLUX component={c} dtype={kwargs[c].dtype} quant={getattr(kwargs[c], "quantization_method", None) or getattr(kwargs[c], "gguf", None)}')
- if kwargs[c].dtype == torch.float32 and devices.dtype != torch.float32:
- try:
- kwargs[c] = kwargs[c].to(dtype=devices.dtype)
- log.warning(f'Load model: type=FLUX component={c} dtype={kwargs[c].dtype} cast dtype={devices.dtype} recast')
- except Exception:
- pass
-
- allow_quant = 'gguf' not in (sd_unet.loaded_unet or '') and (prequantized is None or prequantized == 'none')
- fn = checkpoint_info.path
- if (fn is None) or (not os.path.exists(fn) or os.path.isdir(fn)):
- kwargs = load_quants(kwargs, repo_id, cache_dir=shared.opts.diffusers_dir, allow_quant=allow_quant)
- if fn.endswith('.safetensors') and os.path.isfile(fn):
- pipe = cls.from_single_file(fn, cache_dir=shared.opts.diffusers_dir, **kwargs, **diffusers_load_config)
- allow_post_quant = True
- else:
- pipe = cls.from_pretrained(repo_id, cache_dir=shared.opts.diffusers_dir, **kwargs, **diffusers_load_config)
-
- if shared.opts.teacache_enabled and model_quant.check_nunchaku('Model'):
- from nunchaku.caching.diffusers_adapters import apply_cache_on_pipe
- apply_cache_on_pipe(pipe, residual_diff_threshold=0.12)
-
- # release memory
- transformer = None
- text_encoder_1 = None
- text_encoder_2 = None
- vae = None
- for k in kwargs.keys():
- kwargs[k] = None
- sd_hijack_te.init_hijack(pipe)
- devices.torch_gc(force=True, reason='load')
- return pipe, allow_post_quant
diff --git a/pipelines/flux/flux_nf4.py b/pipelines/flux/flux_nf4.py
deleted file mode 100644
index 08c124b0b..000000000
--- a/pipelines/flux/flux_nf4.py
+++ /dev/null
@@ -1,201 +0,0 @@
-"""
-Copied from: https://github.com/huggingface/diffusers/issues/9165
-"""
-
-import os
-import torch
-import torch.nn as nn
-from transformers.quantizers.quantizers_utils import get_module_from_name
-from huggingface_hub import hf_hub_download
-from accelerate import init_empty_weights
-from accelerate.utils import set_module_tensor_to_device
-from diffusers.loaders.single_file_utils import convert_flux_transformer_checkpoint_to_diffusers
-import safetensors.torch
-from modules import shared, devices, model_quant
-from modules.logger import log
-
-
-debug = os.environ.get('SD_LOAD_DEBUG', None) is not None
-
-
-def _replace_with_bnb_linear(
- model,
- method="nf4",
- has_been_replaced=False,
-):
- """
- Private method that wraps the recursion for module replacement.
- Returns the converted model and a boolean that indicates if the conversion has been successfull or not.
- """
- bnb = model_quant.load_bnb('Load model: type=FLUX')
- for name, module in model.named_children():
- if isinstance(module, nn.Linear):
- with init_empty_weights():
- in_features = module.in_features
- out_features = module.out_features
-
- if method == "llm_int8":
- model._modules[name] = bnb.nn.Linear8bitLt( # pylint: disable=protected-access
- in_features,
- out_features,
- module.bias is not None,
- has_fp16_weights=False,
- threshold=6.0,
- )
- has_been_replaced = True
- else:
- model._modules[name] = bnb.nn.Linear4bit( # pylint: disable=protected-access
- in_features,
- out_features,
- module.bias is not None,
- compute_dtype=devices.dtype,
- compress_statistics=False,
- quant_type="nf4",
- )
- has_been_replaced = True
- # Store the module class in case we need to transpose the weight later
- model._modules[name].source_cls = type(module) # pylint: disable=protected-access
- # Force requires grad to False to avoid unexpected errors
- model._modules[name].requires_grad_(False) # pylint: disable=protected-access
-
- if len(list(module.children())) > 0:
- _, has_been_replaced = _replace_with_bnb_linear(
- module,
- has_been_replaced=has_been_replaced,
- )
- # Remove the last key for recursion
- return model, has_been_replaced
-
-
-def check_quantized_param(
- model,
- param_name: str,
-) -> bool:
- bnb = model_quant.load_bnb('Load model: type=FLUX')
- module, tensor_name = get_module_from_name(model, param_name)
- if isinstance(module._parameters.get(tensor_name, None), bnb.nn.Params4bit): # pylint: disable=protected-access
- # Add here check for loaded components' dtypes once serialization is implemented
- return True
- elif isinstance(module, bnb.nn.Linear4bit) and tensor_name == "bias":
- # bias could be loaded by regular set_module_tensor_to_device() from accelerate,
- # but it would wrongly use uninitialized weight there.
- return True
- else:
- return False
-
-
-def create_quantized_param(
- model,
- param_value: "torch.Tensor",
- param_name: str,
- target_device: "torch.device",
- state_dict=None,
- unexpected_keys=None,
- pre_quantized=False
-):
- bnb = model_quant.load_bnb('Load model: type=FLUX')
- module, tensor_name = get_module_from_name(model, param_name)
-
- if tensor_name not in module._parameters: # pylint: disable=protected-access
- raise ValueError(f"{module} does not have a parameter or a buffer named {tensor_name}.")
-
- old_value = getattr(module, tensor_name)
-
- if tensor_name == "bias":
- if param_value is None:
- new_value = old_value.to(target_device)
- else:
- new_value = param_value.to(target_device)
- new_value = torch.nn.Parameter(new_value, requires_grad=old_value.requires_grad)
- module._parameters[tensor_name] = new_value # pylint: disable=protected-access
- return
-
- if not isinstance(module._parameters[tensor_name], bnb.nn.Params4bit): # pylint: disable=protected-access
- raise ValueError("this function only loads `Linear4bit components`")
- if (
- old_value.device == torch.device("meta")
- and target_device not in ["meta", torch.device("meta")]
- and param_value is None
- ):
- raise ValueError(f"{tensor_name} is on the meta device, we need a `value` to put in on {target_device}.")
-
- if pre_quantized:
- if (param_name + ".quant_state.bitsandbytes__fp4" not in state_dict) and (param_name + ".quant_state.bitsandbytes__nf4" not in state_dict):
- raise ValueError(f"Supplied state dict for {param_name} does not contain `bitsandbytes__*` and possibly other `quantized_stats` components.")
- quantized_stats = {}
- for k, v in state_dict.items():
- # `startswith` to counter for edge cases where `param_name`
- # substring can be present in multiple places in the `state_dict`
- if param_name + "." in k and k.startswith(param_name):
- quantized_stats[k] = v
- if unexpected_keys is not None and k in unexpected_keys:
- unexpected_keys.remove(k)
- new_value = bnb.nn.Params4bit.from_prequantized(
- data=param_value,
- quantized_stats=quantized_stats,
- requires_grad=False,
- device=target_device,
- )
- else:
- new_value = param_value.to("cpu")
- kwargs = old_value.__dict__
- new_value = bnb.nn.Params4bit(new_value, requires_grad=False, **kwargs).to(target_device)
- module._parameters[tensor_name] = new_value # pylint: disable=protected-access
-
-
-def load_flux_nf4(checkpoint_info, prequantized: bool = True):
- transformer = None
- text_encoder_2 = None
- if isinstance(checkpoint_info, str):
- repo_path = checkpoint_info
- else:
- repo_path = checkpoint_info.path
- if os.path.exists(repo_path) and os.path.isfile(repo_path):
- ckpt_path = repo_path
- elif os.path.exists(repo_path) and os.path.isdir(repo_path) and os.path.exists(os.path.join(repo_path, "diffusion_pytorch_model.safetensors")):
- ckpt_path = os.path.join(repo_path, "diffusion_pytorch_model.safetensors")
- else:
- ckpt_path = hf_hub_download(repo_path, filename="diffusion_pytorch_model.safetensors", cache_dir=shared.opts.diffusers_dir)
- original_state_dict = safetensors.torch.load_file(ckpt_path)
-
- if 'sayakpaul' in repo_path:
- converted_state_dict = original_state_dict # already converted
- else:
- try:
- converted_state_dict = convert_flux_transformer_checkpoint_to_diffusers(original_state_dict)
- except Exception as e:
- log.error(f"Load model: type=FLUX Failed to convert UNET: {e}")
- if debug:
- from modules import errors
- errors.display(e, 'FLUX convert:')
- converted_state_dict = original_state_dict
-
- with init_empty_weights():
- from diffusers import FluxTransformer2DModel
- config = FluxTransformer2DModel.load_config(os.path.join('configs', 'flux'), subfolder="transformer")
- transformer = FluxTransformer2DModel.from_config(config).to(devices.dtype)
- expected_state_dict_keys = list(transformer.state_dict().keys())
-
- _replace_with_bnb_linear(transformer, "nf4")
-
- try:
- for param_name, param in converted_state_dict.items():
- if param_name not in expected_state_dict_keys:
- continue
- is_param_float8_e4m3fn = hasattr(torch, "float8_e4m3fn") and param.dtype == torch.float8_e4m3fn
- if torch.is_floating_point(param) and not is_param_float8_e4m3fn:
- param = param.to(devices.dtype)
- if not check_quantized_param(transformer, param_name):
- set_module_tensor_to_device(transformer, param_name, device=0, value=param)
- else:
- create_quantized_param(transformer, param, param_name, target_device=0, state_dict=original_state_dict, pre_quantized=prequantized)
- except Exception as e:
- transformer, text_encoder_2 = None, None
- log.error(f"Load model: type=FLUX failed to load UNET: {e}")
- if debug:
- from modules import errors
- errors.display(e, 'FLUX:')
-
- del original_state_dict
- devices.torch_gc(force=True, reason='load')
- return transformer, text_encoder_2
diff --git a/pipelines/flux/flux_quanto.py b/pipelines/flux/flux_quanto.py
deleted file mode 100644
index 74bd07c8e..000000000
--- a/pipelines/flux/flux_quanto.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import os
-import json
-import torch
-import diffusers
-import transformers
-from safetensors.torch import load_file
-from huggingface_hub import hf_hub_download
-from modules import shared, errors, devices, sd_models, model_quant
-from modules.logger import log
-
-
-debug = log.trace if os.environ.get('SD_LOAD_DEBUG', None) is not None else lambda *args, **kwargs: None
-
-
-def load_flux_quanto(checkpoint_info):
- transformer, text_encoder_2 = None, None
- quanto = model_quant.load_quanto('Load model: type=FLUX')
-
- if isinstance(checkpoint_info, str):
- repo_path = checkpoint_info
- else:
- repo_path = checkpoint_info.path
-
- try:
- quantization_map = os.path.join(repo_path, "transformer", "quantization_map.json")
- debug(f'Load model: type=FLUX quantization map="{quantization_map}" repo="{checkpoint_info.name}" component="transformer"')
- if not os.path.exists(quantization_map):
- repo_id = sd_models.path_to_repo(checkpoint_info)
- quantization_map = hf_hub_download(repo_id, subfolder='transformer', filename='quantization_map.json', cache_dir=shared.opts.diffusers_dir)
- with open(quantization_map, "r", encoding='utf8') as f:
- quantization_map = json.load(f)
- state_dict = load_file(os.path.join(repo_path, "transformer", "diffusion_pytorch_model.safetensors"))
- dtype = state_dict['context_embedder.bias'].dtype
- with torch.device("meta"):
- transformer = diffusers.FluxTransformer2DModel.from_config(os.path.join(repo_path, "transformer", "config.json")).to(dtype=dtype)
- quanto.requantize(transformer, state_dict, quantization_map, device=torch.device("cpu"))
- transformer_dtype = transformer.dtype
- if transformer_dtype != devices.dtype:
- try:
- transformer = transformer.to(dtype=devices.dtype)
- except Exception:
- log.error(f"Load model: type=FLUX Failed to cast transformer to {devices.dtype}, set dtype to {transformer_dtype}")
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load Quanto transformer: {e}")
- if debug:
- errors.display(e, 'FLUX Quanto:')
-
- try:
- quantization_map = os.path.join(repo_path, "text_encoder_2", "quantization_map.json")
- debug(f'Load model: type=FLUX quantization map="{quantization_map}" repo="{checkpoint_info.name}" component="text_encoder_2"')
- if not os.path.exists(quantization_map):
- repo_id = sd_models.path_to_repo(checkpoint_info)
- quantization_map = hf_hub_download(repo_id, subfolder='text_encoder_2', filename='quantization_map.json', cache_dir=shared.opts.diffusers_dir)
- with open(quantization_map, "r", encoding='utf8') as f:
- quantization_map = json.load(f)
- with open(os.path.join(repo_path, "text_encoder_2", "config.json"), encoding='utf8') as f:
- t5_config = transformers.T5Config(**json.load(f))
- state_dict = load_file(os.path.join(repo_path, "text_encoder_2", "model.safetensors"))
- dtype = state_dict['encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight'].dtype
- with torch.device("meta"):
- text_encoder_2 = transformers.T5EncoderModel(t5_config).to(dtype=dtype)
- quanto.requantize(text_encoder_2, state_dict, quantization_map, device=torch.device("cpu"))
- text_encoder_2_dtype = text_encoder_2.dtype
- if text_encoder_2_dtype != devices.dtype:
- try:
- text_encoder_2 = text_encoder_2.to(dtype=devices.dtype)
- except Exception:
- log.error(f"Load model: type=FLUX Failed to cast text encoder to {devices.dtype}, set dtype to {text_encoder_2_dtype}")
- except Exception as e:
- log.error(f"Load model: type=FLUX failed to load Quanto text encoder: {e}")
- if debug:
- errors.display(e, 'FLUX Quanto:')
-
- return transformer, text_encoder_2
diff --git a/pipelines/model_flux.py b/pipelines/model_flux.py
index 08a2a2854..23bd40455 100644
--- a/pipelines/model_flux.py
+++ b/pipelines/model_flux.py
@@ -41,18 +41,6 @@ def load_flux(checkpoint_info, diffusers_load_config=None):
transformer = None
text_encoder_2 = None
- # handle prequantized models
- prequantized = model_quant.get_quant(checkpoint_info.path)
- if prequantized == 'nf4':
- from pipelines.flux.flux_nf4 import load_flux_nf4
- transformer, text_encoder_2 = load_flux_nf4(checkpoint_info)
- elif prequantized == 'qint8' or prequantized == 'qint4':
- from pipelines.flux.flux_quanto import load_flux_quanto
- transformer, text_encoder_2 = load_flux_quanto(checkpoint_info)
- elif prequantized == 'fp4' or prequantized == 'fp8':
- from pipelines.flux.flux_bnb import load_flux_bnb
- transformer = load_flux_bnb(checkpoint_info, diffusers_load_config)
-
# handle transformer svdquant if available, t5 is handled inside load_text_encoder
if transformer is None and model_quant.check_nunchaku('Model'):
from pipelines.flux.flux_nunchaku import load_flux_nunchaku
diff --git a/pipelines/model_flux2.py b/pipelines/model_flux2.py
index c2963c316..dd6c364b0 100644
--- a/pipelines/model_flux2.py
+++ b/pipelines/model_flux2.py
@@ -31,6 +31,9 @@ def load_flux2(checkpoint_info, diffusers_load_config=None):
diffusers.pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING["flux2"] = diffusers.Flux2Pipeline
diffusers.pipelines.auto_pipeline.AUTO_INPAINT_PIPELINES_MAPPING["flux2"] = diffusers.Flux2Pipeline
+ from pipelines.flux import flux2_lora
+ flux2_lora.apply_patch()
+
del text_encoder
del transformer
sd_hijack_te.init_hijack(pipe)
diff --git a/pipelines/model_flux2_klein.py b/pipelines/model_flux2_klein.py
index 34ccc1f67..31e539128 100644
--- a/pipelines/model_flux2_klein.py
+++ b/pipelines/model_flux2_klein.py
@@ -34,6 +34,9 @@ def load_flux2_klein(checkpoint_info, diffusers_load_config=None):
diffusers.pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING["flux2klein"] = diffusers.Flux2KleinPipeline
diffusers.pipelines.auto_pipeline.AUTO_INPAINT_PIPELINES_MAPPING["flux2klein"] = diffusers.Flux2KleinPipeline
+ from pipelines.flux import flux2_lora
+ flux2_lora.apply_patch()
+
del text_encoder
del transformer
sd_hijack_te.init_hijack(pipe)
diff --git a/requirements.txt b/requirements.txt
index 67c45ac46..e8ca68aba 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -27,13 +27,13 @@ peft==0.18.1
httpx==0.28.1
requests==2.32.3
tqdm==4.67.3
-accelerate==1.12.0
+accelerate==1.13.0
einops==0.8.1
-huggingface_hub==1.5.0
+huggingface_hub==1.7.2
numpy==2.1.2
pandas==2.3.1
protobuf==6.33.5
-pytorch_lightning==2.6.0
+pytorch_lightning==2.6.1
urllib3==1.26.19
Pillow==10.4.0
timm==1.0.24
diff --git a/scripts/color_grading.py b/scripts/color_grading.py
new file mode 100644
index 000000000..7ef518662
--- /dev/null
+++ b/scripts/color_grading.py
@@ -0,0 +1,15 @@
+from modules import scripts_postprocessing, ui_sections, processing_grading
+
+
+class ScriptPostprocessingColorGrading(scripts_postprocessing.ScriptPostprocessing):
+ name = "Color Grading"
+
+ def ui(self):
+ ui_controls = ui_sections.create_color_inputs('process')
+ ui_controls_dict = {control.label.replace(" ", "_").replace(".", "").lower(): control for control in ui_controls}
+ return ui_controls_dict
+
+ def process(self, pp: scripts_postprocessing.PostprocessedImage, *args, **kwargs): # pylint: disable=arguments-differ
+ grading_params = processing_grading.GradingParams(*args, **kwargs)
+ if processing_grading.is_active(grading_params):
+ pp.image = processing_grading.grade_image(pp.image, grading_params)
diff --git a/scripts/nudenet_ext.py b/scripts/nudenet_ext.py
index be24ea1ed..3a735ba32 100644
--- a/scripts/nudenet_ext.py
+++ b/scripts/nudenet_ext.py
@@ -124,7 +124,7 @@ def process(
# defines script for dual-mode usage
-class Script(scripts.Script):
+class ScriptNudeNet(scripts.Script):
# see below for all available options and callbacks
#
@@ -148,7 +148,7 @@ class Script(scripts.Script):
# defines postprocessing script for dual-mode usage
-class ScriptPostprocessing(scripts_postprocessing.ScriptPostprocessing):
+class ScriptPostprocessingNudeNet(scripts_postprocessing.ScriptPostprocessing):
name = 'NudeNet'
order = 10000
diff --git a/scripts/postprocessing_video.py b/scripts/postprocessing_video.py
index 84836abca..d855be5d5 100644
--- a/scripts/postprocessing_video.py
+++ b/scripts/postprocessing_video.py
@@ -2,8 +2,8 @@ import gradio as gr
from modules import video, scripts_postprocessing
-class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
- name = "Video"
+class ScriptPostprocessingVideo(scripts_postprocessing.ScriptPostprocessing):
+ name = "Create Video"
def ui(self):
with gr.Accordion('Create video', open = False, elem_id="postprocess_video_accordion"):
@@ -18,7 +18,7 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
]
with gr.Row():
- gr.HTML(" Video Create video from generated images {title} {k} {v} Advanced configuration for ROCm users.
Set your database and solver selections based on GPU profile or individually.
Enable cuDNN in Backend Settings to activate MIOpen.
")
+ with gr.Row():
+ btn_info = gr.Button("Refresh Info", variant="primary", elem_id="rocm_btn_info", size="sm")
+ btn_apply = gr.Button("Apply", variant="primary", elem_id="rocm_btn_apply", size="sm")
+ btn_reset = gr.Button("Defaults", elem_id="rocm_btn_reset", size="sm")
+ btn_clear = gr.Button("Clear Run Vars", elem_id="rocm_btn_clear", size="sm")
+ btn_delete = gr.Button("Delete UserDb", variant="stop", elem_id="rocm_btn_delete", size="sm")
+ with gr.Row():
+ btn_rdna2 = gr.Button("RDNA2 (RX 6000)", elem_id="rocm_btn_rdna2")
+ btn_rdna3 = gr.Button("RDNA3 (RX 7000)", elem_id="rocm_btn_rdna3")
+ btn_rdna4 = gr.Button("RDNA4 (RX 9000)", elem_id="rocm_btn_rdna4")
+ style_out = gr.HTML("")
+ info_out = gr.HTML(value=_info_html, elem_id="rocm_info_table")
+
+ # General vars (dropdowns, textboxes, checkboxes)
+ with gr.Group():
+ gr.HTML("MIOpen Settings {group_name} ');
+ process.exit(1);
+}
+
+try {
+ // Read input file
+ const rawData = fs.readFileSync(inputFile, 'utf8');
+ const jsonData = JSON.parse(rawData);
+
+ // Reformat with mixed depth
+ const result = mixedStringify(jsonData, parseInt(maxDepth, 10));
+
+ // Write output file
+ fs.writeFileSync(outputFile, result);
+ console.log(`Success! File saved to ${outputFile} (levels expanded: ${maxDepth})`);
+} catch (err) {
+ console.error('Error processing JSON:', err.message);
+}
diff --git a/test/test-grading.py b/test/test-grading.py
index 2018519c6..0334faba6 100644
--- a/test/test-grading.py
+++ b/test/test-grading.py
@@ -95,7 +95,7 @@ def test_grading_params_defaults():
assert p.split_tone_balance == 0.5
assert p.vignette == 0.0
assert p.grain == 0.0
- assert p.lut_file == ""
+ assert p.lut_cube_file == ""
assert p.lut_strength == 1.0
return True
diff --git a/wiki b/wiki
index 33dbd026a..99f4e13d0 160000
--- a/wiki
+++ b/wiki
@@ -1 +1 @@
-Subproject commit 33dbd026a2e2fb7311d545a3b2d2db0363bb887f
+Subproject commit 99f4e13d03191b5269b869c71283d7fcf9c98f60
+
+
+