Upload folder using huggingface_hub (part 3)

.gitattributes

@@ -36,3 +36,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 SECourses_Musubi_Trainer/musubi-tuner/docs/kisekaeichi_ref.png filter=lfs diff=lfs merge=lfs -text
 SECourses_Musubi_Trainer/musubi-tuner/docs/kisekaeichi_result.png filter=lfs diff=lfs merge=lfs -text
 SECourses_Musubi_Trainer/musubi-tuner/docs/kisekaeichi_start.png filter=lfs diff=lfs merge=lfs -text
+SECourses_Musubi_Trainer/venv/bin/python filter=lfs diff=lfs merge=lfs -text
+SECourses_Musubi_Trainer/venv/bin/python3 filter=lfs diff=lfs merge=lfs -text
+SECourses_Musubi_Trainer/venv/bin/python3.10 filter=lfs diff=lfs merge=lfs -text
+gradio/frpc/frpc_linux_amd64_v0.3 filter=lfs diff=lfs merge=lfs -text
+venv/bin/python filter=lfs diff=lfs merge=lfs -text
+venv/bin/python3 filter=lfs diff=lfs merge=lfs -text
+venv/bin/python3.11 filter=lfs diff=lfs merge=lfs -text
+venv/bin/uv filter=lfs diff=lfs merge=lfs -text
+venv/bin/uvx filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/_imaging.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/_imagingcms.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/_imagingft.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/_imagingmath.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/_webp.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/_brotli.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

SECourses_Musubi_Trainer/musubi_tuner_gui/zimage_lora_gui.py

@@ -0,0 +1,2219 @@
+import os
+import re
+import shlex
+import shutil
+import sys
+import time
+from datetime import datetime
+
+import gradio as gr
+import toml
+
+from .class_accelerate_launch import AccelerateLaunch
+from .class_advanced_training import AdvancedTraining
+from .class_command_executor import CommandExecutor
+from .class_configuration_file import ConfigurationFile
+from .class_gui_config import GUIConfig
+from .class_huggingface import HuggingFace
+from .class_metadata import MetaData
+from .class_network import Network
+from .class_optimizer_and_scheduler import OptimizerAndScheduler
+from .class_save_load import SaveLoadSettings
+from .class_training import TrainingSettings
+from .full_finetune_gui import normalize_image_training_parameters, training_mode_runtime_exclusions
+from .common_gui import (
+    SaveConfigFile,
+    SaveConfigFileToRun,
+    generate_script_content,
+    get_file_path,
+    get_file_path_or_save_as,
+    get_folder_path,
+    print_command_and_toml,
+    resolve_portable_model_value,
+    run_cmd_advanced_training,
+    save_executed_script,
+    save_training_preview_config,
+    scriptdir,
+    requires_native_compile_toolchain,
+    setup_environment,
+    validate_block_swap_options,
+)
+from .custom_logging import setup_logging
+from .dataset_config_generator import generate_dataset_config_from_folders, save_dataset_config, validate_dataset_config
+
+log = setup_logging()
+
+executor = None
+train_state_value = time.time()
+
+
+def _find_accelerate_launch(python_cmd: str) -> list[str]:
+    python_dir = os.path.dirname(python_cmd)
+    accelerate_fallback = os.path.join(python_dir, "accelerate.exe" if sys.platform == "win32" else "accelerate")
+    if os.path.exists(accelerate_fallback) and os.access(accelerate_fallback, os.X_OK):
+        return [rf"{accelerate_fallback}", "launch"]
+
+    accelerate_path = shutil.which("accelerate")
+    if accelerate_path:
+        return [rf"{accelerate_path}", "launch"]
+
+    log.warning("Accelerate binary not found, using Python module fallback")
+    return [python_cmd, "-m", "accelerate.commands.launch"]
+
+
+def _get_debug_parameters_for_mode(debug_mode: str) -> str:
+    debug_params = {
+        "Show Timesteps (Image)": "--show_timesteps image",
+        "Show Timesteps (Console)": "--show_timesteps console",
+        "RCM Debug Save": "--rcm_debug_save",
+        "Enable Logging (TensorBoard)": "--log_with tensorboard",
+        "Enable Logging (WandB)": "--log_with wandb",
+        "Enable Logging (All)": "--log_with all",
+    }
+    return debug_params.get(debug_mode, "")
+
+
+def _generate_zimage_dataset_toml(
+    parent_folder_path: str,
+    dataset_resolution_width: int,
+    dataset_resolution_height: int,
+    dataset_caption_extension: str,
+    create_missing_captions: bool,
+    caption_strategy: str,
+    dataset_batch_size: int,
+    dataset_enable_bucket: bool,
+    dataset_bucket_no_upscale: bool,
+    dataset_cache_directory: str,
+    output_dir: str,
+):
+    try:
+        parent_folder_path = (parent_folder_path or "").strip()
+        if not parent_folder_path:
+            raise ValueError("Parent folder path is required.")
+        if not os.path.isdir(parent_folder_path):
+            raise ValueError(f"Parent folder does not exist: {parent_folder_path}")
+
+        save_dir = (output_dir or "").strip() or parent_folder_path
+        os.makedirs(save_dir, exist_ok=True)
+
+        cfg, msgs = generate_dataset_config_from_folders(
+            parent_folder=parent_folder_path,
+            resolution=(int(dataset_resolution_width), int(dataset_resolution_height)),
+            caption_extension=(dataset_caption_extension or ".txt"),
+            create_missing_captions=bool(create_missing_captions),
+            caption_strategy=caption_strategy or "folder_name",
+            batch_size=int(dataset_batch_size),
+            enable_bucket=bool(dataset_enable_bucket),
+            bucket_no_upscale=bool(dataset_bucket_no_upscale),
+            cache_directory_name=dataset_cache_directory or "cache_dir",
+            # Z-Image does not support control images; avoid adding control_directory entries.
+            control_directory_name="__zimage_no_control__",
+        )
+
+        ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+        out_path = os.path.join(save_dir, f"zimage_dataset_{ts}.toml")
+        save_dataset_config(cfg, out_path)
+
+        is_valid, v_msgs = validate_dataset_config(out_path)
+        status_lines = []
+        status_lines.extend(msgs)
+        status_lines.extend(v_msgs)
+        if not is_valid:
+            status_lines.append("[ERROR] Dataset TOML validation failed. Please review warnings/errors above.")
+        else:
+            status_lines.append(f"[OK] Saved dataset TOML: {out_path}")
+
+        return out_path, out_path, "\n".join(status_lines)
+    except Exception as e:
+        err = f"[ERROR] Failed to generate dataset TOML: {e}"
+        log.error(err)
+        return "", "", err
+
+
+def save_zimage_configuration(save_as_bool, file_path, parameters):
+    original_file_path = file_path
+
+    if save_as_bool or not file_path:
+        file_path = get_file_path_or_save_as(file_path, default_extension=".toml", extension_name="TOML files")
+
+    if not file_path:
+        return original_file_path, gr.update(value="No file selected.", visible=True)
+
+    try:
+        SaveConfigFile(
+            parameters=parameters,
+            file_path=file_path,
+            exclusion=["file_path", "save_as", "save_as_bool", "headless", "print_only"],
+        )
+        msg = f"Configuration saved: {os.path.basename(file_path)}"
+        gr.Info(msg)
+        return file_path, gr.update(value=msg, visible=True)
+    except Exception as e:
+        msg = f"Failed to save configuration: {e}"
+        log.error(msg)
+        gr.Error(msg)
+        return original_file_path, gr.update(value=msg, visible=True)
+
+
+def open_zimage_configuration(ask_for_file, file_path, parameters):
+    original_file_path = file_path
+
+    if ask_for_file:
+        file_path = get_file_path_or_save_as(file_path, default_extension=".toml", extension_name="TOML files")
+
+    if not file_path:
+        values = [original_file_path, gr.update(value="", visible=False)]
+        values.extend([v for _, v in parameters])
+        return tuple(values)
+
+    if ask_for_file and not os.path.isfile(file_path):
+        msg = f"New configuration file will be created at: {os.path.basename(file_path)}"
+        gr.Info(msg)
+        values = [file_path, gr.update(value=msg, visible=True)]
+        values.extend([v for _, v in parameters])
+        return tuple(values)
+
+    if not os.path.isfile(file_path):
+        msg = f"Config file does not exist: {file_path}"
+        gr.Error(msg)
+        values = [original_file_path, gr.update(value=msg, visible=True)]
+        values.extend([v for _, v in parameters])
+        return tuple(values)
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = toml.load(f)
+    except Exception as e:
+        msg = f"Failed to load configuration: {e}"
+        log.error(msg)
+        gr.Error(msg)
+        values = [original_file_path, gr.update(value=msg, visible=True)]
+        values.extend([v for _, v in parameters])
+        return tuple(values)
+
+    numeric_fields = {
+        "dataset_resolution_width",
+        "dataset_resolution_height",
+        "dataset_batch_size",
+        "num_cpu_threads_per_process",
+        "num_processes",
+        "num_machines",
+        "main_process_port",
+        "blocks_to_swap",
+        "max_train_steps",
+        "max_train_epochs",
+        "max_data_loader_n_workers",
+        "seed",
+        "gradient_accumulation_steps",
+        "discrete_flow_shift",
+        "sigmoid_scale",
+        "min_timestep",
+        "max_timestep",
+        "learning_rate",
+        "max_grad_norm",
+        "lr_warmup_steps",
+        "lr_decay_steps",
+        "lr_scheduler_num_cycles",
+        "lr_scheduler_power",
+        "lr_scheduler_timescale",
+        "lr_scheduler_min_lr_ratio",
+        "network_dim",
+        "network_alpha",
+        "network_dropout",
+        "scale_weight_norms",
+        "sample_every_n_steps",
+        "sample_every_n_epochs",
+        "sample_width",
+        "sample_height",
+        "sample_steps",
+        "sample_guidance_scale",
+        "sample_seed",
+        "sample_cfg_scale",
+        "save_every_n_epochs",
+        "save_every_n_steps",
+        "save_last_n_epochs",
+        "save_last_n_steps",
+        "save_last_n_epochs_state",
+        "save_last_n_steps_state",
+        "ddp_timeout",
+        "compile_cache_size_limit",
+        "caching_latent_batch_size",
+        "caching_latent_num_workers",
+        "caching_teo_batch_size",
+        "caching_teo_num_workers",
+        "training_adapter_multiplier",
+    }
+
+    list_to_str_fields = {"optimizer_args", "lr_scheduler_args", "network_args", "base_weights", "base_weights_multiplier"}
+
+    def _quote_if_needed(s: str) -> str:
+        s = str(s)
+        if not s:
+            return s
+        if any(ch.isspace() for ch in s):
+            return f"\"{s}\""
+        return s
+
+    loaded_values = []
+    for key, default_value in parameters:
+        if key in data:
+            v = resolve_portable_model_value(key, data[key])
+            if isinstance(v, list) and key in numeric_fields:
+                v = v[0] if v else None
+            elif isinstance(v, list) and key in list_to_str_fields:
+                if key == "base_weights":
+                    v = " ".join(_quote_if_needed(str(x)) for x in v)
+                else:
+                    v = " ".join(str(x) for x in v)
+            loaded_values.append(v)
+        else:
+            loaded_values.append(resolve_portable_model_value(key, default_value))
+
+    msg = f"Loaded configuration: {os.path.basename(file_path)}"
+    gr.Info(msg)
+    return tuple([file_path, gr.update(value=msg, visible=True)] + loaded_values)
+
+
+def _maybe_create_enhanced_sample_prompts_zimage(param_dict: dict, parameters: list[tuple[str, object]]) -> tuple[dict, list[tuple[str, object]]]:
+    sample_prompts = (param_dict.get("sample_prompts") or "").strip()
+    if not sample_prompts or not sample_prompts.lower().endswith(".txt"):
+        return param_dict, parameters
+    if not os.path.isfile(sample_prompts):
+        return param_dict, parameters
+    if bool(param_dict.get("disable_prompt_enhancement", False)):
+        log.info("Z-Image prompt enhancement disabled; using original sample prompt file.")
+        return param_dict, parameters
+
+    output_dir = (param_dict.get("output_dir") or "").strip()
+    if not output_dir:
+        return param_dict, parameters
+
+    sample_out_dir = (param_dict.get("sample_output_dir") or "").strip() or output_dir
+    os.makedirs(sample_out_dir, exist_ok=True)
+
+    width = int(param_dict.get("sample_width") or 1024)
+    height = int(param_dict.get("sample_height") or 1024)
+    steps = int(param_dict.get("sample_steps") or 25)
+    seed = param_dict.get("sample_seed", None)
+    neg = (param_dict.get("sample_negative_prompt") or "").strip()
+    cfg_scale = float(param_dict.get("sample_cfg_scale") or 4.0)
+
+    def has_flag(s: str, flag: str) -> bool:
+        return re.search(rf"(?<!\S)--{re.escape(flag)}(?:\s+|=)", s, flags=re.IGNORECASE) is not None
+    def get_flag_value(s: str, flag: str):
+        m = re.search(rf"(?<!\S)--{re.escape(flag)}(?:\s+|=)([^\s]+)", s, flags=re.IGNORECASE)
+        return m.group(1) if m else None
+
+    enhanced_lines = []
+    with open(sample_prompts, "r", encoding="utf-8") as f:
+        for raw in f.readlines():
+            line = raw.rstrip("\n")
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                enhanced_lines.append(line)
+                continue
+
+            s = stripped
+            # Normalize common short/equals forms to canonical Kohya-style options that musubi parses.
+            s = re.sub(r"(?<!\S)-(?P<flag>fs|w|h|s|d|l|n|g)(?=\s|=)", r"--\g<flag>", s, flags=re.IGNORECASE)
+            s = re.sub(r"(?<!\S)--(?P<flag>fs|w|h|s|d|l|n|g)=(?P<value>[^\s]+)", r"--\g<flag> \g<value>", s, flags=re.IGNORECASE)
+            if not has_flag(s, "w"):
+                s += f" --w {width}"
+            if not has_flag(s, "h"):
+                s += f" --h {height}"
+            if not has_flag(s, "s"):
+                s += f" --s {steps}"
+            if seed is not None and int(seed) >= 0 and not has_flag(s, "d"):
+                s += f" --d {int(seed)}"
+
+            # Z-Image training samples are controlled by cfg_scale (`--l`).
+            # Mirror legacy `--g` into `--l` when `--l` is missing.
+            has_cfg_scale = has_flag(s, "l")
+            has_guidance = has_flag(s, "g")
+            if has_guidance and not has_cfg_scale:
+                g_val = get_flag_value(s, "g")
+                if g_val is not None:
+                    s += f" --l {g_val}"
+                    has_cfg_scale = True
+
+            if not has_cfg_scale:
+                s += f" --l {cfg_scale}"
+            if neg and not has_flag(s, "n"):
+                s += f" --n {neg}"
+
+            enhanced_lines.append(s)
+
+    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+    out_name = (param_dict.get("output_name") or "zimage").strip() or "zimage"
+    enhanced_path = os.path.join(sample_out_dir, f"{out_name}_enhanced_prompts_{ts}.txt")
+    with open(enhanced_path, "w", encoding="utf-8") as f:
+        f.write("# Enhanced prompt file generated by SECourses Musubi Trainer\n")
+        f.write(f"# Original file: {sample_prompts}\n\n")
+        for l in enhanced_lines:
+            f.write(l + "\n")
+
+    param_dict["sample_prompts"] = enhanced_path
+    parameters = [(k, (enhanced_path if k == "sample_prompts" else v)) for k, v in parameters]
+    return param_dict, parameters
+
+
+def train_zimage_model(headless: bool, print_only: bool, parameters):
+    global train_state_value
+
+    python_cmd = sys.executable
+    run_cmd = _find_accelerate_launch(python_cmd)
+
+    param_dict, parameters, full_finetune = normalize_image_training_parameters(parameters)
+
+    def _strip_matching_quotes(s: str) -> str:
+        if len(s) >= 2 and ((s[0] == s[-1] == '"') or (s[0] == s[-1] == "'")):
+            return s[1:-1]
+        return s
+
+    def _split_cli_args_windows(value: str) -> list[str]:
+        if not value or not value.strip():
+            return []
+        try:
+            parts = shlex.split(value, posix=False)
+        except Exception:
+            parts = value.replace(",", " ").split()
+        cleaned: list[str] = []
+        for p in parts:
+            p = _strip_matching_quotes(p.strip().strip(",").strip())
+            if p:
+                cleaned.append(p)
+        return cleaned
+
+    def _coerce_str_list(value: object) -> list[str]:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            return [str(v) for v in value if v is not None and str(v).strip()]
+        if isinstance(value, str):
+            return _split_cli_args_windows(value)
+        return [str(value)]
+
+    def _coerce_float_list(value: object) -> list[float]:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            out: list[float] = []
+            for v in value:
+                if v is None:
+                    continue
+                try:
+                    out.append(float(v))
+                except Exception:
+                    continue
+            return out
+        if isinstance(value, (int, float)):
+            return [float(value)]
+        if isinstance(value, str):
+            out: list[float] = []
+            for tok in _split_cli_args_windows(value):
+                try:
+                    out.append(float(tok))
+                except Exception:
+                    continue
+            return out
+        return []
+
+    training_mode = (param_dict.get("training_mode") or "LoRA Training").strip()
+    validate_block_swap_options(param_dict, lora_training=not full_finetune)
+
+    # Prefer generated dataset config when using folder mode.
+    dataset_config_mode = (param_dict.get("dataset_config_mode") or "").strip()
+    if dataset_config_mode == "Generate from Folder Structure":
+        gen_path = (param_dict.get("generated_toml_path") or "").strip()
+        if gen_path:
+            param_dict["dataset_config"] = gen_path
+            parameters = [(k, (gen_path if k == "dataset_config" else v)) for k, v in parameters]
+
+    dataset_config = (param_dict.get("dataset_config") or "").strip()
+    if not dataset_config:
+        raise ValueError("[ERROR] Dataset config is required. Generate a dataset TOML or set dataset_config.")
+    if not os.path.exists(dataset_config):
+        raise ValueError(f"[ERROR] Dataset config file does not exist: {dataset_config}")
+
+    dit_path = (param_dict.get("dit") or "").strip()
+    vae_path = (param_dict.get("vae") or "").strip()
+    te_path = (param_dict.get("text_encoder") or "").strip()
+
+    if not dit_path or not os.path.exists(dit_path):
+        raise ValueError("[ERROR] DiT checkpoint path is required and must exist.")
+    if not vae_path or not os.path.exists(vae_path):
+        raise ValueError("[ERROR] VAE checkpoint path is required and must exist.")
+    if not te_path or not os.path.exists(te_path):
+        raise ValueError("[ERROR] Text Encoder checkpoint path is required and must exist.")
+
+    output_dir = (param_dict.get("output_dir") or "").strip()
+    output_name = (param_dict.get("output_name") or "").strip()
+    if not output_dir:
+        raise ValueError("[ERROR] Output directory is required.")
+    if not output_name:
+        raise ValueError("[ERROR] Output name is required.")
+
+    # Z-Image Turbo training adapter / LoRA adapter support:
+    # - Use the GUI field to populate base_weights (+ multiplier) so musubi-tuner receives --base_weights correctly.
+    # - Also normalize any user-entered base_weights/base_weights_multiplier to lists (argparse expects nargs='*').
+    base_weights_list = _coerce_str_list(param_dict.get("base_weights"))
+    base_weights_multiplier_list = _coerce_float_list(param_dict.get("base_weights_multiplier"))
+
+    training_adapter_path = (param_dict.get("training_adapter_path") or "").strip()
+    training_adapter_multiplier = float(param_dict.get("training_adapter_multiplier") or 1.0)
+    if training_adapter_path:
+        if not os.path.exists(training_adapter_path):
+            raise ValueError(f"[ERROR] Training adapter path does not exist: {training_adapter_path}")
+        if training_adapter_path not in base_weights_list:
+            base_weights_list.append(training_adapter_path)
+        adapter_idx = base_weights_list.index(training_adapter_path)
+        if len(base_weights_multiplier_list) <= adapter_idx:
+            base_weights_multiplier_list.extend([1.0] * (adapter_idx + 1 - len(base_weights_multiplier_list)))
+        base_weights_multiplier_list[adapter_idx] = training_adapter_multiplier
+
+    # Update parameter list with normalized values (lists), so config TOML is compatible with nargs='*'.
+    if base_weights_list:
+        param_dict["base_weights"] = base_weights_list
+        parameters = [(k, (base_weights_list if k == "base_weights" else v)) for k, v in parameters]
+    else:
+        param_dict["base_weights"] = None
+        parameters = [(k, (None if k == "base_weights" else v)) for k, v in parameters]
+
+    if base_weights_multiplier_list:
+        param_dict["base_weights_multiplier"] = base_weights_multiplier_list
+        parameters = [(k, (base_weights_multiplier_list if k == "base_weights_multiplier" else v)) for k, v in parameters]
+    else:
+        param_dict["base_weights_multiplier"] = None
+        parameters = [(k, (None if k == "base_weights_multiplier" else v)) for k, v in parameters]
+
+    # Enforce correct LoRA module for LoRA training only.
+    if not full_finetune:
+        required_network_module = "networks.lora_zimage"
+        if (param_dict.get("network_module") or "").strip() != required_network_module:
+            param_dict["network_module"] = required_network_module
+            parameters = [(k, (required_network_module if k == "network_module" else v)) for k, v in parameters]
+
+    # Optional pre-steps
+    latent_cache_cmd = None
+    teo_cache_cmd = None
+
+    # Match WAN tab behavior: run caching unless explicitly disabled.
+    if param_dict.get("caching_latent_skip_existing") is not False:
+        latent_cache_cmd = [
+            python_cmd,
+            f"{scriptdir}/musubi-tuner/src/musubi_tuner/zimage_cache_latents.py",
+            "--dataset_config",
+            dataset_config,
+            "--vae",
+            vae_path,
+        ]
+
+        caching_device = (param_dict.get("caching_latent_device") or "cuda").strip()
+        if caching_device == "cuda":
+            if (param_dict.get("gpu_ids") or "").strip():
+                gpu_ids = str(param_dict.get("gpu_ids")).split(",")
+                caching_device = f"cuda:{gpu_ids[0].strip()}"
+            else:
+                caching_device = "cuda:0"
+        latent_cache_cmd.extend(["--device", caching_device])
+
+        if param_dict.get("caching_latent_batch_size") is not None:
+            latent_cache_cmd.extend(["--batch_size", str(int(param_dict.get("caching_latent_batch_size")))])
+        if param_dict.get("caching_latent_num_workers") is not None:
+            latent_cache_cmd.extend(["--num_workers", str(int(param_dict.get("caching_latent_num_workers")))])
+
+        if bool(param_dict.get("caching_latent_skip_existing")):
+            latent_cache_cmd.append("--skip_existing")
+        if bool(param_dict.get("caching_latent_keep_cache", False)):
+            latent_cache_cmd.append("--keep_cache")
+
+    if param_dict.get("caching_teo_skip_existing") is not False:
+        teo_cache_cmd = [
+            python_cmd,
+            f"{scriptdir}/musubi-tuner/src/musubi_tuner/zimage_cache_text_encoder_outputs.py",
+            "--dataset_config",
+            dataset_config,
+            "--text_encoder",
+            te_path,
+        ]
+
+        if bool(param_dict.get("caching_teo_fp8_llm", False)):
+            teo_cache_cmd.append("--fp8_llm")
+
+        teo_device = (param_dict.get("caching_teo_device") or "cuda").strip()
+        if teo_device == "cuda":
+            if (param_dict.get("gpu_ids") or "").strip():
+                gpu_ids = str(param_dict.get("gpu_ids")).split(",")
+                teo_device = f"cuda:{gpu_ids[0].strip()}"
+            else:
+                teo_device = "cuda:0"
+        teo_cache_cmd.extend(["--device", teo_device])
+
+        if param_dict.get("caching_teo_batch_size") is not None:
+            teo_cache_cmd.extend(["--batch_size", str(int(param_dict.get("caching_teo_batch_size")))])
+        if param_dict.get("caching_teo_num_workers") is not None:
+            teo_cache_cmd.extend(["--num_workers", str(int(param_dict.get("caching_teo_num_workers")))])
+
+        if bool(param_dict.get("caching_teo_skip_existing")):
+            teo_cache_cmd.append("--skip_existing")
+        if bool(param_dict.get("caching_teo_keep_cache", False)):
+            teo_cache_cmd.append("--keep_cache")
+
+    # Accelerate launch flags
+    run_cmd = AccelerateLaunch.run_cmd(
+        run_cmd=run_cmd,
+        dynamo_backend=param_dict.get("dynamo_backend"),
+        dynamo_mode=param_dict.get("dynamo_mode"),
+        dynamo_use_fullgraph=param_dict.get("dynamo_use_fullgraph"),
+        dynamo_use_dynamic=param_dict.get("dynamo_use_dynamic"),
+        num_processes=param_dict.get("num_processes"),
+        num_machines=param_dict.get("num_machines"),
+        multi_gpu=param_dict.get("multi_gpu"),
+        gpu_ids=param_dict.get("gpu_ids"),
+        main_process_port=param_dict.get("main_process_port"),
+        num_cpu_threads_per_process=param_dict.get("num_cpu_threads_per_process"),
+        mixed_precision=param_dict.get("mixed_precision"),
+        extra_accelerate_launch_args=param_dict.get("extra_accelerate_launch_args"),
+    )
+
+    if full_finetune:
+        run_cmd.append(f"{scriptdir}/musubi-tuner/src/musubi_tuner/zimage_train.py")
+    else:
+        run_cmd.append(f"{scriptdir}/musubi-tuner/src/musubi_tuner/zimage_train_network.py")
+
+    if not print_only:
+        os.makedirs(output_dir, exist_ok=True)
+    formatted_datetime = datetime.now().strftime("%Y%m%d-%H%M%S")
+    cfg_path = os.path.join(output_dir, f"{output_name}_{formatted_datetime}.toml")
+
+    # Enhance prompt file defaults if user provided sample_prompts.
+    param_dict, parameters = _maybe_create_enhanced_sample_prompts_zimage(param_dict, parameters)
+
+    pattern_exclusion = [k for k, _ in parameters if k.startswith("caching_latent_") or k.startswith("caching_teo_")]
+
+    dreambooth_mode = full_finetune
+    exclusion_extra = []
+    if dreambooth_mode:
+        exclusion_extra.extend(
+            [
+                "network_module",
+                "network_dim",
+                "network_alpha",
+                "network_dropout",
+                "network_args",
+                "network_weights",
+                "training_comment",
+                "dim_from_weights",
+                "scale_weight_norms",
+                "base_weights",
+                "base_weights_multiplier",
+                "no_metadata",
+            ]
+        )
+    else:
+        # These options are implemented by zimage_train.py, not the LoRA trainer.
+        exclusion_extra.extend(["mem_eff_save", "fused_backward_pass"])
+
+    run_config_exclusion = [
+            "file_path",
+            "save_as",
+            "save_as_bool",
+            "headless",
+            "print_only",
+            "num_cpu_threads_per_process",
+            "num_processes",
+            "num_machines",
+            "multi_gpu",
+            "gpu_ids",
+            "main_process_port",
+            "dynamo_backend",
+            "dynamo_mode",
+            "dynamo_use_fullgraph",
+            "dynamo_use_dynamic",
+            "extra_accelerate_launch_args",
+            # GUI-only dataset generation fields
+            "dataset_config_mode",
+            "parent_folder_path",
+            "dataset_resolution_width",
+            "dataset_resolution_height",
+            "dataset_caption_extension",
+            "create_missing_captions",
+            "caption_strategy",
+            "dataset_batch_size",
+            "dataset_enable_bucket",
+            "dataset_bucket_no_upscale",
+            "dataset_cache_directory",
+            "generated_toml_path",
+            # GUI-only variant selector and prompt helper
+            "zimage_variant",
+            "sample_cfg_scale",
+            "disable_prompt_enhancement",
+            "sample_output_dir",
+            "sample_width",
+            "sample_height",
+            "sample_steps",
+            "sample_guidance_scale",
+            "sample_seed",
+            "sample_negative_prompt",
+            "training_mode",
+            "training_adapter_path",
+            "training_adapter_multiplier",
+            "additional_parameters",
+            "debug_mode",
+            # Cache-only toggle
+            "caching_teo_fp8_llm",
+        ] + pattern_exclusion + exclusion_extra + list(training_mode_runtime_exclusions(training_mode))
+    mandatory_keys = ["dataset_config", "dit", "vae", "text_encoder"] + (
+        [] if dreambooth_mode else ["network_module"]
+    )
+    if print_only:
+        cfg_path = save_training_preview_config(
+            parameters,
+            f"zimage_{output_name}",
+            run_config_exclusion,
+            mandatory_keys,
+        )
+    else:
+        SaveConfigFileToRun(
+            parameters=parameters,
+            file_path=cfg_path,
+            exclusion=run_config_exclusion,
+            mandatory_keys=mandatory_keys,
+        )
+
+    run_cmd.append("--config_file")
+    run_cmd.append(cfg_path)
+
+    additional_params = (param_dict.get("additional_parameters") or "").strip()
+    debug_mode_selected = (param_dict.get("debug_mode") or "None").strip()
+    if debug_mode_selected and debug_mode_selected != "None":
+        debug_params = _get_debug_parameters_for_mode(debug_mode_selected)
+        if debug_params:
+            additional_params = (additional_params + " " + debug_params).strip() if additional_params else debug_params
+
+    run_cmd = run_cmd_advanced_training(run_cmd=run_cmd, additional_parameters=additional_params)
+
+    if print_only:
+        if latent_cache_cmd:
+            print_command_and_toml(latent_cache_cmd, "")
+        if teo_cache_cmd:
+            print_command_and_toml(teo_cache_cmd, "")
+        print_command_and_toml(run_cmd, cfg_path)
+        return
+
+    # Match Qwen/WAN launch strategy:
+    # 1) run latent caching synchronously (so failures surface before training),
+    # 2) then run (optional) text-encoder caching + training via a wrapper script so Stop cancels both.
+    env = setup_environment(compile_requested=requires_native_compile_toolchain(param_dict))
+
+    if latent_cache_cmd:
+        log.info("Running latent caching...")
+        latent_cache_script = generate_script_content(latent_cache_cmd, "Z-Image latent caching")
+        save_executed_script(script_content=latent_cache_script, config_name=output_name, script_type="zimage_latent_cache")
+        try:
+            gr.Info("Starting latent caching... This may take a while.")
+            import subprocess
+
+            subprocess.run(latent_cache_cmd, env=setup_environment(), check=True)
+            gr.Info("Latent caching completed successfully!")
+        except subprocess.CalledProcessError as e:
+            log.error(f"Latent caching failed with return code {e.returncode}")
+            gr.Warning(f"Latent caching failed with return code {e.returncode}")
+            raise RuntimeError(f"Latent caching failed with return code {e.returncode}")
+        except FileNotFoundError:
+            raise RuntimeError(f"Python executable not found: {python_cmd}")
+
+    if teo_cache_cmd:
+        import platform
+        import tempfile
+        import subprocess
+
+        if platform.system() == "Windows":
+            script_ext = ".bat"
+            teo_cache_cmd_str = " ".join([f"\"{arg}\"" if " " in str(arg) else str(arg) for arg in teo_cache_cmd])
+            run_cmd_str = " ".join([f"\"{arg}\"" if " " in str(arg) else str(arg) for arg in run_cmd])
+            script_content = f"""@echo off
+echo Starting text encoder output caching...
+{teo_cache_cmd_str}
+if %errorlevel% neq 0 (
+    echo Text encoder output caching failed with error code %errorlevel%
+    exit /b %errorlevel%
+)
+echo Text encoder output caching completed successfully.
+echo Starting training...
+{run_cmd_str}
+"""
+        else:
+            script_ext = ".sh"
+            teo_cache_cmd_str = shlex.join(teo_cache_cmd)
+            run_cmd_str = shlex.join(run_cmd)
+            script_content = f"""#!/bin/bash
+set -e
+echo "Starting text encoder output caching..."
+{teo_cache_cmd_str}
+echo "Text encoder output caching completed successfully."
+echo "Starting training..."
+{run_cmd_str}
+"""
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=script_ext, delete=False, encoding="utf-8") as f:
+            temp_script = f.name
+            f.write(script_content)
+
+        if platform.system() != "Windows":
+            import stat
+
+            os.chmod(temp_script, os.stat(temp_script).st_mode | stat.S_IEXEC)
+
+        save_executed_script(script_content=script_content, config_name=output_name, script_type="zimage")
+        final_cmd = [temp_script] if platform.system() == "Windows" else ["bash", temp_script]
+        gr.Info("Starting text encoder caching followed by training...")
+        executor.execute_command(run_cmd=final_cmd, env=env, shell=True if platform.system() == "Windows" else False)
+    else:
+        training_script = generate_script_content(run_cmd, "Z-Image training")
+        save_executed_script(script_content=training_script, config_name=output_name, script_type="zimage")
+        gr.Info("Starting training...")
+        executor.execute_command(run_cmd=run_cmd, env=env)
+
+    train_state_value = time.time()
+    return (
+        gr.Button(visible=False or headless),
+        gr.Row(visible=True),
+        gr.Button(interactive=True),
+        gr.Textbox(value="Training in progress..."),
+        gr.Textbox(value=train_state_value),
+    )
+
+
+ZIMAGE_PARAM_KEYS = [
+    # accelerate_launch
+    "mixed_precision",
+    "num_cpu_threads_per_process",
+    "num_processes",
+    "num_machines",
+    "multi_gpu",
+    "gpu_ids",
+    "main_process_port",
+    "dynamo_backend",
+    "dynamo_mode",
+    "dynamo_use_fullgraph",
+    "dynamo_use_dynamic",
+    "extra_accelerate_launch_args",
+    # advanced_training
+    "additional_parameters",
+    "debug_mode",
+    # dataset
+    "dataset_config_mode",
+    "dataset_config",
+    "parent_folder_path",
+    "dataset_resolution_width",
+    "dataset_resolution_height",
+    "dataset_caption_extension",
+    "create_missing_captions",
+    "caption_strategy",
+    "dataset_batch_size",
+    "dataset_enable_bucket",
+    "dataset_bucket_no_upscale",
+    "dataset_cache_directory",
+    "generated_toml_path",
+    # gui-only model selector
+    "training_mode",
+    "zimage_variant",
+    "training_adapter_path",
+    "training_adapter_multiplier",
+    # model
+    "dit",
+    "vae",
+    "text_encoder",
+    "fp8_base",
+    "fp8_scaled",
+    "fp8_llm",
+    "disable_numpy_memmap",
+    "blocks_to_swap",
+    "use_pinned_memory_for_block_swap",
+    "block_swap_h2d_only",
+    "block_swap_ring_size",
+    "img_in_txt_in_offloading",
+    # torch compile
+    "compile",
+    "compile_backend",
+    "compile_mode",
+    "compile_dynamic",
+    "compile_fullgraph",
+    "compile_cache_size_limit",
+    # schedule
+    "timestep_sampling",
+    "weighting_scheme",
+    "discrete_flow_shift",
+    "sigmoid_scale",
+    "min_timestep",
+    "max_timestep",
+    # training settings
+    "sdpa",
+    "flash_attn",
+    "sage_attn",
+    "xformers",
+    "split_attn",
+    "use_legacy_sdpa",
+    "max_train_steps",
+    "max_train_epochs",
+    "max_data_loader_n_workers",
+    "persistent_data_loader_workers",
+    "seed",
+    "gradient_checkpointing",
+    "gradient_checkpointing_cpu_offload",
+    "gradient_accumulation_steps",
+    "full_bf16",
+    "full_fp16",
+    "logging_dir",
+    "log_with",
+    "log_prefix",
+    "log_tracker_name",
+    "wandb_run_name",
+    "log_tracker_config",
+    "wandb_api_key",
+    "log_config",
+    "ddp_timeout",
+    "ddp_gradient_as_bucket_view",
+    "ddp_static_graph",
+    # samples
+    "sample_every_n_steps",
+    "sample_every_n_epochs",
+    "sample_at_first",
+    "sample_prompts",
+    "disable_prompt_enhancement",
+    "sample_output_dir",
+    "sample_width",
+    "sample_height",
+    "sample_steps",
+    "sample_guidance_scale",
+    "sample_seed",
+    "sample_negative_prompt",
+    "sample_cfg_scale",
+    # caching
+    "caching_latent_device",
+    "caching_latent_batch_size",
+    "caching_latent_num_workers",
+    "caching_latent_skip_existing",
+    "caching_latent_keep_cache",
+    "caching_teo_device",
+    "caching_teo_batch_size",
+    "caching_teo_num_workers",
+    "caching_teo_skip_existing",
+    "caching_teo_keep_cache",
+    "caching_teo_fp8_llm",
+    # optimizer/scheduler
+    "optimizer_type",
+    "optimizer_args",
+    "learning_rate",
+    "max_grad_norm",
+    "fused_backward_pass",
+    "lr_scheduler",
+    "lr_warmup_steps",
+    "lr_decay_steps",
+    "lr_scheduler_num_cycles",
+    "lr_scheduler_power",
+    "lr_scheduler_timescale",
+    "lr_scheduler_min_lr_ratio",
+    "lr_scheduler_type",
+    "lr_scheduler_args",
+    # network
+    "no_metadata",
+    "network_weights",
+    "network_module",
+    "network_dim",
+    "network_alpha",
+    "network_dropout",
+    "network_args",
+    "training_comment",
+    "dim_from_weights",
+    "scale_weight_norms",
+    "base_weights",
+    "base_weights_multiplier",
+    # save/load
+    "output_dir",
+    "output_name",
+    "resume",
+    "save_precision",
+    "save_every_n_epochs",
+    "save_last_n_epochs",
+    "save_every_n_steps",
+    "save_last_n_steps",
+    "save_last_n_epochs_state",
+    "save_last_n_steps_state",
+    "save_state",
+    "save_state_on_train_end",
+    "mem_eff_save",
+    # metadata
+    "metadata_author",
+    "metadata_description",
+    "metadata_license",
+    "metadata_tags",
+    "metadata_title",
+    "metadata_reso",
+    "metadata_arch",
+    # huggingface
+    "huggingface_repo_id",
+    "huggingface_token",
+    "huggingface_repo_type",
+    "huggingface_repo_visibility",
+    "huggingface_path_in_repo",
+    "save_state_to_huggingface",
+    "resume_from_huggingface",
+    "async_upload",
+]
+
+
+def zimage_gui_actions(action: str, ask_for_file: bool, config_file_name: str, headless: bool, print_only: bool, *args):
+    if action == "open_configuration":
+        return open_zimage_configuration(ask_for_file, config_file_name, list(zip(ZIMAGE_PARAM_KEYS, args)))
+    if action == "save_configuration":
+        return save_zimage_configuration(ask_for_file, config_file_name, list(zip(ZIMAGE_PARAM_KEYS, args)))
+    if action == "train_model":
+        return train_zimage_model(headless=headless, print_only=print_only, parameters=list(zip(ZIMAGE_PARAM_KEYS, args)))
+
+
+def zimage_lora_tab(headless=False, config: GUIConfig = {}):
+    global executor
+
+    dummy_true = gr.Checkbox(value=True, visible=False)
+    dummy_false = gr.Checkbox(value=False, visible=False)
+    dummy_headless = gr.Checkbox(value=headless, visible=False)
+
+    defaults = {
+        "training_mode": "LoRA Training",
+        "zimage_variant": "base",
+        "training_adapter_path": "",
+        "training_adapter_multiplier": 1.0,
+        "network_module": "networks.lora_zimage",
+        "output_name": "my-zimage-lora",
+        # Torch compile defaults
+        "compile": False,
+        "compile_backend": "inductor",
+        "compile_mode": "default",
+        "compile_dynamic": "auto",
+        "compile_fullgraph": False,
+        "compile_cache_size_limit": 0,
+        "mixed_precision": "bf16",
+        "num_cpu_threads_per_process": 1,
+        "sdpa": True,
+        "optimizer_type": "adamw8bit",
+        "learning_rate": 1e-4,
+        "fused_backward_pass": False,
+        "gradient_checkpointing": True,
+        "timestep_sampling": "shift",
+        "weighting_scheme": "none",
+        "discrete_flow_shift": 2.0,
+        "dataset_config_mode": "Generate from Folder Structure",
+        "dataset_resolution_width": 1024,
+        "dataset_resolution_height": 1024,
+        "dataset_enable_bucket": True,
+        "dataset_cache_directory": "cache_dir",
+        # Caching defaults
+        "caching_latent_device": "cuda",
+        "caching_latent_batch_size": 1,
+        "caching_latent_num_workers": 2,
+        "caching_latent_skip_existing": True,
+        "caching_latent_keep_cache": True,
+        "caching_teo_device": "cuda",
+        "caching_teo_batch_size": 8,
+        "caching_teo_num_workers": 2,
+        "caching_teo_skip_existing": True,
+        "caching_teo_keep_cache": True,
+        "caching_teo_fp8_llm": False,
+        # Samples
+        "disable_prompt_enhancement": False,
+        "sample_width": 1024,
+        "sample_height": 1024,
+        "sample_steps": 25,
+        "sample_cfg_scale": 4.0,
+    }
+
+    if isinstance(config, dict):
+        config.update({k: v for k, v in defaults.items() if k not in config})
+        config = type("GUIConfig", (), {"config": config, "get": config.get})()
+    elif hasattr(config, "config"):
+        if not getattr(config, "config", None):
+            config.config = defaults.copy()
+        else:
+            config.config.update({k: v for k, v in defaults.items() if k not in config.config})
+
+    with gr.Accordion("Configuration file Settings", open=True):
+        configuration = ConfigurationFile(headless=headless, config=config)
+
+    # Add search functionality and unified toggle button
+    with gr.Row():
+        with gr.Column(scale=2):
+            search_input = gr.Textbox(
+                label="🔍 Search Settings",
+                placeholder="Type to search and filter panels (e.g., 'model', 'learning', 'fp8', 'cache', 'epochs')",
+                lines=1,
+                interactive=True,
+                info="Filter settings panels by keyword.",
+            )
+        with gr.Column(scale=1):
+            toggle_all_btn = gr.Button(
+                value="Open All Panels",
+                variant="secondary",
+                size="lg",
+                elem_id="toggle-all-btn"
+            )
+            # Hidden state to track if panels are open or closed
+            panels_state = gr.State(value="closed")  # Default state is closed
+
+    # Hidden elements for search functionality (not displayed)
+    search_results_row = gr.Row(visible=False)
+    search_results = gr.HTML(visible=False)
+
+    # Create accordion references
+    accordions = []
+
+    accelerate_accordion = gr.Accordion("Accelerate launch Settings", open=False, elem_classes="flux1_background")
+    accordions.append(accelerate_accordion)
+    with accelerate_accordion:
+        accelerate_launch = AccelerateLaunch(config=config)
+
+    save_load_accordion = gr.Accordion("Save Models and Resume Training Settings", open=False, elem_classes="samples_background")
+    accordions.append(save_load_accordion)
+    with save_load_accordion:
+        save_load = SaveLoadSettings(headless=headless, config=config)
+
+    dataset_accordion = gr.Accordion("Z-Image Training Dataset", open=False, elem_classes="samples_background")
+    accordions.append(dataset_accordion)
+    with dataset_accordion:
+        with gr.Row():
+            dataset_config_mode = gr.Radio(
+                label="Dataset Configuration Method",
+                choices=["Use TOML File", "Generate from Folder Structure"],
+                value=config.get("dataset_config_mode", "Generate from Folder Structure"),
+                info="Choose how to configure your dataset: provide a TOML file or auto-generate from folder structure",
+            )
+
+        def _toggle_dataset_mode(mode):
+            toml_visible = mode == "Use TOML File"
+            folder_visible = mode == "Generate from Folder Structure"
+            return gr.Row(visible=toml_visible), gr.Column(visible=folder_visible)
+
+        with gr.Row(
+            visible=config.get("dataset_config_mode", "Generate from Folder Structure") == "Use TOML File"
+        ) as toml_mode_row:
+            dataset_config = gr.Textbox(
+                label="dataset_config",
+                value=config.get("dataset_config", ""),
+                interactive=True,
+                info="Path to dataset TOML used by caching and training.",
+            )
+            dataset_config_btn = gr.Button("📁", size="lg", visible=not headless)
+            dataset_config_btn.click(
+                fn=lambda: get_file_path(file_path="", default_extension=".toml", extension_name="TOML files"),
+                outputs=[dataset_config],
+            )
+
+        with gr.Column(
+            visible=config.get("dataset_config_mode", "Generate from Folder Structure") == "Generate from Folder Structure"
+        ) as folder_mode_column:
+            with gr.Row():
+                parent_folder_path = gr.Textbox(
+                    label="parent_folder_path",
+                    value=config.get("parent_folder_path", ""),
+                    interactive=True,
+                    info="Parent folder used to generate a dataset TOML (only in Generate mode).",
+                )
+                parent_folder_btn = gr.Button("📂", size="lg", visible=not headless)
+                parent_folder_btn.click(fn=lambda: get_folder_path(folder_path=""), outputs=[parent_folder_path])
+
+            with gr.Row():
+                dataset_resolution_width = gr.Number(
+                    label="dataset_resolution_width",
+                    value=config.get("dataset_resolution_width", 1024),
+                    step=8,
+                    interactive=True,
+                    info="Target dataset width in pixels (multiples of 8 recommended).",
+                )
+                dataset_resolution_height = gr.Number(
+                    label="dataset_resolution_height",
+                    value=config.get("dataset_resolution_height", 1024),
+                    step=8,
+                    interactive=True,
+                    info="Target dataset height in pixels (multiples of 8 recommended).",
+                )
+
+            with gr.Row():
+                dataset_caption_extension = gr.Textbox(
+                    label="dataset_caption_extension",
+                    value=config.get("dataset_caption_extension", ".txt"),
+                    interactive=True,
+                    info="Caption file extension to read/write (e.g., .txt).",
+                )
+                create_missing_captions = gr.Checkbox(
+                    label="create_missing_captions",
+                    value=bool(config.get("create_missing_captions", True)),
+                    info="Create empty captions when missing during TOML generation.",
+                )
+                caption_strategy = gr.Dropdown(
+                    label="caption_strategy",
+                    choices=["folder_name", "empty"],
+                    value=config.get("caption_strategy", "folder_name"),
+                    interactive=True,
+                    info="folder_name uses the folder name as caption; empty writes blank captions.",
+                )
+
+            with gr.Row():
+                dataset_batch_size = gr.Number(
+                    label="dataset_batch_size",
+                    value=config.get("dataset_batch_size", 1),
+                    minimum=1,
+                    step=1,
+                    interactive=True,
+                    info="Batch size recorded in the dataset config.",
+                )
+                dataset_enable_bucket = gr.Checkbox(
+                    label="dataset_enable_bucket",
+                    value=bool(config.get("dataset_enable_bucket", True)),
+                    info="Enable resolution bucketing in the dataset config.",
+                )
+                dataset_bucket_no_upscale = gr.Checkbox(
+                    label="dataset_bucket_no_upscale",
+                    value=bool(config.get("dataset_bucket_no_upscale", False)),
+                    info="Do not upscale smaller images when bucketing.",
+                )
+
+            with gr.Row():
+                dataset_cache_directory = gr.Textbox(
+                    label="dataset_cache_directory",
+                    value=config.get("dataset_cache_directory", "cache_dir"),
+                    interactive=True,
+                    info="Cache directory name for latent/text encoder outputs.",
+                )
+                generated_toml_path = gr.Textbox(
+                    label="generated_toml_path",
+                    value=config.get("generated_toml_path", ""),
+                    interactive=False,
+                    info="Read-only: path of the generated dataset TOML.",
+                )
+
+            with gr.Row():
+                dataset_status = gr.Textbox(label="Dataset status", value="", interactive=False, info="Validation and status messages.")
+
+            with gr.Row():
+                generate_toml_btn = gr.Button("Generate dataset TOML", variant="primary")
+                generate_toml_btn.click(
+                    fn=_generate_zimage_dataset_toml,
+                    inputs=[
+                        parent_folder_path,
+                        dataset_resolution_width,
+                        dataset_resolution_height,
+                        dataset_caption_extension,
+                        create_missing_captions,
+                        caption_strategy,
+                        dataset_batch_size,
+                        dataset_enable_bucket,
+                        dataset_bucket_no_upscale,
+                        dataset_cache_directory,
+                        save_load.output_dir,
+                    ],
+                    outputs=[dataset_config, generated_toml_path, dataset_status],
+                )
+
+        dataset_config_mode.change(
+            fn=_toggle_dataset_mode,
+            inputs=[dataset_config_mode],
+            outputs=[toml_mode_row, folder_mode_column],
+        )
+
+    model_accordion = gr.Accordion("Z-Image Model Settings", open=False, elem_classes="preset_background")
+    accordions.append(model_accordion)
+    with model_accordion:
+        with gr.Row():
+            training_mode = gr.Radio(
+                label="Training Mode",
+                choices=["LoRA Training", "DreamBooth Fine-Tuning"],
+                value=config.get("training_mode", "LoRA Training"),
+                info="LoRA: parameter-efficient. DreamBooth: full fine-tuning (more VRAM).",
+            )
+        with gr.Row():
+            zimage_variant = gr.Dropdown(
+                label="zimage_variant",
+                choices=[("Base", "base"), ("Turbo", "turbo")],
+                value=config.get("zimage_variant", "base"),
+                interactive=True,
+                info="Select Base vs Turbo defaults (your actual DiT checkpoint decides what you train).",
+            )
+        with gr.Row():
+            training_adapter_path = gr.Textbox(
+                label="training_adapter_path",
+                value=config.get("training_adapter_path", ""),
+                placeholder="Optional: zimage_turbo_training_adapter_*.safetensors",
+                interactive=True,
+                info="Optional Turbo Training Adapter (LoRA). If set, it is passed as base_weights (--base_weights).",
+            )
+            adapter_btn = gr.Button("📁", size="lg", visible=not headless)
+            adapter_btn.click(fn=lambda: get_file_path(file_path="", default_extension=".safetensors", extension_name="Model files"), outputs=[training_adapter_path])
+            training_adapter_multiplier = gr.Number(
+                label="training_adapter_multiplier",
+                value=float(config.get("training_adapter_multiplier", 1.0) or 1.0),
+                step=0.1,
+                interactive=True,
+                info="Strength multiplier for the training adapter when merged as base_weights (1.0 = full strength).",
+            )
+        with gr.Row():
+            dit = gr.Textbox(
+                label="DiT (Base Model) Checkpoint Path",
+                value=config.get("dit", ""),
+                placeholder="Path to DiT base model checkpoint (Z_Image_BF16.safetensors)",
+                interactive=True,
+                info="Required DiT checkpoint. Examples: Z_Image_BF16.safetensors or Z_Image_Turbo_BF16.safetensors.",
+            )
+            dit_btn = gr.Button("📁", size="lg", visible=not headless)
+            dit_btn.click(fn=lambda: get_file_path(file_path="", default_extension=".safetensors", extension_name="Model files"), outputs=[dit])
+        with gr.Row():
+            vae = gr.Textbox(
+                label="vae",
+                value=config.get("vae", ""),
+                placeholder="Example: Z_Image_Train_VAE.safetensors",
+                interactive=True,
+                info="Required VAE checkpoint (e.g., Z_Image_Train_VAE.safetensors).",
+            )
+            vae_btn = gr.Button("📁", size="lg", visible=not headless)
+            vae_btn.click(fn=lambda: get_file_path(file_path="", default_extension=".safetensors", extension_name="Model files"), outputs=[vae])
+        with gr.Row():
+            text_encoder = gr.Textbox(
+                label="text_encoder",
+                value=config.get("text_encoder", ""),
+                placeholder="Example: qwen_3_8b.safetensors",
+                interactive=True,
+                info="Required Qwen3 text encoder (Z_Image_Training_Text_Encoder.safetensors).",
+            )
+            te_btn = gr.Button("📁", size="lg", visible=not headless)
+            te_btn.click(fn=lambda: get_file_path(file_path="", default_extension=".safetensors", extension_name="Model files"), outputs=[text_encoder])
+        with gr.Row():
+            fp8_base = gr.Checkbox(
+                label="fp8_base",
+                value=bool(config.get("fp8_base", False)),
+                info="Use FP8 for the base model (DiT) to reduce VRAM.",
+            )
+            fp8_scaled = gr.Checkbox(
+                label="fp8_scaled",
+                value=bool(config.get("fp8_scaled", False)),
+                info="Use scaled FP8 for the base model (recommended with fp8_base).",
+            )
+            fp8_llm = gr.Checkbox(
+                label="fp8_llm",
+                value=bool(config.get("fp8_llm", False)),
+                info="Use FP8 for the Qwen3 text encoder during training.",
+            )
+        with gr.Row():
+            disable_numpy_memmap = gr.Checkbox(
+                label="disable_numpy_memmap",
+                value=bool(config.get("disable_numpy_memmap", False)),
+                info="Disable numpy memmap when loading weights (uses more RAM but can avoid mmap issues).",
+            )
+            blocks_to_swap = gr.Number(
+                label="blocks_to_swap",
+                value=config.get("blocks_to_swap", 0),
+                minimum=0,
+                maximum=28,
+                step=1,
+                interactive=True,
+                info="Offload N transformer blocks to CPU for VRAM savings. Maximum 28.",
+            )
+            use_pinned_memory_for_block_swap = gr.Checkbox(
+                label="use_pinned_memory_for_block_swap",
+                value=bool(config.get("use_pinned_memory_for_block_swap", False)),
+                info="Use pinned memory for faster CPU<->GPU transfers (uses more shared memory on Windows).",
+            )
+            block_swap_h2d_only = gr.Checkbox(
+                label="block_swap_h2d_only",
+                value=bool(config.get("block_swap_h2d_only", False)),
+                info="LoRA only. Stream frozen blocks host-to-device without copying them back. Requires blocks_to_swap > 0 and gradient checkpointing.",
+            )
+            block_swap_ring_size = gr.Number(
+                label="block_swap_ring_size",
+                value=config.get("block_swap_ring_size", 2),
+                minimum=1,
+                step=1,
+                interactive=True,
+                info="GPU buffers used by H2D-only block swap. 2 overlaps transfer and compute; 1 minimizes VRAM.",
+            )
+            img_in_txt_in_offloading = gr.Checkbox(
+                label="img_in_txt_in_offloading",
+                value=bool(config.get("img_in_txt_in_offloading", False)),
+                info="Offload img_in and txt_in tensors to CPU to reduce VRAM.",
+            )
+
+    torch_compile_accordion = gr.Accordion("Torch Compile Settings", open=False)
+    accordions.append(torch_compile_accordion)
+    with torch_compile_accordion:
+        gr.Markdown(
+            """⚠️ **Important:** If you get errors with torch.compile just disable it. It can increase speed and slightly reduce VRAM with no quality loss."""
+        )
+
+        with gr.Row():
+            compile = gr.Checkbox(
+                label="Enable torch.compile",
+                info="Enable torch.compile for faster training (requires PyTorch 2.1+, Triton for CUDA). Disable gradient checkpointing for best results!",
+                value=bool(config.get("compile", False)),
+                interactive=True,
+            )
+            compile_backend = gr.Dropdown(
+                label="Compile Backend",
+                info="Backend for torch.compile (default: inductor)",
+                choices=["inductor", "cudagraphs", "eager", "aot_eager", "aot_ts_nvfuser"],
+                value=config.get("compile_backend", "inductor"),
+                interactive=True,
+            )
+            compile_mode = gr.Dropdown(
+                label="Compile Mode",
+                info="Optimization mode for torch.compile",
+                choices=["default", "reduce-overhead", "max-autotune", "max-autotune-no-cudagraphs"],
+                value=config.get("compile_mode", "default"),
+                interactive=True,
+            )
+
+        with gr.Row():
+            compile_dynamic = gr.Dropdown(
+                label="Dynamic Shapes",
+                info="Dynamic shape handling: auto (default), true (enable), false (disable)",
+                choices=["auto", "true", "false"],
+                value=config.get("compile_dynamic", "auto"),
+                allow_custom_value=False,
+                interactive=True,
+            )
+            compile_fullgraph = gr.Checkbox(
+                label="Fullgraph Mode",
+                info="Enable fullgraph mode in torch.compile (may fail with complex models)",
+                value=bool(config.get("compile_fullgraph", False)),
+                interactive=True,
+            )
+            compile_cache_size_limit = gr.Number(
+                label="Cache Size Limit",
+                info="Set torch._dynamo.config.cache_size_limit (0 = use PyTorch default, typically 8-32)",
+                value=config.get("compile_cache_size_limit", 0),
+                step=1,
+                minimum=0,
+                interactive=True,
+            )
+
+    schedule_accordion = gr.Accordion("Flow Matching and Timestep Settings", open=False, elem_classes="flux1_background")
+    accordions.append(schedule_accordion)
+    with schedule_accordion:
+        with gr.Row():
+            timestep_sampling = gr.Dropdown(
+                label="timestep_sampling",
+                choices=["sigma", "uniform", "sigmoid", "shift", "flux_shift", "flux2_shift", "qwen_shift", "logsnr", "qinglong_flux", "qinglong_qwen"],
+                value=config.get("timestep_sampling", "shift"),
+                interactive=True,
+                info="Timestep sampling method for flow matching (shift recommended for Z-Image).",
+            )
+            weighting_scheme = gr.Dropdown(
+                label="weighting_scheme",
+                choices=["logit_normal", "mode", "cosmap", "sigma_sqrt", "none"],
+                value=config.get("weighting_scheme", "none"),
+                interactive=True,
+                info="Loss weighting scheme for timestep distribution (none disables weighting).",
+            )
+        with gr.Row():
+            discrete_flow_shift = gr.Number(
+                label="discrete_flow_shift",
+                value=config.get("discrete_flow_shift", 2.0),
+                step=0.1,
+                interactive=True,
+                info="Shift factor used by shift/flux_shift sampling.",
+            )
+            sigmoid_scale = gr.Number(
+                label="sigmoid_scale",
+                value=config.get("sigmoid_scale", 1.0),
+                step=0.1,
+                interactive=True,
+                info="Scale for sigmoid/shift timestep sampling.",
+            )
+        with gr.Row():
+            min_timestep = gr.Number(
+                label="min_timestep",
+                value=config.get("min_timestep", 0),
+                step=1,
+                interactive=True,
+                info="Minimum timestep clamp (0-999).",
+            )
+            max_timestep = gr.Number(
+                label="max_timestep",
+                value=config.get("max_timestep", 1000),
+                step=1,
+                interactive=True,
+                info="Maximum timestep clamp (1-1000).",
+            )
+
+    training_accordion = gr.Accordion("Training Settings", open=False, elem_classes="preset_background")
+    accordions.append(training_accordion)
+    with training_accordion:
+        training = TrainingSettings(headless=headless, config=config)
+
+    sample_accordion = gr.Accordion("Sample Generation Settings", open=False, elem_classes="samples_background")
+    accordions.append(sample_accordion)
+    with sample_accordion:
+        _variant_init = (config.get("zimage_variant", "base") or "base").strip().lower()
+        _default_sample_steps = 20 if _variant_init == "turbo" else 25
+        _default_cfg_scale = 1.0 if _variant_init == "turbo" else 4.0
+        with gr.Row():
+            sample_every_n_steps = gr.Number(
+                label="sample_every_n_steps",
+                value=config.get("sample_every_n_steps", 0),
+                minimum=0,
+                step=1,
+                interactive=True,
+                info="Generate samples every N steps (0 disables).",
+            )
+            sample_every_n_epochs = gr.Number(
+                label="sample_every_n_epochs",
+                value=config.get("sample_every_n_epochs", 0),
+                minimum=0,
+                step=1,
+                interactive=True,
+                info="Generate samples every N epochs (overrides steps).",
+            )
+            sample_at_first = gr.Checkbox(
+                label="sample_at_first",
+                value=bool(config.get("sample_at_first", False)),
+                info="Generate samples before training starts.",
+            )
+        with gr.Row():
+            sample_prompts = gr.Textbox(
+                label="sample_prompts",
+                value=config.get("sample_prompts", ""),
+                interactive=True,
+                info="Path to a prompt file (one prompt per line). Missing defaults are auto-added unless disabled below.",
+            )
+            sample_prompts_btn = gr.Button("📁", size="lg", visible=not headless)
+            sample_prompts_btn.click(fn=lambda: get_file_path(file_path="", default_extension=".txt", extension_name="Text files"), outputs=[sample_prompts])
+        with gr.Row():
+            disable_prompt_enhancement = gr.Checkbox(
+                label="Disable Automatic Prompt Enhancement",
+                value=bool(config.get("disable_prompt_enhancement", False)),
+                info="Use prompt file as-is (do not auto-add default --w/--h/--s/--l/--d/--n values).",
+            )
+        with gr.Row():
+            sample_output_dir = gr.Textbox(
+                label="sample_output_dir",
+                value=config.get("sample_output_dir", ""),
+                interactive=True,
+                info="Folder to save generated samples.",
+            )
+            sample_output_dir_btn = gr.Button("📂", size="lg", visible=not headless)
+            sample_output_dir_btn.click(fn=lambda: get_folder_path(folder_path=""), outputs=[sample_output_dir])
+        with gr.Row():
+            sample_width = gr.Number(
+                label="sample_width",
+                value=config.get("sample_width", 1024),
+                step=8,
+                interactive=True,
+                info="Sample width in pixels (multiples of 8 recommended).",
+            )
+            sample_height = gr.Number(
+                label="sample_height",
+                value=config.get("sample_height", 1024),
+                step=8,
+                interactive=True,
+                info="Sample height in pixels (multiples of 8 recommended).",
+            )
+        with gr.Row():
+            sample_steps = gr.Number(
+                label="sample_steps",
+                value=config.get("sample_steps", _default_sample_steps),
+                step=1,
+                interactive=True,
+                info="Sampling steps (Base ~25, Turbo ~20 by default).",
+            )
+            sample_guidance_scale = gr.Number(
+                label="sample_guidance_scale",
+                value=config.get("sample_guidance_scale", 0.0),
+                step=0.1,
+                interactive=True,
+                info="Legacy guidance scale; Z-Image uses sample_cfg_scale (--l) instead.",
+            )
+            sample_seed = gr.Number(
+                label="sample_seed",
+                value=config.get("sample_seed", 42),
+                step=1,
+                interactive=True,
+                info="Seed for sample generation.",
+            )
+        with gr.Row():
+            sample_cfg_scale = gr.Number(
+                label="sample_cfg_scale",
+                value=config.get("sample_cfg_scale", _default_cfg_scale),
+                step=0.1,
+                interactive=True,
+                info="CFG scale for Z-Image sampling (kohya flag: --l).",
+            )
+            sample_negative_prompt = gr.Textbox(
+                label="sample_negative_prompt",
+                value=config.get("sample_negative_prompt", ""),
+                interactive=True,
+                info="Optional negative prompt (used when cfg_scale > 1).",
+            )
+
+        # Variant-based suggestions (doesn't force anything, but helps defaults)
+        def _variant_defaults(variant: str):
+            if variant == "turbo":
+                return gr.update(value=1.0), gr.update(value=20)
+            return gr.update(value=4.0), gr.update(value=25)
+
+        zimage_variant.change(fn=_variant_defaults, inputs=[zimage_variant], outputs=[sample_cfg_scale, sample_steps])
+
+    caching_accordion = gr.Accordion("Caching Settings", open=False, elem_classes="samples_background")
+    accordions.append(caching_accordion)
+    with caching_accordion:
+        with gr.Row():
+            caching_latent_device = gr.Textbox(
+                label="caching_latent_device",
+                value=config.get("caching_latent_device", "cuda"),
+                interactive=True,
+                info="Device for latent caching (e.g., cuda, cuda:0, cpu).",
+            )
+            caching_latent_batch_size = gr.Number(
+                label="caching_latent_batch_size",
+                value=config.get("caching_latent_batch_size", 1),
+                step=1,
+                interactive=True,
+                info="Batch size for latent caching.",
+            )
+            caching_latent_num_workers = gr.Number(
+                label="caching_latent_num_workers",
+                value=config.get("caching_latent_num_workers", 2),
+                step=1,
+                interactive=True,
+                info="Dataloader workers for latent caching.",
+            )
+        with gr.Row():
+            caching_latent_skip_existing = gr.Checkbox(
+                label="caching_latent_skip_existing",
+                value=bool(config.get("caching_latent_skip_existing", True)),
+                info="Skip existing cache entries (set false to disable latent caching step).",
+            )
+            caching_latent_keep_cache = gr.Checkbox(
+                label="caching_latent_keep_cache",
+                value=bool(config.get("caching_latent_keep_cache", True)),
+                info="Keep latent cache after training.",
+            )
+        with gr.Row():
+            caching_teo_device = gr.Textbox(
+                label="caching_teo_device",
+                value=config.get("caching_teo_device", "cuda"),
+                interactive=True,
+                info="Device for text encoder output caching.",
+            )
+            caching_teo_batch_size = gr.Number(
+                label="caching_teo_batch_size",
+                value=config.get("caching_teo_batch_size", 8),
+                step=1,
+                interactive=True,
+                info="Batch size for text encoder output caching.",
+            )
+            caching_teo_num_workers = gr.Number(
+                label="caching_teo_num_workers",
+                value=config.get("caching_teo_num_workers", 2),
+                step=1,
+                interactive=True,
+                info="Dataloader workers for text encoder output caching.",
+            )
+        with gr.Row():
+            caching_teo_skip_existing = gr.Checkbox(
+                label="caching_teo_skip_existing",
+                value=bool(config.get("caching_teo_skip_existing", True)),
+                info="Skip existing caches (set false to disable text encoder caching step).",
+            )
+            caching_teo_keep_cache = gr.Checkbox(
+                label="caching_teo_keep_cache",
+                value=bool(config.get("caching_teo_keep_cache", True)),
+                info="Keep text encoder output cache after training.",
+            )
+            caching_teo_fp8_llm = gr.Checkbox(
+                label="caching_teo_fp8_llm",
+                value=bool(config.get("caching_teo_fp8_llm", False)),
+                interactive=True,
+                info="Use FP8 for the Qwen3 text encoder during caching.",
+            )
+
+    optimizer_accordion = gr.Accordion("Learning Rate, Optimizer and Scheduler Settings", open=False, elem_classes="flux1_rank_layers_background")
+    accordions.append(optimizer_accordion)
+    with optimizer_accordion:
+        optim = OptimizerAndScheduler(headless=headless, config=config)
+        fused_backward_pass = gr.Checkbox(
+            label="fused_backward_pass",
+            value=bool(config.get("fused_backward_pass", False)),
+            info="DreamBooth only: reduces VRAM during backward pass with AdaFactor. Not effective for LoRA training.",
+        )
+
+    network_accordion = gr.Accordion("LoRA Settings", open=False, elem_classes="flux1_background")
+    accordions.append(network_accordion)
+    with network_accordion:
+        network = Network(headless=headless, config=config)
+
+    advanced_accordion = gr.Accordion("Advanced Settings", open=False, elem_classes="samples_background")
+    accordions.append(advanced_accordion)
+    with advanced_accordion:
+        advanced = AdvancedTraining(headless=headless, config=config)
+
+    metadata_accordion = gr.Accordion("Metadata Settings", open=False, elem_classes="flux1_rank_layers_background")
+    accordions.append(metadata_accordion)
+    with metadata_accordion:
+        metadata = MetaData(config=config)
+
+    huggingface_accordion = gr.Accordion("HuggingFace Settings", open=False, elem_classes="huggingface_background")
+    accordions.append(huggingface_accordion)
+    with huggingface_accordion:
+        huggingface = HuggingFace(config=config)
+
+    executor = CommandExecutor(headless=headless)
+    run_state = gr.Textbox(value=train_state_value, visible=False)
+
+    with gr.Column(), gr.Group():
+        with gr.Row():
+            button_print = gr.Button("Print training command")
+            toggle_all_btn_bottom = gr.Button(
+                value="Open All Panels",
+                variant="secondary"
+            )
+
+    settings_list = [
+        # accelerate_launch
+        accelerate_launch.mixed_precision,
+        accelerate_launch.num_cpu_threads_per_process,
+        accelerate_launch.num_processes,
+        accelerate_launch.num_machines,
+        accelerate_launch.multi_gpu,
+        accelerate_launch.gpu_ids,
+        accelerate_launch.main_process_port,
+        accelerate_launch.dynamo_backend,
+        accelerate_launch.dynamo_mode,
+        accelerate_launch.dynamo_use_fullgraph,
+        accelerate_launch.dynamo_use_dynamic,
+        accelerate_launch.extra_accelerate_launch_args,
+        # advanced_training
+        advanced.additional_parameters,
+        advanced.debug_mode,
+        # dataset
+        dataset_config_mode,
+        dataset_config,
+        parent_folder_path,
+        dataset_resolution_width,
+        dataset_resolution_height,
+        dataset_caption_extension,
+        create_missing_captions,
+        caption_strategy,
+        dataset_batch_size,
+        dataset_enable_bucket,
+        dataset_bucket_no_upscale,
+        dataset_cache_directory,
+        generated_toml_path,
+        # variant
+        training_mode,
+        zimage_variant,
+        training_adapter_path,
+        training_adapter_multiplier,
+        # model
+        dit,
+        vae,
+        text_encoder,
+        fp8_base,
+        fp8_scaled,
+        fp8_llm,
+        disable_numpy_memmap,
+        blocks_to_swap,
+        use_pinned_memory_for_block_swap,
+        block_swap_h2d_only,
+        block_swap_ring_size,
+        img_in_txt_in_offloading,
+        # torch compile
+        compile,
+        compile_backend,
+        compile_mode,
+        compile_dynamic,
+        compile_fullgraph,
+        compile_cache_size_limit,
+        # schedule
+        timestep_sampling,
+        weighting_scheme,
+        discrete_flow_shift,
+        sigmoid_scale,
+        min_timestep,
+        max_timestep,
+        # training settings
+        training.sdpa,
+        training.flash_attn,
+        training.sage_attn,
+        training.xformers,
+        training.split_attn,
+        training.use_legacy_sdpa,
+        training.max_train_steps,
+        training.max_train_epochs,
+        training.max_data_loader_n_workers,
+        training.persistent_data_loader_workers,
+        training.seed,
+        training.gradient_checkpointing,
+        training.gradient_checkpointing_cpu_offload,
+        training.gradient_accumulation_steps,
+        training.full_bf16,
+        training.full_fp16,
+        training.logging_dir,
+        training.log_with,
+        training.log_prefix,
+        training.log_tracker_name,
+        training.wandb_run_name,
+        training.log_tracker_config,
+        training.wandb_api_key,
+        training.log_config,
+        training.ddp_timeout,
+        training.ddp_gradient_as_bucket_view,
+        training.ddp_static_graph,
+        # samples
+        sample_every_n_steps,
+        sample_every_n_epochs,
+        sample_at_first,
+        sample_prompts,
+        disable_prompt_enhancement,
+        sample_output_dir,
+        sample_width,
+        sample_height,
+        sample_steps,
+        sample_guidance_scale,
+        sample_seed,
+        sample_negative_prompt,
+        sample_cfg_scale,
+        # caching
+        caching_latent_device,
+        caching_latent_batch_size,
+        caching_latent_num_workers,
+        caching_latent_skip_existing,
+        caching_latent_keep_cache,
+        caching_teo_device,
+        caching_teo_batch_size,
+        caching_teo_num_workers,
+        caching_teo_skip_existing,
+        caching_teo_keep_cache,
+        caching_teo_fp8_llm,
+        # optimizer/scheduler
+        optim.optimizer_type,
+        optim.optimizer_args,
+        optim.learning_rate,
+        optim.max_grad_norm,
+        fused_backward_pass,
+        optim.lr_scheduler,
+        optim.lr_warmup_steps,
+        optim.lr_decay_steps,
+        optim.lr_scheduler_num_cycles,
+        optim.lr_scheduler_power,
+        optim.lr_scheduler_timescale,
+        optim.lr_scheduler_min_lr_ratio,
+        optim.lr_scheduler_type,
+        optim.lr_scheduler_args,
+        # network
+        network.no_metadata,
+        network.network_weights,
+        network.network_module,
+        network.network_dim,
+        network.network_alpha,
+        network.network_dropout,
+        network.network_args,
+        network.training_comment,
+        network.dim_from_weights,
+        network.scale_weight_norms,
+        network.base_weights,
+        network.base_weights_multiplier,
+        # save/load
+        save_load.output_dir,
+        save_load.output_name,
+        save_load.resume,
+        save_load.save_precision,
+        save_load.save_every_n_epochs,
+        save_load.save_last_n_epochs,
+        save_load.save_every_n_steps,
+        save_load.save_last_n_steps,
+        save_load.save_last_n_epochs_state,
+        save_load.save_last_n_steps_state,
+        save_load.save_state,
+        save_load.save_state_on_train_end,
+        save_load.mem_eff_save,
+        # metadata
+        metadata.metadata_author,
+        metadata.metadata_description,
+        metadata.metadata_license,
+        metadata.metadata_tags,
+        metadata.metadata_title,
+        metadata.metadata_reso,
+        metadata.metadata_arch,
+        # huggingface
+        huggingface.huggingface_repo_id,
+        huggingface.huggingface_token,
+        huggingface.huggingface_repo_type,
+        huggingface.huggingface_repo_visibility,
+        huggingface.huggingface_path_in_repo,
+        huggingface.save_state_to_huggingface,
+        huggingface.resume_from_huggingface,
+        huggingface.async_upload,
+    ]
+
+    assert len(settings_list) == len(ZIMAGE_PARAM_KEYS), f"settings_list ({len(settings_list)}) != keys ({len(ZIMAGE_PARAM_KEYS)})"
+
+    # Add handler for search functionality
+    def search_settings(query):
+        if not query or len(query.strip()) < 1:
+            return gr.Row(visible=False), ""
+
+        query_lower = query.lower().strip()
+        results = []
+
+        # Comprehensive parameter map for Z-Image
+        parameter_map = {
+            # Model Variant
+            "training_mode": ("Z-Image Model Settings", "Training Mode (LoRA/DreamBooth)"),
+            "zimage_variant": ("Z-Image Model Settings", "Z-Image Variant (Base/Turbo)"),
+            "base": ("Z-Image Model Settings", "Base Model"),
+            "turbo": ("Z-Image Model Settings", "Turbo Model (Distilled)"),
+            "variant": ("Z-Image Model Settings", "Model Variant"),
+            "adapter": ("Z-Image Model Settings", "Turbo Training Adapter (LoRA)"),
+            "training_adapter": ("Z-Image Model Settings", "Turbo Training Adapter (LoRA)"),
+            "base_weights": ("LoRA Settings", "Base Weights"),
+
+            # Model Paths
+            "dit": ("Z-Image Model Settings", "DiT (Base Model) Checkpoint Path"),
+            "vae": ("Z-Image Model Settings", "VAE Checkpoint Path"),
+            "text_encoder": ("Z-Image Model Settings", "Text Encoder (Qwen3) Path"),
+
+            # FP8 and Memory
+            "fp8_base": ("Z-Image Model Settings", "FP8 for Base Model (DiT)"),
+            "fp8_scaled": ("Z-Image Model Settings", "Scaled FP8 for Base Model"),
+            "fp8_llm": ("Z-Image Model Settings", "FP8 for Qwen3 Text Encoder"),
+            "blocks_to_swap": ("Z-Image Model Settings", "Blocks to Swap to CPU"),
+            "blocks": ("Z-Image Model Settings", "Blocks to Swap"),
+            "swap": ("Z-Image Model Settings", "Blocks to Swap"),
+            "cpu": ("Z-Image Model Settings", "CPU Offloading"),
+            "disable_numpy_memmap": ("Z-Image Model Settings", "Disable NumPy Memmap"),
+            "use_pinned_memory_for_block_swap": ("Z-Image Model Settings", "Use Pinned Memory for Block Swap"),
+            "img_in_txt_in_offloading": ("Z-Image Model Settings", "Image-in-Text Input Offloading"),
+
+            # Torch Compile
+            "compile": ("Torch Compile Settings", "Enable torch.compile"),
+            "compile_backend": ("Torch Compile Settings", "Compile Backend"),
+            "compile_mode": ("Torch Compile Settings", "Compile Mode"),
+            "compile_dynamic": ("Torch Compile Settings", "Dynamic Shapes"),
+            "compile_fullgraph": ("Torch Compile Settings", "Fullgraph Mode"),
+            "compile_cache_size_limit": ("Torch Compile Settings", "Cache Size Limit"),
+
+            # Dataset Settings
+            "dataset": ("Z-Image Training Dataset", "Dataset Configuration"),
+            "dataset_config_mode": ("Z-Image Training Dataset", "Dataset Configuration Method"),
+            "dataset_config": ("Z-Image Training Dataset", "Dataset Config File"),
+            "parent_folder": ("Z-Image Training Dataset", "Parent Folder Path"),
+            "resolution": ("Z-Image Training Dataset", "Resolution"),
+            "caption": ("Z-Image Training Dataset", "Caption Settings"),
+            "bucket": ("Z-Image Training Dataset", "Bucketing"),
+            "batch_size": ("Z-Image Training Dataset", "Batch Size"),
+            "cache_directory": ("Z-Image Training Dataset", "Cache Directory"),
+
+            # Flow Matching
+            "timestep": ("Flow Matching and Timestep Settings", "Timestep Sampling"),
+            "weighting": ("Flow Matching and Timestep Settings", "Weighting Scheme"),
+            "discrete_flow_shift": ("Flow Matching and Timestep Settings", "Discrete Flow Shift"),
+            "sigmoid": ("Flow Matching and Timestep Settings", "Sigmoid Scale"),
+
+            # Training Settings
+            "sdpa": ("Training Settings", "Use SDPA"),
+            "flash_attn": ("Training Settings", "Use FlashAttention"),
+            "sage_attn": ("Training Settings", "Use SageAttention"),
+            "xformers": ("Training Settings", "Use xformers"),
+            "split_attn": ("Training Settings", "Split Attention"),
+            "use_legacy_sdpa": ("Training Settings", "Use Legacy PyTorch SDPA"),
+            "max_train_steps": ("Training Settings", "Max Training Steps"),
+            "max_train_epochs": ("Training Settings", "Max Training Epochs"),
+            "epochs": ("Training Settings", "Training Epochs"),
+            "steps": ("Training Settings", "Training Steps"),
+            "seed": ("Training Settings", "Random Seed"),
+            "gradient": ("Training Settings", "Gradient Settings"),
+            "gradient_checkpointing": ("Training Settings", "Gradient Checkpointing"),
+            "gradient_accumulation": ("Training Settings", "Gradient Accumulation Steps"),
+            "full_bf16": ("Training Settings", "Full BF16"),
+            "full_fp16": ("Training Settings", "Full FP16"),
+            "workers": ("Training Settings", "DataLoader Workers"),
+            "persistent": ("Training Settings", "Persistent DataLoader Workers"),
+
+            # Optimizer Settings
+            "optimizer": ("Learning Rate, Optimizer and Scheduler Settings", "Optimizer Type"),
+            "learning_rate": ("Learning Rate, Optimizer and Scheduler Settings", "Learning Rate"),
+            "lr": ("Learning Rate, Optimizer and Scheduler Settings", "Learning Rate"),
+            "adamw": ("Learning Rate, Optimizer and Scheduler Settings", "AdamW Optimizer"),
+            "scheduler": ("Learning Rate, Optimizer and Scheduler Settings", "LR Scheduler"),
+            "warmup": ("Learning Rate, Optimizer and Scheduler Settings", "LR Warmup Steps"),
+            "max_grad_norm": ("Learning Rate, Optimizer and Scheduler Settings", "Max Gradient Norm"),
+            "fused_backward_pass": ("Learning Rate, Optimizer and Scheduler Settings", "Fused Backward Pass"),
+
+            # Network/LoRA Settings
+            "lora": ("LoRA Settings", "LoRA Configuration"),
+            "network_module": ("LoRA Settings", "Network Module"),
+            "network_dim": ("LoRA Settings", "Network Dimension (LoRA Rank)"),
+            "network_alpha": ("LoRA Settings", "Network Alpha"),
+            "network_dropout": ("LoRA Settings", "Network Dropout"),
+            "network_args": ("LoRA Settings", "Network Arguments"),
+            "rank": ("LoRA Settings", "LoRA Rank"),
+            "alpha": ("LoRA Settings", "LoRA Alpha"),
+            "lora_zimage": ("LoRA Settings", "LoRA Z-Image Module"),
+
+            # Caching
+            "cache": ("Caching Settings", "Caching Configuration"),
+            "latent_cache": ("Caching Settings", "Latent Caching"),
+            "text_encoder_cache": ("Caching Settings", "Text Encoder Output Caching"),
+            "teo_cache": ("Caching Settings", "Text Encoder Output Caching"),
+            "caching_device": ("Caching Settings", "Caching Device"),
+            "skip_existing": ("Caching Settings", "Skip Existing Cache"),
+            "keep_cache": ("Caching Settings", "Keep Cache Files"),
+            "fp8_llm_cache": ("Caching Settings", "FP8 for Text Encoder Caching"),
+
+            # Samples
+            "sample": ("Sample Generation Settings", "Sample Generation"),
+            "sample_prompts": ("Sample Generation Settings", "Sample Prompts File"),
+            "disable_prompt_enhancement": ("Sample Generation Settings", "Disable Automatic Prompt Enhancement"),
+            "sample_steps": ("Sample Generation Settings", "Sample Steps"),
+            "sample_cfg_scale": ("Sample Generation Settings", "Sample CFG Scale"),
+            "guidance": ("Sample Generation Settings", "Guidance Scale"),
+            "cfg": ("Sample Generation Settings", "CFG Scale"),
+
+            # Save/Load
+            "output": ("Save Models and Resume Training Settings", "Output Settings"),
+            "output_dir": ("Save Models and Resume Training Settings", "Output Directory"),
+            "output_name": ("Save Models and Resume Training Settings", "Output Name"),
+            "save_every": ("Save Models and Resume Training Settings", "Save Frequency"),
+            "resume": ("Save Models and Resume Training Settings", "Resume Training"),
+            "save_state": ("Save Models and Resume Training Settings", "Save Optimizer State"),
+            "mem_eff_save": ("Save Models and Resume Training Settings", "Memory Efficient Save"),
+
+            # Accelerate
+            "mixed_precision": ("Accelerate launch Settings", "Mixed Precision"),
+            "bf16": ("Accelerate launch Settings", "BF16 Mixed Precision"),
+            "num_processes": ("Accelerate launch Settings", "Number of Processes"),
+            "multi_gpu": ("Accelerate launch Settings", "Multi GPU"),
+            "gpu_ids": ("Accelerate launch Settings", "GPU IDs"),
+            "dynamo": ("Accelerate launch Settings", "Dynamo Backend"),
+
+            # Metadata
+            "metadata": ("Metadata Settings", "Model Metadata"),
+            "author": ("Metadata Settings", "Metadata Author"),
+            "description": ("Metadata Settings", "Metadata Description"),
+            "license": ("Metadata Settings", "Metadata License"),
+            "tags": ("Metadata Settings", "Metadata Tags"),
+
+            # HuggingFace
+            "huggingface": ("HuggingFace Settings", "HuggingFace Upload"),
+            "repo_id": ("HuggingFace Settings", "Repository ID"),
+            "huggingface_token": ("HuggingFace Settings", "HuggingFace Token"),
+
+            # Advanced
+            "additional_parameters": ("Advanced Settings", "Additional Parameters"),
+            "debug": ("Advanced Settings", "Debug Mode"),
+        }
+
+        # Search through parameter map
+        for param, (location, display_name) in parameter_map.items():
+            if query_lower in param.lower() or query_lower in display_name.lower() or param.lower() in query_lower:
+                score = 0
+                if query_lower == param.lower():
+                    score = 100
+                elif param.lower().startswith(query_lower):
+                    score = 80
+                elif query_lower in param.lower():
+                    score = 60
+                elif query_lower in display_name.lower():
+                    score = 40
+
+                results.append((location, display_name, param, score))
+
+        # Sort by score
+        results.sort(key=lambda x: x[3], reverse=True)
+
+        # Remove duplicates
+        seen = set()
+        unique_results = []
+        for item in results:
+            key = (item[0], item[1])
+            if key not in seen:
+                seen.add(key)
+                unique_results.append(item[:3])
+
+        if not unique_results:
+            html = f"<div style='padding: 10px; background: #fff3cd; border: 1px solid #ffc107; border-radius: 5px;'>"
+            html += f"<strong>No results found for '{query}'</strong><br>"
+            html += f"<span style='color: #666; font-size: 0.9em;'>Try: learning, optimizer, fp8, vram, epochs, batch, cache, sample, zimage, turbo</span>"
+            html += "</div>"
+            return gr.Row(visible=True), html
+
+        # Format results
+        html = f"<div style='padding: 10px; background: #f0f0f0; border-radius: 5px;'>"
+        html += f"<strong>Found {len(unique_results)} result(s) for '{query}':</strong><br><br>"
+
+        unique_panels = set()
+        for location, display_name, param in unique_results:
+            panel_name = location.split('→')[0].strip()
+            unique_panels.add(panel_name)
+
+        html += f"<div style='margin-bottom: 10px; padding: 8px; background: #d4edda; border: 1px solid #c3e6cb; border-radius: 3px; color: #155724;'>"
+        html += f"✅ <strong>Opening {len(unique_panels)} relevant panel{'s' if len(unique_panels) > 1 else ''}:</strong> "
+        html += ", ".join(sorted(unique_panels))
+        html += "</div>"
+
+        for location, display_name, param in unique_results[:10]:
+            html += f"<div style='margin-bottom: 8px; padding: 8px; background: white; border-radius: 3px; border-left: 3px solid #007bff;'>"
+            html += f"📍 <strong>{location}</strong><br>"
+            html += f"<span style='margin-left: 20px; color: #333;'>→ {display_name}</span>"
+            html += f"</div>"
+
+        if len(unique_results) > 10:
+            html += f"<div style='color: #666; margin-top: 5px;'>... and {len(unique_results) - 10} more results</div>"
+
+        html += "</div>"
+
+        return gr.Row(visible=True), html
+
+    # Modified search functionality to open relevant panels
+    def search_and_open_panels(query):
+        if not query or len(query.strip()) < 1:
+            accordion_states = [gr.Accordion(open=False) for _ in accordions]
+            return [gr.Row(visible=False), "", gr.Button(value="Open All Panels"), gr.Button(value="Open All Panels"), "closed"] + accordion_states
+
+        results_row, results_html = search_settings(query)
+
+        panels_to_open = set()
+
+        panel_map = {
+            "Accelerate launch Settings": 0,
+            "Save Models and Resume Training Settings": 1,
+            "Z-Image Training Dataset": 2,
+            "Z-Image Model Settings": 3,
+            "Torch Compile Settings": 4,
+            "Flow Matching and Timestep Settings": 5,
+            "Training Settings": 6,
+            "Sample Generation Settings": 7,
+            "Caching Settings": 8,
+            "Learning Rate, Optimizer and Scheduler Settings": 9,
+            "LoRA Settings": 10,
+            "Advanced Settings": 11,
+            "Metadata Settings": 12,
+            "HuggingFace Settings": 13,
+        }
+
+        import re
+        panel_pattern = r'📍 <strong>([^<]+)</strong>'
+        matches = re.findall(panel_pattern, results_html)
+
+        for match in matches:
+            base_panel = match.split('→')[0].strip()
+            if base_panel in panel_map:
+                panels_to_open.add(panel_map[base_panel])
+
+        accordion_states = []
+        for i in range(len(accordions)):
+            if i in panels_to_open:
+                accordion_states.append(gr.Accordion(open=True))
+            else:
+                accordion_states.append(gr.Accordion(open=False))
+
+        if panels_to_open:
+            button_text = f"Reset Search ({len(panels_to_open)} panel{'s' if len(panels_to_open) > 1 else ''} filtered)"
+            state = "search"
+        else:
+            button_text = "Open All Panels"
+            state = "closed"
+
+        return [gr.Row(visible=False), "", gr.Button(value=button_text), gr.Button(value=button_text), state] + accordion_states
+
+    search_input.change(
+        search_and_open_panels,
+        inputs=[search_input],
+        outputs=[search_results_row, search_results, toggle_all_btn, toggle_all_btn_bottom, panels_state] + accordions,
+        show_progress=False,
+    )
+
+    # Add handler for unified toggle button
+    def toggle_all_panels(current_state):
+        if current_state == "search":
+            new_state = "closed"
+            new_button_text = "Open All Panels"
+            accordion_states = [gr.Accordion(open=False) for _ in accordions]
+            search_value = ""
+            results_visibility = gr.Row(visible=False)
+            results_content = ""
+        elif current_state == "closed":
+            new_state = "open"
+            new_button_text = "Hide All Panels"
+            accordion_states = [gr.Accordion(open=True) for _ in accordions]
+            search_value = gr.Textbox(value="")
+            results_visibility = gr.Row(visible=False)
+            results_content = ""
+        else:
+            new_state = "closed"
+            new_button_text = "Open All Panels"
+            accordion_states = [gr.Accordion(open=False) for _ in accordions]
+            search_value = gr.Textbox(value="")
+            results_visibility = gr.Row(visible=False)
+            results_content = ""
+
+        return [new_state, gr.Button(value=new_button_text), gr.Button(value=new_button_text), search_value, results_visibility, results_content] + accordion_states
+
+    toggle_all_btn.click(
+        toggle_all_panels,
+        inputs=[panels_state],
+        outputs=[panels_state, toggle_all_btn, toggle_all_btn_bottom, search_input, search_results_row, search_results] + accordions,
+        show_progress=False,
+    )
+
+    toggle_all_btn_bottom.click(
+        toggle_all_panels,
+        inputs=[panels_state],
+        outputs=[panels_state, toggle_all_btn, toggle_all_btn_bottom, search_input, search_results_row, search_results] + accordions,
+        show_progress=False,
+    )
+
+    configuration.button_open_config.click(
+        zimage_gui_actions,
+        inputs=[gr.Textbox(value="open_configuration", visible=False), dummy_true, configuration.config_file_name, dummy_headless, dummy_false] + settings_list,
+        outputs=[configuration.config_file_name, configuration.config_status] + settings_list,
+        show_progress=False,
+    )
+    configuration.button_load_config.click(
+        zimage_gui_actions,
+        inputs=[gr.Textbox(value="open_configuration", visible=False), dummy_false, configuration.config_file_name, dummy_headless, dummy_false] + settings_list,
+        outputs=[configuration.config_file_name, configuration.config_status] + settings_list,
+        show_progress=False,
+        queue=False,
+    )
+    configuration.button_save_config.click(
+        zimage_gui_actions,
+        inputs=[gr.Textbox(value="save_configuration", visible=False), dummy_false, configuration.config_file_name, dummy_headless, dummy_false] + settings_list,
+        outputs=[configuration.config_file_name, configuration.config_status],
+        show_progress=False,
+        queue=False,
+    )
+
+    button_print.click(
+        zimage_gui_actions,
+        inputs=[gr.Textbox(value="train_model", visible=False), dummy_false, configuration.config_file_name, dummy_headless, dummy_true] + settings_list,
+        show_progress=False,
+    )
+
+    executor.button_run.click(
+        zimage_gui_actions,
+        inputs=[gr.Textbox(value="train_model", visible=False), dummy_false, configuration.config_file_name, dummy_headless, dummy_false] + settings_list,
+        outputs=[executor.button_run, executor.stop_row, executor.button_stop_training, executor.training_status, run_state],
+        show_progress=False,
+    )
+
+    executor.button_stop_training.click(
+        executor.kill_command,
+        inputs=[],
+        outputs=[executor.button_run, executor.stop_row, executor.button_stop_training, executor.training_status],
+        js="() => { if (confirm('Stop training/caching?')) { return []; } else { throw new Error('Cancelled'); } }",
+    )
+
+    run_state.change(
+        fn=executor.wait_for_training_to_end,
+        outputs=[executor.button_run, executor.stop_row, executor.button_stop_training, executor.training_status],
+        show_progress=False,
+    )

SECourses_Musubi_Trainer/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+testpaths = tests

SECourses_Musubi_Trainer/qwen_image_defaults.toml

@@ -0,0 +1,252 @@
+# Qwen Image Training - Optimal Defaults Configuration
+# This file contains the recommended default values for Qwen Image training
+# Supports both LoRA (parameter-efficient) and DreamBooth (full fine-tuning) modes
+# Based on documentation examples and best practices
+
+# Training Mode Selection
+training_mode = "LoRA Training"  # Options: "LoRA Training" (efficient, lower VRAM) or "DreamBooth Fine-Tuning" (higher VRAM)
+
+# Model Settings - REQUIRED FIELDS MUST BE SET BY USER
+dit = ""  # REQUIRED: Path to DiT checkpoint (qwen_image_bf16.safetensors)
+vae = ""  # REQUIRED: Path to VAE checkpoint (diffusion_pytorch_model.safetensors)
+text_encoder = ""  # REQUIRED: Path to Qwen2.5-VL checkpoint
+dataset_config = ""  # Path to dataset TOML configuration (required if using "Use TOML File" mode)
+dataset_config_mode = "Generate from Folder Structure"  # Default to auto-generate from folder structure
+
+# Folder Structure Settings (used when dataset_config_mode = "Generate from Folder Structure")
+parent_folder_path = ""  # REQUIRED when using folder structure mode: Path to parent folder containing training images
+dataset_resolution_width = 1328  # Target width for training images
+dataset_resolution_height = 1328  # Target height for training images
+dataset_caption_extension = ".txt"  # Extension for caption files
+create_missing_captions = true  # Auto-create empty captions for images without caption files
+caption_strategy = "folder_name"  # How to handle missing captions: "folder_name" or "empty"
+dataset_batch_size = 1  # Batch size for dataset processing
+dataset_enable_bucket = false  # Enable bucketing for variable aspect ratios
+dataset_bucket_no_upscale = false  # Prevent upscaling in bucket mode
+dataset_cache_directory = "cache_dir"  # Directory for caching processed data
+dataset_control_directory = "edit_images"  # [EDIT MODE] Directory name for control/reference images (only used when edit=true)
+dataset_qwen_image_edit_no_resize_control = false  # [EDIT MODE] Keep control images at original size. Only used when edit=true. Cannot be used with control resolution settings
+dataset_qwen_image_edit_control_resolution_width = 1328  # [EDIT MODE] Control image width. 0=same as training images, 1024=official Qwen default, 1328=optimal for Qwen models. Only when edit=true
+dataset_qwen_image_edit_control_resolution_height = 1328  # [EDIT MODE] Control image height. 0=same as training images, 1024=official Qwen default, 1328=optimal for Qwen models. Only when edit=true
+auto_generate_black_control_images = false  # [EDIT MODE] Auto-generate pitch black PNG control images with same filenames as training images. Uses control resolution settings
+generated_toml_path = ""  # Path where generated TOML will be saved (auto-set)
+
+dit_dtype = "bfloat16"  # HARDCODED: Must be bfloat16 for Qwen Image
+dit_in_channels = 16  # [DO NOT CHANGE] VAE latent channel count. MUST be 16 for Qwen (different from SD's 4). Changing breaks training!
+# num_layers = 60  # [ADVANCED] Number of DiT transformer layers. Leave commented out for auto-detection (60 for standard Qwen). Uncomment and change value only for custom/pruned models
+text_encoder_dtype = "bfloat16"  # Data type for Qwen2.5-VL. float16=faster, bfloat16=better precision
+vae_dtype = "bfloat16"       # Data type for VAE. bfloat16=Qwen Image default, float16=faster
+
+# VAE Optimization Settings
+vae_tiling = false           # Enable spatial tiling to reduce VRAM usage during VAE operations (supported in Qwen Image)
+vae_chunk_size = 0           # 0 = auto/disabled. Higher = faster but more VRAM
+vae_spatial_tile_sample_min_size = 0  # 0 = disabled. 256 = typical. Auto-enables vae_tiling if set
+
+fp8_vl = false  # Enable for lower VRAM GPUs. Reduces VRAM with minimal quality loss
+fp8_base = false  # Optional: FP8 for DiT model, reduces VRAM usage
+fp8_scaled = false  # REQUIRED when fp8_base=true, better quality than standard FP8
+blocks_to_swap = 0             # 0 = disabled. Max 59 (Qwen has 60 blocks). Higher values save more VRAM but require more RAM
+
+# Additional Model Settings  
+guidance_scale = 1.0          # Classifier-free guidance scale. 1.0 = default, higher = stronger prompt adherence
+img_in_txt_in_offloading = false  # Memory optimization for mixed image-text inputs
+
+# Model Variant Selection
+# Upstream musubi-tuner now supports:
+# - original (text-to-image)
+# - edit-2509 (Edit Plus, multiple control images)
+# - edit-2511 (Edit-2511, multiple control images)
+# NOTE: The older base "edit" variant is intentionally removed from this GUI.
+model_version = "original"  # Options: "original", "edit-2509", "edit-2511"
+
+faster_model_loading = false  # Faster Model Loading: Disables numpy memmap for faster model loading. Uses more RAM but speeds up loading, especially useful for RunPod and similar environments
+use_pinned_memory_for_block_swap = false  # Use Pinned Memory for Block Swapping: Uses more system RAM but speeds up training. The speed up maybe significant depending on system settings. To work, go to Advanced Graphics settings in System > Display > Graphics as in tutorial video and disable Hardware-Accelerated GPU Scheduling and restart your PC. Only effective when blocks_to_swap > 0
+block_swap_h2d_only = false  # LoRA only; requires blocks_to_swap > 0 and gradient_checkpointing
+block_swap_ring_size = 2  # 2 overlaps transfer/compute; 1 minimizes VRAM
+
+# Flow Matching Settings
+timestep_sampling = "qwen_shift"  # Use Qwen-specific resolution-aware sampling
+discrete_flow_shift = 2.2  # Discrete flow shift for training (used with 'shift' method)
+flow_shift = 7.0  # [ADVANCED] Noise schedule control. 7.0 is optimal. Higher (8-10)=smoother/slower, Lower (5-6)=faster/unstable
+weighting_scheme = "none"  # Set to "mode" if you want to use mode_scale
+logit_mean = 0.0
+logit_std = 1.0
+mode_scale = 1.0  # Optimized for Qwen (lower than SD3's 1.29 for better stability)
+
+# Advanced Timestep Parameters (usually leave as defaults)
+sigmoid_scale = 1.0          # Scale factor for sigmoid timestep sampling. Only used with 'sigmoid' method
+min_timestep = 0            # 0 = no minimum constraint. 0-999 = constrain minimum timestep
+max_timestep = 1000         # Maximum timestep value. 1000 = default (full range). 1-1000 = constrain maximum timestep 
+preserve_distribution_shape = false  # Preserve original distribution when using min/max constraints
+
+# Advanced Timestep Settings
+num_timestep_buckets = 0  # 0 = disabled. 4-10 = bucketed sampling for uniform timestep distribution
+
+# Debugging
+show_timesteps = ""
+
+# Training Settings
+sdpa = true
+flash_attn = false
+sage_attn = false
+xformers = false
+flash3 = false               # EXPERIMENTAL: FlashAttention 3, not confirmed to work with Qwen Image
+split_attn = false           # REQUIRED if using flash_attn/sage_attn/xformers/flash3
+use_legacy_sdpa = false      # Force the older PyTorch SDPA path instead of automatic verified acceleration
+max_train_steps = 90000
+max_train_epochs = 200
+max_data_loader_n_workers = 2
+persistent_data_loader_workers = true
+seed = 99
+gradient_checkpointing = true
+gradient_accumulation_steps = 1
+full_bf16 = false  # [EXPERIMENTAL] Store gradients in BF16. Requires mixed_precision='bf16'; monitor loss for instability.
+full_fp16 = false  # [EXPERIMENTAL] Store gradients in FP16. Saves ~30% VRAM but risk of underflow. Use full_bf16 instead if possible
+
+# Optimizer Settings
+optimizer_type = "adamw8bit"
+optimizer_args = []  # Additional optimizer arguments like ["weight_decay=0.01", "betas=0.9,0.999"]
+learning_rate = 5e-5  # RECOMMENDED: Changed from 1e-4 to 5e-5 per official documentation update
+max_grad_norm = 1.0
+fused_backward_pass = true  # [DREAMBOOT EXCLUSIVE] Advanced memory optimization for DreamBooth fine-tuning. Automatically enabled for DreamBooth mode, disabled for LoRA mode. Requires AdaFactor optimizer. Reduces VRAM during gradient computation
+lr_scheduler = "constant"
+lr_warmup_steps = 0  # 0 = no warmup. Integer = steps, float <1 = ratio of total steps
+lr_decay_steps = 0   # 0 = no decay. Integer = steps, float <1 = ratio of total steps
+lr_scheduler_num_cycles = 1
+lr_scheduler_power = 1.0
+lr_scheduler_timescale = 0      # 0 = auto (uses warmup steps). Advanced parameter
+lr_scheduler_min_lr_ratio = 0.0  # 0.0 = can reach zero LR. 0.1 = minimum 10% of initial LR
+lr_scheduler_type = ""
+lr_scheduler_args = []  # Additional scheduler arguments like ["T_max=100"]
+
+# Network Settings (LoRA Mode Only - Ignored in DreamBooth Mode)
+no_metadata = false
+network_weights = ""  # [LORA ONLY] Path to pretrained LoRA weights to continue training
+network_module = "networks.lora_qwen_image"  # [AUTO-SET] Set to empty for DreamBooth, networks.lora_qwen_image for LoRA
+network_dim = 128  # [LORA ONLY] Network dimension/rank. RECOMMENDED: 16 per official documentation
+network_alpha = 128.0  # [LORA ONLY] Alpha for scaling. RECOMMENDED: Equal to network_dim for best results
+network_dropout = 0.0  # [LORA ONLY] Dropout rate. 0.0 = no dropout, 0.1 = 10% dropout for regularization
+# Additional network arguments. Supported options:
+# - loraplus_lr_ratio=N: Enables LoRA+ with learning rate ratio for "up" matrices (e.g., "loraplus_lr_ratio=4")
+# - exclude_patterns=["regex"]: Regex patterns to exclude modules from LoRA (default excludes ".*(_mod_).*")
+# - include_patterns=["regex"]: Regex patterns to re-include excluded modules
+# - verbose=true: Print detailed info about which modules are being trained
+# Example: ["loraplus_lr_ratio=4", "verbose=true"]
+network_args = []
+training_comment = ""
+dim_from_weights = false
+scale_weight_norms = 0.0  # 0.0 = disabled. 1.0+ = scale weights to prevent exploding gradients
+base_weights = ""  # Path to LoRA weights to merge before training (empty = none)
+base_weights_multiplier = 1.0  # Strength multiplier for base weights (1.0 = full strength)
+
+# Save/Load Settings
+output_dir = ""
+output_name = "my-qwen-lora"  # Base filename without .safetensors extension - musubi auto-adds it
+resume = ""
+save_precision = "bf16"  # LoRA output dtype; BF16 keeps files about half the size of FP32
+save_every_n_epochs = 10
+save_every_n_steps = 0        # 0 = disabled. Positive integer = save every N steps
+save_last_n_epochs = 0       # 0 = keep all. Positive integer = keep only last N epoch checkpoints
+save_last_n_epochs_state = 0 # 0 = keep all. Positive integer = keep only last N epoch states
+save_last_n_steps = 0        # 0 = keep all. Positive integer = keep only last N step checkpoints
+save_last_n_steps_state = 0  # 0 = keep all. Positive integer = keep only last N step states
+save_state = false
+save_state_on_train_end = false
+mem_eff_save = false  # [DreamBooth Only] Dramatically reduces RAM usage during checkpoint saving (from ~40GB to ~20GB). Essential for low-RAM systems doing DreamBooth fine-tuning. Ignored for LoRA training. NOTE: Optimizer state saves still require full RAM
+
+# Caching Settings - Latents
+caching_latent_device = "cuda"
+caching_latent_batch_size = 4
+caching_latent_num_workers = 8
+caching_latent_skip_existing = true
+caching_latent_keep_cache = true
+caching_latent_debug_mode = ""
+caching_latent_console_width = 80
+caching_latent_console_back = ""
+caching_latent_console_num_images = 0  # 0 = no limit. Positive integer = max images in debug console
+
+# Caching Settings - Text Encoder
+caching_teo_text_encoder = ""
+caching_teo_device = "cuda"
+caching_teo_fp8_vl = false
+caching_teo_batch_size = 16
+caching_teo_num_workers = 8
+caching_teo_skip_existing = true
+caching_teo_keep_cache = true
+
+# Torch compile (optional)
+compile = false
+compile_resident_blocks_only = true  # Recommended: compile resident Qwen blocks; swapped blocks remain eager
+compile_backend = "inductor"
+compile_mode = "default"
+compile_dynamic = "auto"         # "auto" | "true" | "false"
+compile_fullgraph = false
+compile_cache_size_limit = 0     # 0 = use PyTorch default
+
+# Accelerate Launch Settings
+mixed_precision = "bf16"    # RECOMMENDED for Qwen Image. fp16 may cause instability, fp8 not supported
+multi_gpu = false           # Enable distributed multi-GPU training
+gpu_ids = "0"                # GPU IDs for distributed training (e.g., "0,1,2,3")
+num_processes = 1           # Number of processes for distributed training
+num_machines = 1            # Number of machines for distributed training
+num_cpu_threads_per_process = 2  # CPU threads per process
+main_process_port = 0       # Port for distributed training communication (0 = auto)
+dynamo_backend = "no"       # no = disabled (recommended). Use inductor for PyTorch 2.0+ optimization
+dynamo_mode = ""            # Empty = default. Options: "default", "reduce-overhead", "max-autotune"
+dynamo_use_fullgraph = false   # Use fullgraph mode for dynamo
+dynamo_use_dynamic = false     # Use dynamic mode for dynamo
+extra_accelerate_launch_args = ""  # Additional accelerate launch arguments
+
+# Logging Settings
+logging_dir = ""
+# log_with = ""  # Leave commented out or set to specific logger like "tensorboard"
+log_prefix = ""
+log_tracker_name = ""
+wandb_run_name = ""
+log_tracker_config = ""
+wandb_api_key = ""
+log_config = false
+
+# DDP Settings
+ddp_timeout = 0  # 0 = use default (30min). Positive integer = timeout in minutes for distributed training
+ddp_gradient_as_bucket_view = false
+ddp_static_graph = false
+
+# Sample Generation
+# Generate sample images during training to monitor progress
+sample_every_n_steps = 0   # 0 = disabled. 100-500 recommended for step-based sampling
+sample_every_n_epochs = 0  # 0 = disabled. 1 = generate samples every epoch (recommended)
+sample_at_first = false
+sample_prompts = ""  # Path to text file with prompts for sample generation
+disable_prompt_enhancement = false  # true = use prompt file exactly as written (no auto-added defaults)
+
+# Default Sample Parameters
+# These will be automatically added to prompts that don't specify them
+# An enhanced prompt file will be saved to your output directory
+sample_width = 1328                # Default width (Qwen optimal: 1328)
+sample_height = 1328               # Default height (Qwen optimal: 1328)
+sample_steps = 20                  # Number of denoising steps
+sample_guidance_scale = 1.0        # Legacy/compat guidance flag (--g). Qwen training sampling primarily uses --l.
+sample_seed = 99                   # Random seed (-1 = random each time)
+sample_discrete_flow_shift = 2.2     # Discrete flow shift (0 = use training value, 2.2 = Qwen optimal)
+sample_cfg_scale = 4.0             # Primary CFG scale (--l) for Qwen training samples. Set 1.0 to disable CFG.
+sample_negative_prompt = ""        # Default negative prompt for all samples
+
+# Metadata Settings
+metadata_author = ""
+metadata_description = ""
+metadata_license = ""
+metadata_tags = ""
+metadata_title = ""
+metadata_reso = ""
+metadata_arch = ""
+
+# HuggingFace Settings
+huggingface_repo_id = ""
+huggingface_token = ""
+huggingface_repo_type = ""
+huggingface_repo_visibility = ""
+huggingface_path_in_repo = ""
+save_state_to_huggingface = false
+resume_from_huggingface = ""
+async_upload = false

SECourses_Musubi_Trainer/sitecustomize.py

@@ -0,0 +1,3 @@
+"""Apply project-wide Python compatibility hooks in launched worker processes."""
+
+import musubi_tuner_gui.torch_compat  # noqa: F401

SECourses_Musubi_Trainer/tests/test_automagic_gui.py

@@ -0,0 +1,75 @@
+import gradio as gr
+import pytest
+
+from musubi_tuner_gui.class_optimizer_and_scheduler import OptimizerAndScheduler
+from musubi_tuner_gui.optimizer_catalog import (
+    AUTOMAGIC_OPTIMIZER_CHOICES,
+    add_automagic_optimizer_choices,
+    optimizer_guidance,
+)
+from musubi_tuner_gui.qwen_image_lora_gui import QwenImageOptimizerSettings
+
+
+def dropdown_values(component):
+    return [value for _, value in component.choices]
+
+
+def test_add_automagic_choices_preserves_defaults_and_avoids_duplicates():
+    choices = add_automagic_optimizer_choices(["AdamW", "automagic"])
+
+    assert choices[:2] == ["AdamW", "automagic"]
+    assert sum(choice.casefold() == "automagic" for choice in choices) == 1
+    assert {choice.casefold() for choice in choices} >= {choice.casefold() for choice in AUTOMAGIC_OPTIMIZER_CHOICES}
+
+
+@pytest.mark.parametrize("optimizer_type", AUTOMAGIC_OPTIMIZER_CHOICES)
+def test_automagic_guidance_explains_adaptive_lr_and_scheduler(optimizer_type):
+    guidance = optimizer_guidance(optimizer_type)
+
+    expected_version = "v1" if optimizer_type == "Automagic" else optimizer_type.replace("Automagic", "v")
+    assert expected_version in guidance
+    assert "starting rate" in guidance
+    assert "scheduler" in guidance.casefold()
+    assert "Fused Backward Pass" in guidance
+    assert "Adafactor-only preset arguments" in guidance
+    assert "ignored automatically" in guidance
+    assert "block swapping" in guidance.casefold()
+
+
+def test_automagic2_guidance_explains_hard_compatibility_limits():
+    guidance = optimizer_guidance("Automagic2")
+
+    for expected in ("single-process", "Gradient Accumulation Steps = 1", "Max Gradient Norm = 0", "fp16"):
+        assert expected in guidance
+
+
+def test_automagic3_guidance_explains_automatic_safe_mode():
+    guidance = optimizer_guidance("Automagic3")
+
+    assert "automatically" in guidance
+    assert "fused=False" in guidance
+    assert "fused=True" in guidance
+
+
+@pytest.mark.parametrize(
+    ("component_factory", "selected"),
+    [
+        (lambda: OptimizerAndScheduler(config={"optimizer_type": "Automagic3"}), "Automagic3"),
+        (lambda: QwenImageOptimizerSettings(False, {"optimizer_type": "Automagic2"}), "Automagic2"),
+    ],
+)
+def test_all_optimizer_component_variants_expose_choices_and_initial_guidance(component_factory, selected):
+    with gr.Blocks():
+        component = component_factory()
+
+    values = dropdown_values(component.optimizer_type)
+    assert set(AUTOMAGIC_OPTIMIZER_CHOICES) <= set(values)
+    expected_version = "v1" if selected == "Automagic" else selected.replace("Automagic", "v")
+    assert expected_version in component.optimizer_guidance.value
+
+
+def test_custom_optimizer_guidance_is_explicit():
+    guidance = optimizer_guidance("example.CustomOptimizer")
+
+    assert "Custom optimizer" in guidance
+    assert "example.CustomOptimizer" in guidance

SECourses_Musubi_Trainer/tests/test_full_finetune_gui.py

@@ -0,0 +1,875 @@
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+from types import SimpleNamespace
+
+import gradio as gr
+import pytest
+import toml
+
+from musubi_tuner_gui import (
+    flux2_lora_gui,
+    flux_klein_lora_gui,
+    flux_lora_gui,
+    modern_image_lora_gui,
+    qwen_image_lora_gui,
+    wan_lora_gui,
+    zimage_lora_gui,
+)
+from musubi_tuner_gui.full_finetune_gui import (
+    FULL_FINE_TUNING_MODE,
+    FULL_FINE_TUNING_NETWORK_KEYS,
+    LORA_TRAINING_MODE,
+    normalize_image_training_parameters,
+    training_mode_runtime_exclusions,
+)
+from musubi_tuner_gui.modern_image_lora_gui import (
+    ModernImageWorkflow,
+    _architecture_defaults,
+    _build_workflow_script,
+    get_architecture,
+    prepare_modern_image_workflow,
+)
+from musubi_tuner_gui.class_tab_config_manager import TabConfigManager
+
+
+class _FakeExecutor:
+    def __init__(self):
+        self.calls = []
+
+    def execute_command(self, **kwargs):
+        self.calls.append(kwargs)
+
+
+def _touch(path: Path, contents: str = "placeholder") -> str:
+    path.write_text(contents, encoding="utf-8")
+    return str(path)
+
+
+def _ordered_parameters(keys: list[str], values: dict[str, object]) -> list[tuple[str, object]]:
+    return [(key, values.get(key)) for key in keys]
+
+
+def _base_full_values(tmp_path: Path, keys: list[str], *, model_version: str) -> dict[str, object]:
+    dataset = _touch(tmp_path / "dataset.toml", "[[datasets]]\nimage_directory = 'images'\n")
+    values = {key: None for key in keys}
+    values.update(
+        {
+            "training_mode": FULL_FINE_TUNING_MODE,
+            "mixed_precision": "bf16",
+            "num_cpu_threads_per_process": 1,
+            "num_processes": 1,
+            "num_machines": 1,
+            "multi_gpu": False,
+            "gpu_ids": "0",
+            "dynamo_backend": "no",
+            "dataset_config_mode": "Use TOML File",
+            "dataset_config": dataset,
+            "model_version": model_version,
+            "dit": _touch(tmp_path / "dit.safetensors"),
+            "vae": _touch(tmp_path / "vae.safetensors"),
+            "text_encoder": _touch(tmp_path / "text_encoder.safetensors"),
+            "fp8_base": False,
+            "fp8_scaled": False,
+            "blocks_to_swap": 0,
+            "sdpa": True,
+            "use_legacy_sdpa": True,
+            "gradient_checkpointing": True,
+            "gradient_accumulation_steps": 1,
+            "full_bf16": True,
+            "full_fp16": False,
+            "fused_backward_pass": True,
+            "block_swap_optimizer_patch_params": False,
+            "optimizer_type": "AdaFactor",
+            "optimizer_args": [],
+            "learning_rate": 1e-5,
+            "max_grad_norm": 0,
+            "lr_scheduler": "constant",
+            "network_module": "networks.lora_flux_2",
+            "network_dim": 32,
+            "network_alpha": 32,
+            "network_dropout": 0,
+            "network_args": [],
+            "output_dir": str(tmp_path / "output"),
+            "output_name": "full-smoke",
+            "save_precision": "bf16",
+            "save_every_n_steps": 1,
+            "caching_latent_skip_existing": False,
+            "caching_teo_skip_existing": False,
+        }
+    )
+    return values
+
+
+def test_shared_full_finetune_rules_remove_quantized_base_and_align_precision():
+    parameters = [
+        ("training_mode", "DreamBooth Fine-Tuning"),
+        ("mixed_precision", "bf16"),
+        ("full_bf16", True),
+        ("full_fp16", False),
+        ("fp8_base", True),
+        ("fp8_scaled", True),
+        ("block_swap_h2d_only", True),
+        ("dit_dtype", "float16"),
+        ("save_precision", "fp32"),
+        ("blocks_to_swap", 8),
+        ("num_processes", 1),
+        ("gradient_accumulation_steps", 1),
+        ("optimizer_type", "AdaFactor"),
+        ("fused_backward_pass", True),
+        ("block_swap_optimizer_patch_params", False),
+    ]
+
+    values, normalized, full_finetune = normalize_image_training_parameters(parameters)
+
+    assert full_finetune is True
+    assert values["training_mode"] == FULL_FINE_TUNING_MODE
+    assert values["fp8_base"] is False
+    assert values["fp8_scaled"] is False
+    assert values["block_swap_h2d_only"] is False
+    assert values["dit_dtype"] == "bfloat16"
+    assert values["save_precision"] == "bf16"
+    assert dict(normalized) == values
+
+
+@pytest.mark.parametrize(
+    "overrides, message",
+    [
+        ({"full_fp16": True}, "Full FP16"),
+        ({"num_processes": 2, "blocks_to_swap": 1}, "multi-process"),
+        ({"optimizer_type": "AdamW", "fused_backward_pass": True}, "Adafactor"),
+        ({"gradient_accumulation_steps": 2, "fused_backward_pass": True}, "accumulation"),
+        ({"blocks_to_swap": 0, "block_swap_optimizer_patch_params": True}, "blocks_to_swap"),
+        (
+            {"blocks_to_swap": 1, "optimizer_type": "Automagic2", "block_swap_optimizer_patch_params": True},
+            "Automagic3",
+        ),
+    ],
+)
+def test_shared_full_finetune_rules_reject_unsupported_combinations(overrides, message):
+    values = {
+        "training_mode": FULL_FINE_TUNING_MODE,
+        "mixed_precision": "bf16",
+        "full_bf16": True,
+        "full_fp16": False,
+        "blocks_to_swap": 0,
+        "num_processes": 1,
+        "gradient_accumulation_steps": 1,
+        "optimizer_type": "AdaFactor",
+        "fused_backward_pass": False,
+        "block_swap_optimizer_patch_params": False,
+    }
+    values.update(overrides)
+
+    with pytest.raises(ValueError, match=message):
+        normalize_image_training_parameters(list(values.items()))
+
+
+@pytest.mark.parametrize("optimizer_type", ["Automagic", "Automagic3"])
+def test_full_finetune_block_swap_patch_accepts_non_fused_automagic(optimizer_type):
+    values = {
+        "training_mode": FULL_FINE_TUNING_MODE,
+        "mixed_precision": "bf16",
+        "full_bf16": True,
+        "full_fp16": False,
+        "blocks_to_swap": 1,
+        "num_processes": 1,
+        "gradient_accumulation_steps": 1,
+        "optimizer_type": optimizer_type,
+        "fused_backward_pass": False,
+        "block_swap_optimizer_patch_params": True,
+    }
+
+    normalized_values, normalized, full_finetune = normalize_image_training_parameters(list(values.items()))
+
+    assert full_finetune is True
+    assert normalized_values["block_swap_optimizer_patch_params"] is True
+    assert dict(normalized)["block_swap_optimizer_patch_params"] is True
+
+
+def test_training_mode_exclusions_keep_runtime_configs_mode_correct():
+    full = training_mode_runtime_exclusions(FULL_FINE_TUNING_MODE)
+    lora = training_mode_runtime_exclusions(LORA_TRAINING_MODE)
+
+    assert {"network_module", "network_dim", "network_alpha", "full_fp16"} <= full
+    assert {"fused_backward_pass", "block_swap_optimizer_patch_params", "mem_eff_save"} <= lora
+    assert "network_module" not in lora
+
+
+def test_qwen_dreambooth_preview_normalizes_full_model_runtime_config(tmp_path: Path, monkeypatch):
+    dataset = tmp_path / "dataset.toml"
+    dataset.write_text("[[datasets]]\nimage_directory = 'images'\n", encoding="utf-8")
+    dit = _touch(tmp_path / "dit.safetensors")
+    vae = _touch(tmp_path / "vae.safetensors")
+    text_encoder = _touch(tmp_path / "text_encoder.safetensors")
+    captured: dict[str, object] = {}
+
+    def capture_preview(command, config_path):
+        captured["command"] = command
+        captured["config"] = toml.load(config_path)
+
+    monkeypatch.setattr(qwen_image_lora_gui, "print_command_and_toml", capture_preview)
+    parameters = [
+        ("training_mode", "DreamBooth Fine-Tuning"),
+        ("dataset_config_mode", "Use TOML File"),
+        ("dataset_config", str(dataset)),
+        ("model_version", "original"),
+        ("dit", dit),
+        ("vae", vae),
+        ("text_encoder", text_encoder),
+        ("output_dir", str(tmp_path / "output")),
+        ("output_name", "qwen-full-preview"),
+        ("mixed_precision", "bf16"),
+        ("full_bf16", True),
+        ("full_fp16", False),
+        ("save_precision", "fp32"),
+        ("dit_dtype", "float16"),
+        ("fp8_base", True),
+        ("fp8_scaled", True),
+        ("block_swap_h2d_only", True),
+        ("block_swap_ring_size", 2),
+        ("blocks_to_swap", 6),
+        ("gradient_checkpointing", True),
+        ("gradient_accumulation_steps", 1),
+        ("num_processes", 1),
+        ("num_machines", 1),
+        ("num_cpu_threads_per_process", 1),
+        ("gpu_ids", "0"),
+        ("dynamo_backend", "no"),
+        ("optimizer_type", "Automagic3"),
+        ("optimizer_args", ["scale_parameter=False", "relative_step=False"]),
+        ("fused_backward_pass", False),
+        ("block_swap_optimizer_patch_params", False),
+        ("network_module", "networks.lora_qwen_image"),
+        ("network_dim", 32),
+        ("network_alpha", 32),
+        ("network_dropout", 0),
+        ("network_args", []),
+        ("sdpa", True),
+        ("additional_parameters", ""),
+        ("mem_eff_save", True),
+    ]
+
+    qwen_image_lora_gui.train_qwen_image_model(True, True, parameters)
+
+    command = captured["command"]
+    config = captured["config"]
+    assert any(str(part).endswith("qwen_image_train.py") for part in command)
+    assert not any(str(part).endswith("qwen_image_train_network.py") for part in command)
+    assert config.get("fp8_base", False) is False
+    assert config.get("fp8_scaled", False) is False
+    assert config.get("dit_dtype", "bfloat16") == "bfloat16"
+    assert config["save_precision"] == "bf16"
+    assert config["optimizer_type"] == "Automagic3"
+    assert config["mem_eff_save"] is True
+    assert not FULL_FINE_TUNING_NETWORK_KEYS.intersection(config)
+    assert "block_swap_h2d_only" not in config
+
+
+def test_shipped_qwen_default_enables_resident_compile():
+    defaults_path = Path(__file__).resolve().parents[1] / "qwen_image_defaults.toml"
+
+    assert toml.load(defaults_path)["compile_resident_blocks_only"] is True
+
+
+@pytest.mark.parametrize(
+    ("config", "expected"),
+    [
+        ({}, True),
+        ({"compile_resident_blocks_only": True}, True),
+        ({"compile_resident_blocks_only": False}, False),
+    ],
+)
+def test_qwen_resident_compile_default_preserves_config_override(config, expected):
+    with gr.Blocks():
+        model = qwen_image_lora_gui.QwenImageModel(headless=True, config=config)
+
+    assert model.compile_resident_blocks_only.value is expected
+
+
+def test_qwen_resident_compile_callback_order_and_search_mapping_are_wired():
+    parameter_names = list(inspect.signature(qwen_image_lora_gui.qwen_image_gui_actions).parameters)
+    compile_start = parameter_names.index("compile")
+    assert parameter_names[compile_start : compile_start + 7] == [
+        "compile",
+        "compile_resident_blocks_only",
+        "compile_backend",
+        "compile_mode",
+        "compile_dynamic",
+        "compile_fullgraph",
+        "compile_cache_size_limit",
+    ]
+
+    tab_source = inspect.getsource(qwen_image_lora_gui.qwen_image_lora_tab)
+    component_names = [
+        "compile",
+        "compile_resident_blocks_only",
+        "compile_backend",
+        "compile_mode",
+        "compile_dynamic",
+        "compile_fullgraph",
+        "compile_cache_size_limit",
+    ]
+    positions = [tab_source.index(f"qwen_model.{name},") for name in component_names]
+    assert positions == sorted(positions)
+    assert (
+        '"compile_resident_blocks_only": ("Qwen Image Model Settings", "Compile Resident Blocks Only")'
+        in tab_source
+    )
+
+
+@pytest.mark.parametrize("enabled", [True, False])
+def test_qwen_resident_compile_persistent_config_round_trip(tmp_path: Path, enabled):
+    config_path = tmp_path / "qwen.toml"
+    parameters = [
+        ("training_mode", "LoRA Training"),
+        ("network_module", qwen_image_lora_gui.QWEN_IMAGE_NETWORK_MODULE),
+        ("fused_backward_pass", False),
+        ("compile_resident_blocks_only", enabled),
+    ]
+
+    qwen_image_lora_gui.save_qwen_image_configuration(False, str(config_path), parameters)
+
+    assert toml.load(config_path)["compile_resident_blocks_only"] is enabled
+    loaded = qwen_image_lora_gui.open_qwen_image_configuration(
+        False,
+        str(config_path),
+        [("compile_resident_blocks_only", not enabled)],
+    )
+    assert loaded[2] is enabled
+
+
+@pytest.mark.parametrize("enabled", [True, False])
+def test_qwen_resident_compile_reaches_training_preview_config(tmp_path: Path, monkeypatch, enabled):
+    dataset = tmp_path / "dataset.toml"
+    dataset.write_text("[[datasets]]\nimage_directory = 'images'\n", encoding="utf-8")
+    captured = {}
+
+    def capture_preview(command, config_path):
+        captured["command"] = command
+        captured["config"] = toml.load(config_path)
+
+    monkeypatch.setattr(qwen_image_lora_gui, "print_command_and_toml", capture_preview)
+    parameters = [
+        ("training_mode", "LoRA Training"),
+        ("dataset_config_mode", "Use TOML File"),
+        ("dataset_config", str(dataset)),
+        ("model_version", "original"),
+        ("dit", _touch(tmp_path / "dit.safetensors")),
+        ("vae", _touch(tmp_path / "vae.safetensors")),
+        ("text_encoder", _touch(tmp_path / "text_encoder.safetensors")),
+        ("output_dir", str(tmp_path / "output")),
+        ("output_name", f"qwen-resident-{enabled}"),
+        ("mixed_precision", "bf16"),
+        ("gradient_checkpointing", True),
+        ("blocks_to_swap", 6),
+        ("block_swap_h2d_only", False),
+        ("block_swap_ring_size", 2),
+        ("num_processes", 1),
+        ("num_machines", 1),
+        ("num_cpu_threads_per_process", 1),
+        ("gpu_ids", "0"),
+        ("dynamo_backend", "no"),
+        ("network_module", qwen_image_lora_gui.QWEN_IMAGE_NETWORK_MODULE),
+        ("network_dim", 16),
+        ("network_alpha", 16),
+        ("network_dropout", 0),
+        ("network_args", []),
+        ("compile", True),
+        ("compile_backend", "inductor"),
+        ("compile_mode", "default"),
+        ("compile_dynamic", "auto"),
+        ("compile_fullgraph", False),
+        ("compile_cache_size_limit", 0),
+        ("compile_resident_blocks_only", enabled),
+        ("sdpa", True),
+        ("additional_parameters", ""),
+    ]
+
+    qwen_image_lora_gui.train_qwen_image_model(True, True, parameters)
+
+    assert any(str(part).endswith("qwen_image_train_network.py") for part in captured["command"])
+    if enabled:
+        assert captured["config"]["compile_resident_blocks_only"] is True
+    else:
+        assert "compile_resident_blocks_only" not in captured["config"]
+
+
+def test_zimage_dreambooth_preview_normalizes_full_model_runtime_config(tmp_path: Path, monkeypatch):
+    dataset = tmp_path / "dataset.toml"
+    dataset.write_text("[[datasets]]\nimage_directory = 'images'\n", encoding="utf-8")
+    captured: list[tuple[list[str], str]] = []
+    monkeypatch.setattr(
+        zimage_lora_gui,
+        "print_command_and_toml",
+        lambda command, config_path: captured.append((command, config_path)),
+    )
+    parameters = [
+        ("training_mode", "DreamBooth Fine-Tuning"),
+        ("dataset_config_mode", "Use TOML File"),
+        ("dataset_config", str(dataset)),
+        ("dit", _touch(tmp_path / "dit.safetensors")),
+        ("vae", _touch(tmp_path / "vae.safetensors")),
+        ("text_encoder", _touch(tmp_path / "text_encoder.safetensors")),
+        ("output_dir", str(tmp_path / "output")),
+        ("output_name", "zimage-full-preview"),
+        ("mixed_precision", "bf16"),
+        ("full_bf16", True),
+        ("full_fp16", False),
+        ("save_precision", "fp32"),
+        ("fp8_base", True),
+        ("fp8_scaled", True),
+        ("block_swap_h2d_only", True),
+        ("block_swap_ring_size", 2),
+        ("blocks_to_swap", 6),
+        ("gradient_checkpointing", True),
+        ("gradient_accumulation_steps", 1),
+        ("num_processes", 1),
+        ("num_machines", 1),
+        ("num_cpu_threads_per_process", 1),
+        ("gpu_ids", "0"),
+        ("dynamo_backend", "no"),
+        ("optimizer_type", "Automagic3"),
+        ("optimizer_args", []),
+        ("fused_backward_pass", False),
+        ("block_swap_optimizer_patch_params", False),
+        ("network_module", "networks.lora_zimage"),
+        ("network_dim", 32),
+        ("network_alpha", 32),
+        ("network_dropout", 0),
+        ("network_args", []),
+        ("base_weights", ["old-adapter.safetensors"]),
+        ("base_weights_multiplier", [1.0]),
+        ("sdpa", True),
+        ("caching_latent_skip_existing", False),
+        ("caching_teo_skip_existing", False),
+        ("additional_parameters", ""),
+        ("mem_eff_save", True),
+    ]
+
+    zimage_lora_gui.train_zimage_model(True, True, parameters)
+
+    command, config_path = captured[-1]
+    config = toml.load(config_path)
+    assert any(str(part).endswith("zimage_train.py") for part in command)
+    assert not any(str(part).endswith("zimage_train_network.py") for part in command)
+    assert config.get("fp8_base", False) is False
+    assert config.get("fp8_scaled", False) is False
+    assert config["save_precision"] == "bf16"
+    assert config["optimizer_type"] == "Automagic3"
+    assert config["mem_eff_save"] is True
+    assert not FULL_FINE_TUNING_NETWORK_KEYS.intersection(config)
+    assert "block_swap_h2d_only" not in config
+
+
+def test_flux_accelerate_lookup_prefers_the_active_python_environment(tmp_path: Path, monkeypatch):
+    scripts = tmp_path / "venv" / "Scripts"
+    scripts.mkdir(parents=True)
+    python = scripts / "python.exe"
+    accelerate = scripts / "accelerate.exe"
+    python.touch()
+    accelerate.touch()
+    monkeypatch.setattr(flux2_lora_gui.shutil, "which", lambda _name: r"C:\Python310\Scripts\accelerate.exe")
+
+    command = flux2_lora_gui._find_accelerate_launch(str(python))
+
+    assert Path(command[0]) == accelerate
+    assert command[1] == "launch"
+
+
+def test_custom_config_is_isolated_between_gui_tabs(tmp_path: Path):
+    config_path = tmp_path / "custom.toml"
+    config_path.write_text('training_mode = "Full Fine-Tuning"\n[nested]\nvalue = 1\n', encoding="utf-8")
+    manager = TabConfigManager(str(config_path))
+
+    wan_config = manager.get_config_for_tab("wan")
+    flux_config = manager.get_config_for_tab("flux")
+    wan_config.config["max_timestep"] = 0
+    wan_config.config["nested"]["value"] = 2
+
+    assert wan_config is not flux_config
+    assert "max_timestep" not in flux_config.config
+    assert flux_config.config["nested"]["value"] == 1
+    assert "max_timestep" not in manager.base_config.config
+
+
+@pytest.mark.parametrize(
+    "spec_key, expected_script",
+    [("ideogram4", "ideogram4_train.py"), ("krea2", "krea2_train.py")],
+)
+def test_modern_full_finetune_workflow_selects_full_trainer_and_strips_lora(
+    tmp_path: Path,
+    spec_key: str,
+    expected_script: str,
+):
+    spec = get_architecture(spec_key)
+    values = _architecture_defaults(spec)
+    values.update(
+        {
+            "training_mode": FULL_FINE_TUNING_MODE,
+            "mixed_precision": "bf16",
+            "full_bf16": True,
+            "full_fp16": False,
+            "fused_backward_pass": True,
+            "block_swap_optimizer_patch_params": False,
+            "optimizer_type": "AdaFactor",
+            "gradient_accumulation_steps": 1,
+            "fp8_base": True,
+            "fp8_scaled": True,
+            "block_swap_h2d_only": True,
+            "use_legacy_sdpa": True,
+            "dataset_config": _touch(tmp_path / "dataset.toml"),
+            "dit": _touch(tmp_path / "dit.safetensors"),
+            "vae": _touch(tmp_path / "vae.safetensors"),
+            "text_encoder": _touch(tmp_path / "text_encoder.safetensors"),
+            "output_dir": str(tmp_path / "output"),
+            "output_name": "modern-full",
+            "save_precision": "bf16",
+            "dit_variant": "raw",
+            "turbo_dit": "",
+            "turbo_dit_cache": False,
+            "blocks_to_swap": 32 if spec.is_ideogram else spec.max_blocks_to_swap,
+        }
+    )
+    config_path = tmp_path / "runtime.toml"
+
+    workflow = prepare_modern_image_workflow(
+        spec_key,
+        list(values.items()),
+        str(config_path),
+        python_cmd="python",
+    )
+    runtime = toml.load(config_path)
+
+    assert Path(workflow.train_command[-3]).name == expected_script
+    assert workflow.train_command[-2:] == ["--config_file", str(config_path)]
+    assert runtime["full_bf16"] is True
+    assert runtime["fused_backward_pass"] is True
+    assert runtime["use_legacy_sdpa"] is True
+    assert runtime["save_precision"] == "bf16"
+    assert "network_module" not in runtime
+    assert "network_dim" not in runtime
+    assert "fp8_base" not in runtime
+    assert "block_swap_h2d_only" not in runtime
+
+
+@pytest.mark.parametrize("spec_key", ["ideogram4", "krea2"])
+def test_modern_legacy_sdpa_persists_in_runtime_config(tmp_path: Path, spec_key: str):
+    spec = get_architecture(spec_key)
+    values = _architecture_defaults(spec)
+    values.update(
+        {
+            "dataset_config": _touch(tmp_path / "dataset.toml"),
+            "dit": _touch(tmp_path / "dit.safetensors"),
+            "vae": _touch(tmp_path / "vae.safetensors"),
+            "text_encoder": _touch(tmp_path / "text_encoder.safetensors"),
+            "output_dir": str(tmp_path / "output"),
+            "output_name": "legacy-sdpa",
+            "use_legacy_sdpa": True,
+        }
+    )
+    config_path = tmp_path / "runtime.toml"
+
+    workflow = prepare_modern_image_workflow(spec_key, list(values.items()), str(config_path), python_cmd="python")
+    runtime = toml.load(config_path)
+
+    assert dict(workflow.parameters)["use_legacy_sdpa"] is True
+    assert runtime["use_legacy_sdpa"] is True
+    assert _architecture_defaults(spec)["use_legacy_sdpa"] is False
+
+
+@pytest.mark.parametrize(
+    "operating_system",
+    ["Windows", "Linux"],
+)
+def test_workflow_script_does_not_mutate_attention_environment(tmp_path: Path, monkeypatch, operating_system):
+    monkeypatch.setattr(modern_image_lora_gui.platform, "system", lambda: operating_system)
+    workflow = ModernImageWorkflow(
+        parameters=[("use_legacy_sdpa", True)],
+        config_path=str(tmp_path / "runtime.toml"),
+        latent_cache_command=None,
+        text_cache_command=None,
+        train_command=["python", "train.py"],
+    )
+
+    script_path, content = _build_workflow_script(get_architecture("krea2"), workflow)
+    Path(script_path).unlink()
+
+    assert "MUSUBI_DISABLE_EXTERNAL_FLASH_SDPA" not in content
+
+
+@pytest.mark.parametrize(
+    "module, trainer, keys, model_version, model_family",
+    [
+        (flux2_lora_gui, flux2_lora_gui.train_flux2_model, flux2_lora_gui.FLUX2_PARAM_KEYS, "dev", None),
+        (
+            flux_klein_lora_gui,
+            flux_klein_lora_gui.train_flux_klein_model,
+            flux2_lora_gui.FLUX2_PARAM_KEYS,
+            "klein-base-4b",
+            None,
+        ),
+        (flux_lora_gui, flux_lora_gui.train_flux_model, flux_lora_gui.FLUX_PARAM_KEYS, "dev", "FLUX.2"),
+        (
+            flux_lora_gui,
+            flux_lora_gui.train_flux_model,
+            flux_lora_gui.FLUX_PARAM_KEYS,
+            "klein-base-4b",
+            "FLUX Klein",
+        ),
+    ],
+)
+def test_flux_full_finetune_runtime_uses_full_script_and_valid_config(
+    tmp_path: Path,
+    monkeypatch,
+    module,
+    trainer,
+    keys: list[str],
+    model_version: str,
+    model_family: str | None,
+):
+    values = _base_full_values(tmp_path, keys, model_version=model_version)
+    if model_family:
+        values["model_family"] = model_family
+    fake_executor = _FakeExecutor()
+    monkeypatch.setattr(module, "executor", fake_executor)
+    monkeypatch.setattr(module, "save_executed_script", lambda **_kwargs: None)
+    monkeypatch.setattr(module, "setup_environment", lambda **_kwargs: {})
+
+    trainer(
+        headless=True,
+        print_only=False,
+        parameters=_ordered_parameters(keys, values),
+    )
+
+    assert len(fake_executor.calls) == 1
+    command = fake_executor.calls[0]["run_cmd"]
+    assert any(Path(str(part)).name == "flux_2_train.py" for part in command)
+    runtime_files = list((tmp_path / "output").glob("full-smoke_*.toml"))
+    assert len(runtime_files) == 1
+    runtime = toml.load(runtime_files[0])
+    assert runtime["full_bf16"] is True
+    assert runtime["fused_backward_pass"] is True
+    assert runtime["use_legacy_sdpa"] is True
+    assert runtime["save_precision"] == "bf16"
+    assert "training_mode" not in runtime
+    assert "network_module" not in runtime
+    assert "network_dim" not in runtime
+
+
+def test_wan_compile_callback_parameter_order_includes_residency_control():
+    assert wan_lora_gui.WAN_COMPILE_PARAMETER_NAMES == (
+        "compile",
+        "compile_resident_blocks_only",
+        "compile_backend",
+        "compile_mode",
+        "compile_dynamic",
+        "compile_fullgraph",
+        "compile_cache_size_limit",
+    )
+
+
+@pytest.mark.parametrize(
+    ("task", "expected"),
+    [
+        ("t2v-A14B", True),
+        ("i2v-A14B", True),
+        ("t2v-14B", False),
+        ("i2v-14B", False),
+    ],
+)
+def test_wan_compile_residency_default_is_wan22_only(task: str, expected: bool):
+    assert wan_lora_gui.wan_compile_resident_blocks_default(task) is expected
+
+
+@pytest.mark.parametrize(
+    ("task", "explicit_value", "expected"),
+    [
+        ("t2v-A14B", None, True),
+        ("t2v-14B", None, False),
+        ("t2v-A14B", False, False),
+        ("t2v-14B", True, True),
+    ],
+)
+def test_wan_model_settings_control_uses_task_aware_compile_default(
+    task: str,
+    explicit_value: bool | None,
+    expected: bool,
+):
+    values = {"task": task}
+    if explicit_value is not None:
+        values["compile_resident_blocks_only"] = explicit_value
+    config = SimpleNamespace(config=values, get=values.get)
+
+    with gr.Blocks():
+        settings = wan_lora_gui.WanModelSettings(headless=True, config=config)
+
+    assert settings.compile_resident_blocks_only.value is expected
+    assert settings.compile_resident_blocks_only_overridden.value is (
+        explicit_value is not None
+    )
+
+
+@pytest.mark.parametrize(
+    ("task", "explicit_value"),
+    [
+        ("t2v-A14B", False),
+        ("t2v-14B", True),
+    ],
+)
+def test_wan_compile_residency_default_preserves_explicit_override(
+    task: str,
+    explicit_value: bool,
+):
+    parameters = [
+        ("task", task),
+        ("compile_resident_blocks_only", explicit_value),
+    ]
+
+    normalized = wan_lora_gui.apply_wan_compile_residency_default(parameters)
+
+    assert dict(normalized)["compile_resident_blocks_only"] is explicit_value
+    assert sum(key == "compile_resident_blocks_only" for key, _ in normalized) == 1
+
+
+@pytest.mark.parametrize(
+    ("task", "configured_value", "expected"),
+    [
+        ("t2v-A14B", None, True),
+        ("t2v-14B", None, False),
+        ("t2v-A14B", False, False),
+        ("t2v-14B", True, True),
+    ],
+)
+def test_wan_load_config_uses_task_compile_default_only_when_missing(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    task: str,
+    configured_value: bool | None,
+    expected: bool,
+):
+    monkeypatch.setattr(wan_lora_gui.gr, "Info", lambda *_args, **_kwargs: None)
+    config_path = tmp_path / "wan.toml"
+    config = {"task": task}
+    if configured_value is not None:
+        config["compile_resident_blocks_only"] = configured_value
+    config_path.write_text(toml.dumps(config), encoding="utf-8")
+
+    result = wan_lora_gui.open_wan_configuration(
+        False,
+        str(config_path),
+        [
+            ("task", "t2v-14B"),
+            ("compile_resident_blocks_only", False),
+        ],
+    )
+
+    assert result[2] == task
+    assert result[3] is expected
+    assert wan_lora_gui.wan_config_has_compile_residency_override(config_path) is (
+        configured_value is not None
+    )
+
+
+@pytest.mark.parametrize(
+    ("task", "explicit_value", "expected"),
+    [
+        ("t2v-A14B", None, True),
+        ("t2v-14B", None, False),
+        ("t2v-A14B", False, False),
+        ("t2v-14B", True, True),
+    ],
+)
+def test_wan_training_preview_serializes_effective_compile_residency(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    task: str,
+    explicit_value: bool | None,
+    expected: bool,
+):
+    captured: list[str] = []
+    monkeypatch.setattr(
+        wan_lora_gui,
+        "print_command_and_toml",
+        lambda _command, config_path: captured.append(config_path) if config_path else None,
+    )
+
+    dataset = tmp_path / "dataset.toml"
+    dataset.write_text("[[datasets]]\nimage_directory = 'images'\n", encoding="utf-8")
+    parameters = [
+        ("training_mode", "LoRA Training"),
+        ("task", task),
+        ("dataset_config_mode", "Use TOML File"),
+        ("dataset_config", str(dataset)),
+        ("dit", str(tmp_path / "dit.safetensors")),
+        ("vae", str(tmp_path / "vae.safetensors")),
+        ("t5", str(tmp_path / "t5.safetensors")),
+        ("clip", str(tmp_path / "clip.safetensors")),
+        ("output_name", "wan-compile-default"),
+        ("network_module", "networks.lora_wan"),
+        ("compile", True),
+        ("compile_backend", "inductor"),
+        ("compile_mode", "default"),
+        ("compile_dynamic", "auto"),
+        ("caching_latent_skip_existing", False),
+        ("caching_teo_skip_existing", False),
+        ("dynamo_backend", "no"),
+        ("additional_parameters", ""),
+    ]
+    if explicit_value is not None:
+        parameters.append(("compile_resident_blocks_only", explicit_value))
+
+    wan_lora_gui.train_wan_model(True, True, parameters)
+
+    assert captured
+    runtime_config = toml.load(captured[-1])
+    if expected:
+        assert runtime_config["compile_resident_blocks_only"] is True
+    else:
+        assert "compile_resident_blocks_only" not in runtime_config
+
+
+def test_wan_saved_gui_config_keeps_explicit_compile_residency_override(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+):
+    monkeypatch.setattr(wan_lora_gui.gr, "Info", lambda *_args, **_kwargs: None)
+    config_path = tmp_path / "wan-explicit.toml"
+
+    wan_lora_gui.save_wan_configuration(
+        False,
+        str(config_path),
+        [
+            ("training_mode", "LoRA Training"),
+            ("task", "t2v-A14B"),
+            ("compile_resident_blocks_only", False),
+        ],
+    )
+
+    saved = toml.load(config_path)
+    assert saved["compile_resident_blocks_only"] is False
+
+
+@pytest.mark.parametrize(
+    ("task", "current_value", "overridden", "expected"),
+    [
+        ("t2v-A14B", False, False, True),
+        ("t2v-14B", True, False, False),
+        ("t2v-A14B", False, True, False),
+        ("t2v-14B", True, True, True),
+    ],
+)
+def test_wan_task_switch_updates_only_automatic_compile_default(
+    task: str,
+    current_value: bool,
+    overridden: bool,
+    expected: bool,
+):
+    result = wan_lora_gui.WanModelSettings._update_compile_residency_default(
+        task,
+        current_value,
+        overridden,
+    )
+
+    assert result is expected

SECourses_Musubi_Trainer/tests/test_model_quantizer_gui.py

@@ -0,0 +1,232 @@
+import ast
+import io
+import sys
+from pathlib import Path
+
+import musubi_tuner_gui.model_quantizer_gui as model_quantizer_gui
+import pytest
+
+from musubi_tuner_gui.common_gui import utf8_subprocess_options
+from musubi_tuner_gui.model_quantizer_gui import (
+    MODEL_PRESET_NONE,
+    MODEL_PRESET_PRIMARY_CHOICES,
+    PRESET_INT8_CONVROT_HQ,
+    QUANT_FORMAT_INT8,
+    WORKFLOW_QUANTIZE,
+    ModelQuantizer,
+    _combined_preset_settings,
+    _model_preset_filters,
+    _model_preset_label,
+    _model_preset_value,
+)
+
+
+LTX_2_3_LABEL = "LTX 2.3 (INT8 ConvRot Learned HQ)"
+
+
+def _flag_value(command, flag):
+    return command[command.index(flag) + 1]
+
+
+def test_ltx_2_3_hq_is_a_distinct_primary_model_preset():
+    assert _model_preset_label("ltx2_3") == LTX_2_3_LABEL
+    assert _model_preset_value(LTX_2_3_LABEL) == "ltx2_3"
+    assert LTX_2_3_LABEL in MODEL_PRESET_PRIMARY_CHOICES
+
+    # Preserve the legacy combined preset and its stored label.
+    assert _model_preset_value("LTX (2 / 2.3)") == "ltxv2"
+    assert _model_preset_value(MODEL_PRESET_NONE) == MODEL_PRESET_NONE
+
+
+def test_ltx_2_3_hq_resolves_the_learned_fixed_convrot_recipe():
+    effective_preset, settings = _combined_preset_settings(
+        "ltx2_3",
+        None,
+        use_model_default_preset=True,
+    )
+
+    assert effective_preset == PRESET_INT8_CONVROT_HQ
+    assert settings["quant_format"] == QUANT_FORMAT_INT8
+    assert settings["comfy_quant"] is True
+    assert settings["scaling_mode"] == "row"
+    assert settings["block_size"] == 128
+    assert settings["convrot"] is True
+    assert settings["convrot_group_size"] == 256
+    assert settings["dynamic_convrot"] is False
+    assert settings["simple"] is False
+    assert settings["calib_samples"] == 2048
+    assert settings["optimizer"] == "prodigy"
+    assert settings["num_iter"] == 2000
+    assert settings["lr"] == 1.0
+    assert settings["lr_schedule"] == "adaptive"
+    assert settings["lr_factor"] == 0.965
+    assert settings["lr_cooldown"] == 1
+    assert settings["top_p"] == 0.2
+    assert settings["min_k"] == 128
+    assert settings["max_k"] == 1280
+    assert settings["scale_optimization"] == "fixed"
+    assert settings["scale_refinement_rounds"] == 1
+    assert settings["full_matrix"] is False
+    assert settings["full_precision_matrix_mult"] is False
+    assert settings["low_memory"] is True
+    assert settings["save_quant_metadata"] is True
+    assert _model_preset_filters("ltx2_3") == {"ltx2_3"}
+
+
+def test_ltx_2_3_hq_command_uses_native_convrot_and_ignores_layer_config():
+    _, params = _combined_preset_settings(
+        "ltx2_3",
+        None,
+        use_model_default_preset=True,
+    )
+    params.update(
+        {
+            "workflow": WORKFLOW_QUANTIZE,
+            "model_preset": "ltx2_3",
+            "model_filters": {"ltx2_3": True},
+            "layer_config_path": "stale-layer-config.json",
+            "layer_config_fullmatch": True,
+        }
+    )
+
+    command = ModelQuantizer(headless=True, config=None)._build_command(
+        "ltx-2.3-22b-distilled-1.1.safetensors",
+        "ltx-2.3-22b-distilled-1.1-int8-convrot-hq.safetensors",
+        params,
+    )
+
+    assert "--comfy_quant" in command
+    assert "--int8" in command
+    assert "--convrot" in command
+    assert _flag_value(command, "--convrot-group-size") == "256"
+    assert _flag_value(command, "--scaling_mode") == "row"
+    assert _flag_value(command, "--block_size") == "128"
+    assert _flag_value(command, "--calib_samples") == "2048"
+    assert _flag_value(command, "--optimizer") == "prodigy"
+    assert _flag_value(command, "--num_iter") == "2000"
+    assert _flag_value(command, "--scale-refinement") == "1"
+    assert _flag_value(command, "--scale-optimization") == "fixed"
+    assert "--ltx2_3" in command
+    assert "--simple" not in command
+    assert "--dynamic-convrot" not in command
+    assert "--layer-config" not in command
+    assert "--fullmatch" not in command
+
+
+def test_manual_no_model_preset_keeps_custom_layer_config_without_model_filter():
+    command = ModelQuantizer(headless=True, config=None)._build_command(
+        "model.safetensors",
+        "model-int8.safetensors",
+        {
+            "workflow": WORKFLOW_QUANTIZE,
+            "model_preset": MODEL_PRESET_NONE,
+            "model_filters": {},
+            "quant_format": QUANT_FORMAT_INT8,
+            "layer_config_path": "custom-layer-config.json",
+            "layer_config_fullmatch": True,
+        },
+    )
+
+    assert "--int8" in command
+    assert _flag_value(command, "--layer-config") == "custom-layer-config.json"
+    assert "--fullmatch" in command
+    assert "--ltx2_3" not in command
+
+
+def test_utf8_subprocess_options_override_host_locale_without_mutating_input():
+    original_env = {
+        "PYTHONIOENCODING": "cp1252",
+        "PYTHONUTF8": "0",
+        "KEEP_ME": "yes",
+    }
+
+    options = utf8_subprocess_options(original_env)
+
+    assert original_env["PYTHONIOENCODING"] == "cp1252"
+    assert options["text"] is True
+    assert options["encoding"] == "utf-8"
+    assert options["errors"] == "replace"
+    assert options["env"]["PYTHONIOENCODING"] == "utf-8:backslashreplace"
+    assert options["env"]["PYTHONUTF8"] == "1"
+    assert options["env"]["KEEP_ME"] == "yes"
+
+
+def test_progress_output_survives_non_utf8_console(monkeypatch):
+    buffer = io.BytesIO()
+    stream = io.TextIOWrapper(buffer, encoding="cp1252", errors="strict")
+
+    with monkeypatch.context() as patch:
+        patch.setattr(sys, "stdout", stream)
+        ModelQuantizer._write_stdout(f"progress {chr(0x258F)}")
+
+    assert buffer.getvalue() == b"progress \\u258f"
+
+
+def test_all_gui_text_subprocesses_declare_a_non_throwing_decoder():
+    gui_root = Path(model_quantizer_gui.__file__).parent
+    missing_policy = []
+
+    for source_path in gui_root.glob("*.py"):
+        tree = ast.parse(source_path.read_text(encoding="utf-8"), filename=str(source_path))
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
+                continue
+            if not isinstance(node.func.value, ast.Name) or node.func.value.id != "subprocess":
+                continue
+
+            keyword_values = {keyword.arg: keyword.value for keyword in node.keywords if keyword.arg}
+            if node.func.attr == "Popen":
+                stdout = keyword_values.get("stdout")
+                captures_stdout = (
+                    isinstance(stdout, ast.Attribute)
+                    and isinstance(stdout.value, ast.Name)
+                    and stdout.value.id == "subprocess"
+                    and stdout.attr == "PIPE"
+                )
+                if not captures_stdout:
+                    continue
+                uses_shared_policy = any(
+                    keyword.arg is None
+                    and isinstance(keyword.value, ast.Call)
+                    and isinstance(keyword.value.func, ast.Name)
+                    and keyword.value.func.id == "utf8_subprocess_options"
+                    for keyword in node.keywords
+                )
+                if not uses_shared_policy:
+                    missing_policy.append(f"{source_path.name}:{node.lineno}")
+            elif node.func.attr == "run":
+                text_mode = isinstance(keyword_values.get("text"), ast.Constant) and keyword_values["text"].value is True
+                captures_output = (
+                    isinstance(keyword_values.get("capture_output"), ast.Constant)
+                    and keyword_values["capture_output"].value is True
+                )
+                if text_mode and captures_output and "errors" not in keyword_values:
+                    missing_policy.append(f"{source_path.name}:{node.lineno}")
+
+    assert missing_policy == []
+
+
+@pytest.mark.parametrize(
+    "config",
+    [None, object()],
+    ids=["manual-no-config", "config-driven"],
+)
+def test_run_command_decodes_utf8_and_invalid_bytes_from_real_subprocess(monkeypatch, config):
+    monkeypatch.setattr(model_quantizer_gui, "save_executed_script", lambda **_kwargs: None)
+    command = [
+        sys.executable,
+        "-c",
+        "import sys; sys.stdout.buffer.write(b'Optimizing (AdaRound-prodigy-adaptive): 1%|\\xe2\\x96\\x8f| 16/2000\\nNative byte: \\xff\\n')",
+    ]
+
+    output, return_code = ModelQuantizer(headless=True, config=config)._run_command(
+        command,
+        "single_process",
+        "UTF-8 subprocess regression",
+    )
+
+    assert return_code == 0
+    assert output.splitlines() == [
+        f"Optimizing (AdaRound-prodigy-adaptive): 1%|{chr(0x258F)}| 16/2000",
+        f"Native byte: {chr(0xFFFD)}",
+    ]

SECourses_Musubi_Trainer/tmp_quantizer_expected.json

@@ -0,0 +1,2066 @@
+{
+  "fields": [
+    "quant_format",
+    "comfy_quant",
+    "full_precision_matrix_mult",
+    "scaling_mode",
+    "block_size",
+    "include_input_scale",
+    "convrot",
+    "convrot_group_size",
+    "exclude_layers",
+    "custom_type",
+    "custom_block_size",
+    "custom_scaling_mode",
+    "custom_simple",
+    "custom_heur",
+    "fallback_type",
+    "fallback_block_size",
+    "fallback_simple",
+    "simple",
+    "skip_inefficient_layers",
+    "full_matrix",
+    "calib_samples",
+    "manual_seed",
+    "optimizer",
+    "num_iter",
+    "lr",
+    "lr_schedule",
+    "top_p",
+    "min_k",
+    "max_k",
+    "lr_gamma",
+    "lr_patience",
+    "lr_factor",
+    "lr_min",
+    "lr_cooldown",
+    "lr_threshold",
+    "lr_adaptive_mode",
+    "lr_shape_influence",
+    "lr_threshold_mode",
+    "early_stop_loss",
+    "early_stop_lr",
+    "early_stop_stall",
+    "scale_optimization",
+    "scale_refinement_rounds",
+    "layer_config_path",
+    "layer_config_fullmatch",
+    "verbose",
+    "low_memory",
+    "save_quant_metadata"
+  ],
+  "quality": {
+    "0": {
+      "label": "Custom (manual)",
+      "settings": {}
+    },
+    "1": {
+      "label": "Fast (Simple Quantization)",
+      "settings": {
+        "calib_samples": 1024,
+        "optimizer": "original",
+        "num_iter": 200,
+        "lr": 0.008077300000003,
+        "lr_schedule": "adaptive",
+        "top_p": 0.02,
+        "min_k": 16,
+        "max_k": 64,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "2": {
+      "label": "Normal (Balanced)",
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "3": {
+      "label": "High Quality (Slow)",
+      "settings": {
+        "calib_samples": 4096,
+        "optimizer": "prodigy",
+        "num_iter": 6000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.2,
+        "min_k": 256,
+        "max_k": 1536,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "4": {
+      "label": "Extreme Quality (Very Slow)",
+      "settings": {
+        "calib_samples": 4096,
+        "optimizer": "prodigy",
+        "num_iter": 6000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.2,
+        "min_k": 256,
+        "max_k": 1536,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": true,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "5": {
+      "label": "FP8 Scaled (Tensorwise)",
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 3000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.16,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "6": {
+      "label": "FP8 Compatibility (Tensorwise)",
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 2500,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.14,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "7": {
+      "label": "INT8 Blockwise (QuantOps / Experimental)",
+      "settings": {
+        "calib_samples": 1024,
+        "optimizer": "original",
+        "num_iter": 200,
+        "lr": 0.008077300000003,
+        "lr_schedule": "adaptive",
+        "top_p": 0.02,
+        "min_k": 16,
+        "max_k": 64,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "INT8",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "block",
+        "block_size": 128,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": true,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "8": {
+      "label": "INT8 Tensorwise (QuantOps custom / RTX 30xx+)",
+      "settings": {
+        "calib_samples": 512,
+        "optimizer": "original",
+        "num_iter": 120,
+        "lr": 0.008077300000003,
+        "lr_schedule": "adaptive",
+        "top_p": 0.02,
+        "min_k": 16,
+        "max_k": 64,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "INT8",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": true,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "9": {
+      "label": "INT8 ConvRot Rowwise (QuantOps custom / Best INT8)",
+      "settings": {
+        "calib_samples": 1024,
+        "optimizer": "original",
+        "num_iter": 200,
+        "lr": 0.008077300000003,
+        "lr_schedule": "adaptive",
+        "top_p": 0.02,
+        "min_k": 16,
+        "max_k": 64,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "INT8",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "row",
+        "block_size": 128,
+        "convrot": true,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": true,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "10": {
+      "label": "MXFP8 Balanced (QuantOps / Blackwell)",
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 3000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.2,
+        "min_k": 128,
+        "max_k": 1280,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "MXFP8 (Microscaling)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "11": {
+      "label": "NVFP4 Balanced (QuantOps / Blackwell)",
+      "settings": {
+        "calib_samples": 4096,
+        "optimizer": "prodigy",
+        "num_iter": 4000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.2,
+        "min_k": 128,
+        "max_k": 1280,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "NVFP4 (FP4 E2M1)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": true,
+        "full_matrix": false,
+        "scale_optimization": "iterative",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "12": {
+      "label": "NVFP4 Z-Image (Aggressive / Expert)",
+      "settings": {
+        "calib_samples": 8192,
+        "optimizer": "prodigy",
+        "num_iter": 12000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.2,
+        "min_k": 256,
+        "max_k": 2048,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "NVFP4 (FP4 E2M1)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "iterative",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": 42,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    }
+  },
+  "models": {
+    "0": {
+      "label": "Anima (Base/Turbo)",
+      "value": "anima",
+      "preset_value": "FP8 Compatibility (Tensorwise)",
+      "filters": [
+        "anima"
+      ],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 2500,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.14,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "1": {
+      "label": "Boogu-Image",
+      "value": "boogu",
+      "preset_value": "INT8 Blockwise (QuantOps / Experimental)",
+      "filters": [],
+      "settings": {
+        "calib_samples": 1024,
+        "optimizer": "original",
+        "num_iter": 200,
+        "lr": 0.008077300000003,
+        "lr_schedule": "adaptive",
+        "top_p": 0.02,
+        "min_k": 16,
+        "max_k": 64,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "INT8",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "block",
+        "block_size": 128,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "(image_index_embedding|ref_image_patch_embedder)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": true,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "2": {
+      "label": "ERNIE Image",
+      "value": "ernie_image",
+      "preset_value": "FP8 Scaled (Tensorwise)",
+      "filters": [],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 3000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.16,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "(time_embedding|adaLN_modulation|final_linear|final_norm|x_embedder|layers[.]0[.]self_attention|layers[.]0[.]mlp.gate_proj|layers[.]0[.]mlp[.]up_proj|text_proj)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "3": {
+      "label": "FLUX.1",
+      "value": "flux1",
+      "preset_value": "FP8 Scaled (Tensorwise)",
+      "filters": [],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 3000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.16,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true,
+        "include_input_scale": true
+      }
+    },
+    "4": {
+      "label": "FLUX.2",
+      "value": "flux2",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "flux2"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "5": {
+      "label": "Hunyuan Video 1.5",
+      "value": "hunyuan",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "hunyuan"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "6": {
+      "label": "Krea 2 (Raw/Turbo)",
+      "value": "krea2",
+      "preset_value": "Normal (Balanced)",
+      "filters": [],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": false,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "^(first|last|tmlp|tproj|txtmlp|img_in|final_layer|time_embed|time_mod_proj)([.]|$)|^(txtfusion|text_fusion)[.]projector([.]|$)",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "F:\\SECourses_Musubi_Trainer_v16\\SECourses_Musubi_Trainer\\model_quantizer_presets\\krea2_fp8_layer_config.json",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "7": {
+      "label": "LTX (2 / 2.3)",
+      "value": "ltxv2",
+      "preset_value": "FP8 Compatibility (Tensorwise)",
+      "filters": [
+        "ltxv2"
+      ],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 2500,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.14,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "8": {
+      "label": "Microsoft LENS",
+      "value": "lens",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "lens"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "9": {
+      "label": "Qwen Image / Edit (2509, 2511, 2512)",
+      "value": "qwen",
+      "preset_value": "FP8 Scaled (Tensorwise)",
+      "filters": [
+        "qwen"
+      ],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 3000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.16,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "10": {
+      "label": "WAN (2.1 / 2.2)",
+      "value": "wan",
+      "preset_value": "FP8 Scaled (Tensorwise)",
+      "filters": [
+        "wan"
+      ],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 3000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.16,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "11": {
+      "label": "Z-Image",
+      "value": "zimage",
+      "preset_value": "FP8 Compatibility (Tensorwise)",
+      "filters": [
+        "zimage"
+      ],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 2500,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.14,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "12": {
+      "label": "Z-Image Refiner",
+      "value": "zimage_refiner",
+      "preset_value": "FP8 Compatibility (Tensorwise)",
+      "filters": [
+        "zimage_refiner"
+      ],
+      "settings": {
+        "calib_samples": 3072,
+        "optimizer": "prodigy",
+        "num_iter": 2500,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.14,
+        "min_k": 128,
+        "max_k": 1024,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "13": {
+      "label": "distillation_large",
+      "value": "distillation_large",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "distillation_large"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "14": {
+      "label": "distillation_small",
+      "value": "distillation_small",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "distillation_small"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "15": {
+      "label": "FLUX 2 Klein Models",
+      "value": "flux_klein",
+      "preset_value": "Normal (Balanced)",
+      "filters": [],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "16": {
+      "label": "Generic Text Encoder",
+      "value": "generic_text",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "generic_text"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "17": {
+      "label": "mistral",
+      "value": "mistral",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "mistral"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "18": {
+      "label": "nerf_large",
+      "value": "nerf_large",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "nerf_large"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "19": {
+      "label": "nerf_small",
+      "value": "nerf_small",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "nerf_small"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "20": {
+      "label": "Qwen2.5 Text/Multimodal",
+      "value": "qwen35",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "generic_text",
+        "qwen35"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "21": {
+      "label": "radiance",
+      "value": "radiance",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "radiance"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    },
+    "22": {
+      "label": "T5-XXL",
+      "value": "t5xxl",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "t5xxl"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true,
+        "include_input_scale": true
+      }
+    },
+    "23": {
+      "label": "visual",
+      "value": "visual",
+      "preset_value": "Normal (Balanced)",
+      "filters": [
+        "visual"
+      ],
+      "settings": {
+        "calib_samples": 2048,
+        "optimizer": "prodigy",
+        "num_iter": 2000,
+        "lr": 1.0,
+        "lr_schedule": "plateau",
+        "top_p": 0.12,
+        "min_k": 128,
+        "max_k": 896,
+        "lr_gamma": 0.99,
+        "lr_patience": 1,
+        "lr_factor": 0.95,
+        "lr_min": 1e-08,
+        "lr_cooldown": 0,
+        "lr_threshold": 0.0,
+        "lr_adaptive_mode": "simple-reset",
+        "lr_shape_influence": 1.0,
+        "lr_threshold_mode": "rel",
+        "early_stop_loss": 5e-09,
+        "early_stop_lr": 1.01e-08,
+        "early_stop_stall": 2000,
+        "quant_format": "FP8 (E4M3)",
+        "comfy_quant": true,
+        "full_precision_matrix_mult": true,
+        "scaling_mode": "tensor",
+        "block_size": null,
+        "convrot": false,
+        "convrot_group_size": 256,
+        "exclude_layers": "",
+        "custom_type": null,
+        "custom_block_size": null,
+        "custom_scaling_mode": null,
+        "custom_simple": false,
+        "custom_heur": false,
+        "fallback_type": null,
+        "fallback_block_size": null,
+        "fallback_simple": false,
+        "simple": false,
+        "skip_inefficient_layers": false,
+        "full_matrix": false,
+        "scale_optimization": "fixed",
+        "scale_refinement_rounds": 1,
+        "layer_config_path": "",
+        "layer_config_fullmatch": false,
+        "manual_seed": -1,
+        "verbose": "NORMAL",
+        "low_memory": true,
+        "save_quant_metadata": true
+      }
+    }
+  },
+  "known_filters": [
+    "anima",
+    "distillation_large",
+    "distillation_small",
+    "flux2",
+    "generic_text",
+    "hunyuan",
+    "lens",
+    "ltxv2",
+    "mistral",
+    "nerf_large",
+    "nerf_small",
+    "qwen",
+    "qwen35",
+    "radiance",
+    "t5xxl",
+    "visual",
+    "wan",
+    "zimage",
+    "zimage_refiner"
+  ]
+}

SECourses_Musubi_Trainer/venv/bin/python

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b94e9b56bc1f96b18d36a0f1d14308575bb7b5960eda94ae0520f0376e95d12d
+size 5909000

SECourses_Musubi_Trainer/venv/bin/python3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b94e9b56bc1f96b18d36a0f1d14308575bb7b5960eda94ae0520f0376e95d12d
+size 5909000

SECourses_Musubi_Trainer/venv/bin/python3.10

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b94e9b56bc1f96b18d36a0f1d14308575bb7b5960eda94ae0520f0376e95d12d
+size 5909000

SECourses_Musubi_Trainer/venv/pyvenv.cfg

@@ -0,0 +1,3 @@
+home = /usr/bin
+include-system-site-packages = false
+version = 3.10.12

SECourses_Musubi_Trainer/wan_defaults.toml

@@ -0,0 +1,238 @@
+# Wan Models Training - Optimal Defaults Configuration
+# This file contains the recommended default values for Wan model training
+# Supports all Wan models: T2V, I2V, T2I, FLF2V, Fun-Control, and Wan 2.2 Advanced models
+# Based on Wan documentation and best practices
+
+# Training Mode Selection
+training_mode = "LoRA Training"  # The installed Wan backend supports LoRA/network training.
+
+# Wan Model Selection - REQUIRED
+task = "t2v-14B"  # REQUIRED: Wan model type (t2v-14B, t2v-1.3B, i2v-14B, t2i-14B, flf2v-14B, t2v-1.3B-FC, t2v-14B-FC, i2v-14B-FC, t2v-A14B, i2v-A14B)
+
+# Model Settings - REQUIRED FIELDS MUST BE SET BY USER
+dit = ""  # REQUIRED: Path to DiT checkpoint (.safetensors)
+vae = ""  # REQUIRED: Path to VAE checkpoint (Wan2.1_VAE.pth or wan_2.1_vae.safetensors)
+t5 = ""  # REQUIRED: Path to T5 text encoder (umt5-xxl-enc-bf16.safetensors)
+clip = ""  # REQUIRED ONLY for i2v-14B, flf2v-14B, i2v-14B-FC models. Path to CLIP vision encoder (models_clip_open-clip-xlm-roberta-large-vit-huge-14.safetensors)
+dataset_config = ""  # Path to dataset TOML configuration (required if using "Use TOML File" mode)
+dataset_config_mode = "Generate from Folder Structure"  # Default to auto-generate from folder structure
+
+# Wan 2.2 Advanced Models (A14B) - Dual Model System
+dit_high_noise = ""  # [WAN 2.2 ONLY] Path to high noise DiT model for Wan 2.2 Advanced models (t2v-A14B, i2v-A14B)
+timestep_boundary = 0.0  # [WAN 2.2 ONLY] Timestep boundary for dual model system. Auto-detected from model config if not set
+offload_inactive_dit = false  # [WAN 2.2 ONLY] Offload inactive DiT to CPU to save VRAM during dual model training
+use_pinned_memory_for_block_swap = false  # Use Pinned Memory for Block Swapping: Uses more system RAM but speeds up training. The speed up maybe significant depending on system settings. To work, go to Advanced Graphics settings in System > Display > Graphics as in tutorial video and disable Hardware-Accelerated GPU Scheduling and restart your PC. Only effective when blocks_to_swap > 0
+block_swap_h2d_only = false  # LoRA only; requires blocks_to_swap > 0 and gradient_checkpointing; use standard swap for Wan 2.2 dual-DiT
+block_swap_ring_size = 2  # 2 overlaps transfer/compute; 1 minimizes VRAM
+
+# Folder Structure Settings (used when dataset_config_mode = "Generate from Folder Structure")
+parent_folder_path = ""  # REQUIRED when using folder structure mode: Path to parent folder containing training images/videos
+dataset_resolution_width = 960  # Target width for training. Optimal resolutions: 960×960, 1280×720, 720×1280
+dataset_resolution_height = 960  # Target height for training. Optimal resolutions: 960×960, 1280×720, 720×1280
+dataset_caption_extension = ".txt"  # Extension for caption files
+create_missing_captions = true  # Auto-create empty captions for images without caption files
+caption_strategy = "folder_name"  # How to handle missing captions: "folder_name" or "empty"
+dataset_batch_size = 1  # Batch size for dataset processing
+dataset_enable_bucket = false  # Enable bucketing for variable aspect ratios
+dataset_bucket_no_upscale = false  # Prevent upscaling in bucket mode
+dataset_cache_directory = "cache_dir"  # Directory for caching processed data
+generated_toml_path = ""  # Path where generated TOML will be saved (auto-set)
+
+# Video-specific Settings (for T2V, I2V, FLF2V models)
+num_frames = 81  # Number of frames for video training (81 is default for Wan models)
+one_frame = false  # Enable one-frame training mode for image-like training on video models
+
+# Video Frame Extraction Settings
+frame_extraction = "head"  # Frame extraction method: "head" (recommended), "chunk", "slide", "uniform", "full"
+frame_stride = 1  # Step size for sliding window extraction (used with "slide" method)
+frame_sample = 1  # Number of samples to extract (used with "uniform" method)
+# Dataset generation target_frames (written into generated dataset TOML for video datasets)
+target_frames = 81  # Target video frame count for dataset generation (saved as target_frames=[N]). Must be N*4+1 (1,5,9,...,81)
+auto_normalize_target_frames = true  # Scan dataset and clamp Target Frames to the minimum video length found (then round to N*4+1)
+max_frames = 129  # Maximum number of frames to extract from any video (used with "full" method)
+source_fps = 0  # Original video FPS for frame rate conversion (0=auto-detect)
+
+# Data Types and Precision
+dit_dtype = "bfloat16"  # DiT model data type. bfloat16=best quality, float16=faster
+text_encoder_dtype = "bfloat16"  # T5 text encoder data type
+vae_dtype = "bfloat16"  # VAE data type
+clip_vision_dtype = "bfloat16"  # CLIP vision encoder data type
+
+# Memory Optimization Settings
+fp8_base = false  # Enable FP8 for DiT model to reduce VRAM usage (requires fp8_scaled=true)
+fp8_scaled = false  # REQUIRED when fp8_base=true, provides better quality than standard FP8
+fp8_t5 = false  # Enable FP8 for the T5 text encoder to reduce VRAM usage
+blocks_to_swap = 0  # 0=disabled. Max varies by model. Higher values save more VRAM but require more RAM
+
+# VAE Optimization Settings
+vae_tiling = false  # Enable spatial tiling to reduce VRAM usage during VAE operations
+vae_chunk_size = 0  # 0=auto/disabled. Higher=faster but more VRAM
+vae_spatial_tile_sample_min_size = 0  # 0=disabled. 256=typical. Auto-enables vae_tiling if set
+
+# Flow Matching Settings (Wan uses Flow Matching instead of diffusion)
+timestep_sampling = "uniform"  # Timestep sampling method: "uniform", "sigmoid", "shift"
+discrete_flow_shift = 1.0  # Discrete flow shift parameter
+weighting_scheme = "none"  # Loss weighting scheme: "none", "mode"
+logit_mean = 0.0  # Logit mean for timestep sampling
+logit_std = 1.0  # Logit standard deviation for timestep sampling
+mode_scale = 1.29  # Mode scale for weighting scheme
+
+# Advanced Timestep Parameters
+sigmoid_scale = 1.0  # Scale factor for sigmoid timestep sampling
+min_timestep = 0  # Minimum timestep constraint (0=no constraint)
+max_timestep = 1000  # Maximum timestep constraint (1000=no constraint)
+preserve_distribution_shape = false  # Preserve original distribution when using min/max constraints
+num_timestep_buckets = 0  # 0=disabled. 4-10=bucketed sampling for uniform distribution
+
+# Training Settings
+sdpa = true  # Use PyTorch's scaled dot product attention (recommended)
+flash_attn = false  # Use Flash Attention (requires installation)
+sage_attn = false  # Use Sage Attention (inference only)
+xformers = false  # Use xFormers attention
+split_attn = false  # Split attention computation to reduce peak memory use
+use_legacy_sdpa = false  # Force the older PyTorch SDPA path instead of automatic verified acceleration
+max_train_steps = 90000  # Maximum training steps
+max_train_epochs = 200  # Maximum training epochs
+max_data_loader_n_workers = 2  # Number of data loader workers
+persistent_data_loader_workers = true  # Keep data loader workers persistent
+seed = 99  # Random seed for reproducibility
+gradient_checkpointing = true  # Enable gradient checkpointing to save VRAM
+gradient_accumulation_steps = 1  # Number of gradient accumulation steps
+full_bf16 = false  # EXPERIMENTAL: Store gradients in BF16 to save VRAM (currently disabled in backend)
+full_fp16 = false  # EXPERIMENTAL: Store gradients in FP16 to save VRAM (currently disabled in backend)
+
+# Optimizer Settings
+optimizer_type = "adamw8bit"  # Optimizer type (adamw8bit recommended for memory efficiency)
+optimizer_args = []  # Additional optimizer arguments
+learning_rate = 1e-4  # Learning rate (1e-4 is good default for Wan models)
+max_grad_norm = 1.0  # Maximum gradient norm for clipping
+lr_scheduler = "constant"  # Learning rate scheduler type
+lr_warmup_steps = 0  # Number of warmup steps (0=no warmup)
+lr_decay_steps = 0  # Number of decay steps (0=no decay)
+lr_scheduler_num_cycles = 1  # Number of scheduler cycles
+lr_scheduler_power = 1.0  # Scheduler power parameter
+lr_scheduler_timescale = 0  # Scheduler timescale (0=auto)
+lr_scheduler_min_lr_ratio = 0.0  # Minimum learning rate ratio
+lr_scheduler_type = ""  # Additional scheduler type
+lr_scheduler_args = []  # Additional scheduler arguments
+
+# Network Settings (LoRA Mode Only - Ignored in DreamBooth Mode)
+no_metadata = false  # Disable metadata saving
+network_weights = ""  # Path to pretrained LoRA weights to continue training
+network_module = "networks.lora_wan"  # Network module for LoRA (auto-set based on training mode)
+network_dim = 16  # LoRA network dimension/rank (16 recommended for Wan models)
+network_alpha = 16.0  # LoRA alpha parameter (typically equal to network_dim)
+network_dropout = 0.0  # LoRA dropout rate (0.0=no dropout)
+network_args = []  # Additional network arguments
+training_comment = ""  # Training comment for metadata
+dim_from_weights = false  # Extract dimensions from existing weights
+scale_weight_norms = 0.0  # Scale weight norms (0.0=disabled)
+base_weights = ""  # Path to base LoRA weights to merge
+base_weights_multiplier = 1.0  # Multiplier for base weights
+
+# Save/Load Settings
+output_dir = ""  # Output directory for saved models
+output_name = "my-wan-lora"  # Base filename for saved models
+resume = ""  # Path to checkpoint to resume training from
+save_precision = "bf16"  # LoRA output dtype; BF16 keeps files about half the size of FP32
+save_every_n_epochs = 10  # Save checkpoint every N epochs
+save_every_n_steps = 0  # Save checkpoint every N steps (0=disabled)
+save_last_n_epochs = 0  # Keep only last N epoch checkpoints (0=keep all)
+save_last_n_epochs_state = 0  # Keep only last N epoch states (0=keep all)
+save_last_n_steps = 0  # Keep only last N step checkpoints (0=keep all)
+save_last_n_steps_state = 0  # Keep only last N step states (0=keep all)
+save_state = false  # Save training state
+save_state_on_train_end = false  # Save state when training ends
+mem_eff_save = false  # Memory efficient saving for DreamBooth fine-tuning mode
+
+# Caching Settings - Latents
+caching_latent_device = "cuda"  # Device for latent caching
+caching_latent_batch_size = 4  # Batch size for latent caching
+caching_latent_num_workers = 8  # Number of workers for latent caching
+caching_latent_skip_existing = true  # Skip existing cached latents
+caching_latent_keep_cache = true  # Keep cache after training
+caching_latent_debug_mode = ""  # Debug mode for latent caching
+caching_latent_console_width = 80  # Console width for debug output
+caching_latent_console_back = ""  # Console background for debug
+caching_latent_console_num_images = 0  # Number of images in debug console (0=no limit)
+
+# Caching Settings - Text Encoder
+caching_teo_text_encoder1 = ""  # Optional T5 override for caching; empty uses the model T5 path
+caching_teo_text_encoder2 = ""  # Reserved optional second text encoder path
+caching_teo_device = "cuda"  # Device for text encoder caching
+caching_teo_fp8_llm = false  # Use FP8 for T5 text encoder caching
+caching_teo_batch_size = 16  # Batch size for text encoder caching
+caching_teo_num_workers = 8  # Number of workers for text encoder caching
+caching_teo_skip_existing = true  # Skip existing cached outputs
+caching_teo_keep_cache = true  # Keep cache after training
+
+# Torch compile (optional)
+compile = false
+compile_backend = "inductor"
+compile_mode = "default"
+compile_dynamic = "auto"  # "auto" | "true" | "false"
+compile_fullgraph = false
+compile_cache_size_limit = 0  # 0 = use PyTorch default
+
+# Accelerate Launch Settings
+mixed_precision = "bf16"  # Mixed precision training (bf16 recommended for Wan)
+multi_gpu = false  # Enable multi-GPU training
+gpu_ids = "0"  # GPU IDs for distributed training
+num_processes = 1  # Number of processes for distributed training
+num_machines = 1  # Number of machines for distributed training
+num_cpu_threads_per_process = 2  # CPU threads per process
+main_process_port = 0  # Port for distributed communication (0=auto)
+dynamo_backend = "no"  # PyTorch dynamo backend (no=disabled)
+dynamo_mode = ""  # Dynamo optimization mode
+dynamo_use_fullgraph = false  # Use fullgraph mode for dynamo
+dynamo_use_dynamic = false  # Use dynamic mode for dynamo
+extra_accelerate_launch_args = ""  # Additional accelerate launch arguments
+
+# Logging Settings
+logging_dir = ""  # Directory for training logs
+log_prefix = ""  # Prefix for log files
+log_tracker_name = ""  # Name for experiment tracking
+wandb_run_name = ""  # Weights & Biases run name
+log_tracker_config = ""  # Configuration for experiment tracking
+wandb_api_key = ""  # Weights & Biases API key
+log_config = false  # Log configuration to tracker
+
+# DDP Settings (Distributed Training)
+ddp_timeout = 0  # DDP timeout in minutes (0=default)
+ddp_gradient_as_bucket_view = false  # Use gradient as bucket view
+ddp_static_graph = false  # Use static graph for DDP
+
+# Sample Generation Settings
+sample_every_n_steps = 0  # Generate samples every N steps (0=disabled)
+sample_every_n_epochs = 0  # Generate samples every N epochs (0=disabled)
+sample_at_first = false  # Generate samples before training starts
+sample_prompts = ""  # Path to file with sample prompts
+disable_prompt_enhancement = false  # true = use prompt file exactly as written (no auto-added defaults)
+
+# Default Sample Parameters for Video Generation
+sample_width = 960  # Sample video width. Optimal resolutions: 960×960, 1280×720, 720×1280
+sample_height = 960  # Sample video height. Optimal resolutions: 960×960, 1280×720, 720×1280
+sample_num_frames = 81  # Number of frames in sample videos
+sample_steps = 20  # Number of inference steps for samples
+sample_guidance_scale = 7.0  # Default WAN training sample CFG scale (written as --l in enhanced prompts)
+sample_seed = 99  # Seed for sample generation (-1=random)
+sample_negative_prompt = ""  # Default negative prompt for samples
+
+# Metadata Settings
+metadata_author = ""  # Author metadata
+metadata_description = ""  # Description metadata
+metadata_license = ""  # License metadata
+metadata_tags = ""  # Tags metadata
+metadata_title = ""  # Title metadata
+metadata_reso = ""  # Optional resolution metadata, e.g. 960,960
+metadata_arch = ""  # Optional custom architecture metadata
+
+# HuggingFace Settings
+huggingface_repo_id = ""  # HuggingFace repository ID
+huggingface_token = ""  # HuggingFace API token
+huggingface_repo_type = ""  # Repository type
+huggingface_repo_visibility = ""  # Repository visibility
+huggingface_path_in_repo = ""  # Path within repository
+save_state_to_huggingface = false  # Save training state to HuggingFace
+resume_from_huggingface = ""  # Optional Hugging Face resume specification
+async_upload = false  # Use async upload to HuggingFace

SECourses_Musubi_Trainer/zimage_defaults.toml

@@ -0,0 +1,152 @@
+# Z-Image Training - Recommended Defaults (Base + Turbo)
+# Based on musubi-tuner/docs/zimage.md training example.
+
+# Z-Image variant selector (GUI-only; training uses your selected DiT checkpoint)
+zimage_variant = "base"  # "base" | "turbo"
+
+# Training mode (GUI only)
+training_mode = "LoRA Training"  # "LoRA Training" | "DreamBooth Fine-Tuning"
+
+# Optional: Turbo Training Adapter (LoRA). If set, GUI passes it as base_weights (--base_weights) during training.
+training_adapter_path = ""
+training_adapter_multiplier = 1.0
+
+# Required model paths (set these)
+dit = ""          # REQUIRED: path to Z-Image DiT checkpoint (Base or Turbo/De-Turbo)
+vae = ""          # REQUIRED: path to Z-Image VAE checkpoint
+text_encoder = "" # REQUIRED: path to Qwen3 text encoder (split file 00001-of-...)
+
+# Dataset config
+dataset_config_mode = "Generate from Folder Structure"  # "Generate from Folder Structure" | "Use TOML File"
+dataset_config = ""        # Used when dataset_config_mode="Use TOML File"
+parent_folder_path = ""    # Used when dataset_config_mode="Generate from Folder Structure"
+dataset_resolution_width = 1024
+dataset_resolution_height = 1024
+dataset_caption_extension = ".txt"
+create_missing_captions = true
+caption_strategy = "folder_name"
+dataset_batch_size = 1
+dataset_enable_bucket = true
+dataset_bucket_no_upscale = false
+dataset_cache_directory = "cache_dir"
+generated_toml_path = ""
+
+# Precision / memory
+mixed_precision = "bf16"
+num_cpu_threads_per_process = 1
+fp8_base = false
+fp8_scaled = false
+fp8_llm = false
+disable_numpy_memmap = false
+blocks_to_swap = 0
+use_pinned_memory_for_block_swap = false
+block_swap_h2d_only = false
+block_swap_ring_size = 2
+
+# Training core
+sdpa = true
+flash_attn = false
+sage_attn = false
+xformers = false
+split_attn = false
+use_legacy_sdpa = false
+max_train_epochs = 16
+max_train_steps = 1600
+max_data_loader_n_workers = 2
+persistent_data_loader_workers = true
+seed = 42
+gradient_checkpointing = true
+gradient_checkpointing_cpu_offload = false
+gradient_accumulation_steps = 1
+
+# Torch compile (optional)
+compile = false
+compile_backend = "inductor"
+compile_mode = "default"
+compile_dynamic = "auto"         # "auto" | "true" | "false"
+compile_fullgraph = false
+compile_cache_size_limit = 0     # 0 = use PyTorch default
+
+# Flow matching / timestep sampling (example defaults; adjust if needed)
+timestep_sampling = "shift"
+weighting_scheme = "none"
+discrete_flow_shift = 2.0
+sigmoid_scale = 1.0
+min_timestep = 0
+max_timestep = 1000
+
+# Optimizer
+optimizer_type = "adamw8bit"
+optimizer_args = ""
+learning_rate = 1e-4
+max_grad_norm = 1.0
+fused_backward_pass = false  # DreamBooth only: reduces VRAM during backward pass with AdaFactor
+lr_scheduler = "constant"
+lr_warmup_steps = 0
+lr_decay_steps = 0
+lr_scheduler_num_cycles = 1
+lr_scheduler_power = 1.0
+lr_scheduler_timescale = 0
+lr_scheduler_min_lr_ratio = 0.0
+lr_scheduler_type = ""
+lr_scheduler_args = ""
+
+# Network (LoRA)
+network_module = "networks.lora_zimage"
+network_dim = 32
+network_alpha = 32.0
+network_dropout = 0.0
+network_args = ""
+network_weights = ""
+training_comment = ""
+dim_from_weights = false
+scale_weight_norms = 0.0
+base_weights = ""
+base_weights_multiplier = 1.0
+no_metadata = false
+
+# Caching (recommended)
+caching_latent_device = "cuda"
+caching_latent_batch_size = 1
+caching_latent_num_workers = 2
+caching_latent_skip_existing = true
+caching_latent_keep_cache = true
+
+caching_teo_device = "cuda"
+caching_teo_batch_size = 8
+caching_teo_num_workers = 2
+caching_teo_skip_existing = true
+caching_teo_keep_cache = true
+
+# Samples (optional)
+sample_every_n_steps = 0
+sample_every_n_epochs = 0
+sample_at_first = false
+sample_prompts = ""
+disable_prompt_enhancement = false
+sample_output_dir = ""
+sample_width = 1024
+sample_height = 1024
+sample_steps = 25
+sample_seed = 42
+sample_negative_prompt = ""
+sample_cfg_scale = 4.0
+
+# Save / resume
+output_dir = ""
+output_name = "my-zimage-lora"
+resume = ""
+save_precision = "bf16"
+save_every_n_epochs = 1
+save_every_n_steps = 0
+save_last_n_epochs = 0
+save_last_n_steps = 0
+save_last_n_epochs_state = 0
+save_last_n_steps_state = 0
+save_state = false
+save_state_on_train_end = false
+mem_eff_save = false
+
+# Advanced
+additional_parameters = ""
+debug_mode = "None"

gradio/frpc/frpc_linux_amd64_v0.3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c791d1f047b41ff5885772fc4bf20b797c6059bbd82abb9e31de15e55d6a57c4
+size 11907224

hub/models--Qwen--Qwen-Image/blobs/28028c056af412405debd878cdda0171e35fa5d1

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

hub/models--Qwen--Qwen-Image/blobs/482ced4679301bf287ebb310bdd1790eb4514232

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

hub/models--Qwen--Qwen-Image/blobs/ac23c0aaa2434523c494330aeb79c58395378103

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

hub/models--Qwen--Qwen-Image/blobs/eaed590d62aaf0ba31e284b66ddcb18222f066c2

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

hub/models--Qwen--Qwen-Image/refs/main

@@ -0,0 +1 @@
+75e0b4be04f60ec59a75f475837eced720f823b6

hub/models--Qwen--Qwen-Image/snapshots/75e0b4be04f60ec59a75f475837eced720f823b6/tokenizer/added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

hub/models--Qwen--Qwen-Image/snapshots/75e0b4be04f60ec59a75f475837eced720f823b6/tokenizer/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

hub/models--Qwen--Qwen-Image/snapshots/75e0b4be04f60ec59a75f475837eced720f823b6/tokenizer/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

hub/models--Qwen--Qwen-Image/snapshots/75e0b4be04f60ec59a75f475837eced720f823b6/tokenizer/tokenizer_config.json

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

hub/version_diffusers_cache.txt

@@ -0,0 +1 @@
+1

venv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

venv/bin/accelerate

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.accelerate_cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/accelerate-config

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.config import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/accelerate-estimate-memory

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.estimate import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/accelerate-launch

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.launch import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/accelerate-merge-weights

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.merge import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/activate

@@ -0,0 +1,63 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past commands. Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/workspace/venv"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(venv) ${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT="(venv) "
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

venv/bin/activate.csh

@@ -0,0 +1,26 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/workspace/venv"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(venv) $prompt"
+    setenv VIRTUAL_ENV_PROMPT "(venv) "
+endif
+
+alias pydoc python -m pydoc
+
+rehash

venv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/workspace/venv"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(venv) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT "(venv) "
+end

venv/bin/convert-to-quant

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from convert_to_quant.convert_to_quant import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/convert_to_quant

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from convert_to_quant.convert_to_quant import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/ctq

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from convert_to_quant.convert_to_quant import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/diffusers-cli

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from diffusers.commands.diffusers_cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/f2py

@@ -0,0 +1,6 @@
+#!/workspace/venv/bin/python
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(main())

venv/bin/fastapi

@@ -0,0 +1,6 @@
+#!/workspace/venv/bin/python
+import sys
+from fastapi.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(main())

venv/bin/ftfy

@@ -0,0 +1,10 @@
+#!/workspace/venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from ftfy.cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

venv/bin/gradio

@@ -0,0 +1,6 @@
+#!/workspace/venv/bin/python
+import sys
+from gradio.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(cli())