Add layered training functionality and enhance error handling in app.py

Introduce a new function, run_training_layered, to support layered image training, allowing users to upload multiple layers for processing. Implement error handling for required inputs and improve logging for better user feedback. Update the UI to include a dedicated tab for layered training, enhancing user experience by providing clear options for both standard and layered training processes. Additionally, refactor existing training logic to streamline control flow and maintain consistency across different training modes.

app.py

@@ -50,6 +50,8 @@ def _bash_quote(s: str) -> str:
 
 
 _QWEN_IMAGE_TYPES = ("edit-2509", "edit-2511", "layered")
+EDIT_CONTROL_MAX = 8
+LAYER_MAX = 32
 
 
 def _get_qwen_image_type() -> str:
@@ -847,6 +849,10 @@ def run_training(
     image_type = _get_qwen_image_type()
     log_buf += f"[QIE] Model type: {image_type}\n"
     yield (log_buf, ckpts, artifacts, run_out_dir)
+    if image_type == "layered":
+        log_buf += "[ERROR] Layered は Layered タブで実行してください。QWEN_IMAGE_TYPE=layered を設定して再起動してください。\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
 
     # Ensure /auto holds helper files expected by the script
     _ensure_workspace_auto_files()
@@ -883,17 +889,11 @@ def run_training(
         _extract_paths(control6_uploads),
         _extract_paths(control7_uploads),
     ]
-    if image_type == "layered":
-        if not any(control_upload_sets):
-            log_buf += "[ERROR] Layered では control_0〜7 のいずれかが必要です。\n"
-            yield (log_buf, ckpts, artifacts, run_out_dir)
-            return
-    else:
-        # Require control_0; others optional
-        if not control_upload_sets[0]:
-            log_buf += "[ERROR] control_0 images are required.\n"
-            yield (log_buf, ckpts, artifacts, run_out_dir)
-            return
+    # Require control_0; others optional
+    if not control_upload_sets[0]:
+        log_buf += "[ERROR] control_0 images are required.\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
 
     control_dirs: List[Optional[str]] = []
     for i, uploads in enumerate(control_upload_sets):
@@ -909,11 +909,6 @@ def run_training(
         log_buf += f"[QIE] Copied {len(uploads)} control_{i} images to {cdir}\n"
         yield (log_buf, ckpts, artifacts, run_out_dir)
 
-    control_dirs_abs = [
-        (os.path.join(ds_dir, name) if name else None)
-        for name in control_dirs
-    ]
-
     # Prepare script with user parameters
     control_folders = [
         (control_dirs[i] if control_dirs[i] else None)
@@ -933,24 +928,16 @@ def run_training(
 
     # Update dataset config with requested resolution/batch settings
     try:
-        ctrl_w = int(control_res_w) if control_res_w else None
-        ctrl_h = int(control_res_h) if control_res_h else None
-        if image_type == "layered":
-            ctrl_w = None
-            ctrl_h = None
         _update_dataset_toml(
             ds_conf,
             img_res_w=int(train_res_w) if train_res_w else None,
             img_res_h=int(train_res_h) if train_res_h else None,
             train_batch_size=int(train_batch_size) if train_batch_size else None,
-            control_res_w=ctrl_w,
-            control_res_h=ctrl_h,
-            multiple_target=(image_type == "layered"),
+            control_res_w=int(control_res_w) if control_res_w else None,
+            control_res_h=int(control_res_h) if control_res_h else None,
+            multiple_target=False,
         )
-        if image_type == "layered":
-            log_buf += f"[QIE] Updated dataset config: resolution=({train_res_w},{train_res_h}), batch_size={train_batch_size}, multiple_target=true\n"
-        else:
-            log_buf += f"[QIE] Updated dataset config: resolution=({train_res_w},{train_res_h}), batch_size={train_batch_size}, control_res=({control_res_w},{control_res_h})\n"
+        log_buf += f"[QIE] Updated dataset config: resolution=({train_res_w},{train_res_h}), batch_size={train_batch_size}, control_res=({control_res_w},{control_res_h})\n"
     except Exception as e:
         log_buf += f"[QIE] WARN: failed to update dataset config: {e}\n"
     # Expose dataset config for download (if exists)
@@ -1004,39 +991,8 @@ def run_training(
         pass
     yield (log_buf, ckpts, artifacts, run_out_dir)
 
-    output_json = os.path.join(out_base, "metadata.jsonl")
-    if image_type == "layered":
-        _sync_dataset_config_jsonl(ds_conf, output_json)
-        log_buf += f"[QIE] Generating layered metadata: {output_json}\n"
-        yield (log_buf, ckpts, artifacts, run_out_dir)
-        try:
-            count = _generate_layered_jsonl(
-                image_dir=img_dir,
-                caption=caption,
-                output_json=output_json,
-                control_dirs=control_dirs_abs,
-                target_prefix=(target_prefix or ""),
-                target_suffix=(target_suffix or ""),
-                control_prefixes=control_prefixes,
-                control_suffixes=control_suffixes,
-                allow_single=True,
-            )
-            log_buf += f"[QIE] Layered metadata written: {count} entries\n"
-        except Exception as e:
-            log_buf += f"[ERROR] Layered metadata generation failed: {e}\n"
-            yield (log_buf, ckpts, artifacts, run_out_dir)
-            return
-
-        if os.path.isfile(output_json) and output_json not in artifacts:
-            artifacts.append(output_json)
-        yield (log_buf, ckpts, artifacts, run_out_dir)
-
-        if config_only:
-            log_buf += "[QIE] Config-only mode: skipping cache/training.\n"
-            yield (log_buf, ckpts, artifacts, run_out_dir)
-            return
-
     if config_only:
+        output_json = os.path.join(out_base, "metadata.jsonl")
         _sync_dataset_config_jsonl(ds_conf, output_json)
         log_buf += f"[QIE] Generating metadata: {output_json}\n"
         yield (log_buf, ckpts, artifacts, run_out_dir)
@@ -1142,6 +1098,293 @@ def run_training(
         yield (log_buf, ckpts, artifacts, run_out_dir)
 
 
+def run_training_layered(
+    output_name: str,
+    caption: str,
+    image_uploads: Any,
+    target_prefix: str,
+    target_suffix: str,
+    layer_prefix: str,
+    layer_suffix: str,
+    layer1_uploads: Any,
+    layer2_uploads: Any,
+    layer3_uploads: Any,
+    layer4_uploads: Any,
+    layer5_uploads: Any,
+    layer6_uploads: Any,
+    layer7_uploads: Any,
+    layer8_uploads: Any,
+    layer9_uploads: Any,
+    layer10_uploads: Any,
+    layer11_uploads: Any,
+    layer12_uploads: Any,
+    layer13_uploads: Any,
+    layer14_uploads: Any,
+    layer15_uploads: Any,
+    layer16_uploads: Any,
+    layer17_uploads: Any,
+    layer18_uploads: Any,
+    layer19_uploads: Any,
+    layer20_uploads: Any,
+    layer21_uploads: Any,
+    layer22_uploads: Any,
+    layer23_uploads: Any,
+    layer24_uploads: Any,
+    layer25_uploads: Any,
+    layer26_uploads: Any,
+    layer27_uploads: Any,
+    layer28_uploads: Any,
+    layer29_uploads: Any,
+    layer30_uploads: Any,
+    layer31_uploads: Any,
+    layer32_uploads: Any,
+    learning_rate: str,
+    network_dim: int,
+    train_res_w: int,
+    train_res_h: int,
+    train_batch_size: int,
+    te_cache_batch_size: int,
+    seed: int,
+    max_epochs: int,
+    save_every: int,
+    config_only: bool,
+) -> Iterable[tuple]:
+    log_buf = "[QIE] Start Training invoked.\n"
+    ckpts: List[str] = []
+    artifacts: List[str] = []
+    run_out_dir = ""
+    yield (log_buf, ckpts, artifacts, run_out_dir)
+    if not output_name.strip():
+        log_buf += "[ERROR] OUTPUT NAME is required.\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+    if not caption.strip():
+        log_buf += "[ERROR] CAPTION is required.\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+
+    image_type = _get_qwen_image_type()
+    log_buf += f"[QIE] Model type: {image_type}\n"
+    yield (log_buf, ckpts, artifacts, run_out_dir)
+    if image_type != "layered":
+        log_buf += "[ERROR] Layered タブは QWEN_IMAGE_TYPE=layered のみ対応です。環境変数を設定して再起動してください。\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+
+    _ensure_workspace_auto_files()
+    global DATA_ROOT_RUNTIME
+    DATA_ROOT_RUNTIME = _ensure_data_root(None)
+
+    import time
+    ds_name = f"dataset_{int(time.time())}"
+    ds_dir = os.path.abspath(os.path.join(DATA_ROOT_RUNTIME, ds_name))
+    run_out_dir = os.path.abspath(os.path.join(ds_dir, output_name.strip()))
+    img_folder_name = DEFAULT_IMAGE_FOLDER
+    img_dir = os.path.join(ds_dir, img_folder_name)
+    os.makedirs(img_dir, exist_ok=True)
+
+    base_files = _extract_paths(image_uploads)
+    if not base_files:
+        log_buf += "[ERROR] No images uploaded for IMAGE_FOLDER.\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+    base_filenames = _copy_uploads(base_files, img_dir)
+    log_buf += f"[QIE] Copied {len(base_filenames)} base images to {img_dir}\n"
+    yield (log_buf, ckpts, artifacts, run_out_dir)
+
+    layer_upload_sets = [
+        _extract_paths(layer1_uploads),
+        _extract_paths(layer2_uploads),
+        _extract_paths(layer3_uploads),
+        _extract_paths(layer4_uploads),
+        _extract_paths(layer5_uploads),
+        _extract_paths(layer6_uploads),
+        _extract_paths(layer7_uploads),
+        _extract_paths(layer8_uploads),
+        _extract_paths(layer9_uploads),
+        _extract_paths(layer10_uploads),
+        _extract_paths(layer11_uploads),
+        _extract_paths(layer12_uploads),
+        _extract_paths(layer13_uploads),
+        _extract_paths(layer14_uploads),
+        _extract_paths(layer15_uploads),
+        _extract_paths(layer16_uploads),
+        _extract_paths(layer17_uploads),
+        _extract_paths(layer18_uploads),
+        _extract_paths(layer19_uploads),
+        _extract_paths(layer20_uploads),
+        _extract_paths(layer21_uploads),
+        _extract_paths(layer22_uploads),
+        _extract_paths(layer23_uploads),
+        _extract_paths(layer24_uploads),
+        _extract_paths(layer25_uploads),
+        _extract_paths(layer26_uploads),
+        _extract_paths(layer27_uploads),
+        _extract_paths(layer28_uploads),
+        _extract_paths(layer29_uploads),
+        _extract_paths(layer30_uploads),
+        _extract_paths(layer31_uploads),
+        _extract_paths(layer32_uploads),
+    ]
+    if not layer_upload_sets[0]:
+        log_buf += "[ERROR] Layer 1 (image_path_1) images are required.\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+
+    layer_dirs: List[Optional[str]] = []
+    for i, uploads in enumerate(layer_upload_sets):
+        if not uploads:
+            layer_dirs.append(None)
+            continue
+        folder_name = f"layer_{i + 1}"
+        cdir = os.path.join(ds_dir, folder_name)
+        os.makedirs(cdir, exist_ok=True)
+        _copy_uploads(uploads, cdir)
+        layer_dirs.append(folder_name)
+        log_buf += f"[QIE] Copied {len(uploads)} layer_{i + 1} images to {cdir}\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+
+    layer_dirs_abs = [
+        (os.path.join(ds_dir, name) if name else None)
+        for name in layer_dirs
+    ]
+
+    ds_conf = str(Path(AUTO_DIR_RUNTIME) / "dataset_QIE.toml")
+    try:
+        _update_dataset_toml(
+            ds_conf,
+            img_res_w=int(train_res_w) if train_res_w else None,
+            img_res_h=int(train_res_h) if train_res_h else None,
+            train_batch_size=int(train_batch_size) if train_batch_size else None,
+            multiple_target=True,
+        )
+        log_buf += f"[QIE] Updated dataset config: resolution=({train_res_w},{train_res_h}), batch_size={train_batch_size}, multiple_target=true\n"
+    except Exception as e:
+        log_buf += f"[QIE] WARN: failed to update dataset config: {e}\n"
+    if os.path.isfile(ds_conf):
+        artifacts = [ds_conf]
+
+    models_root = MODELS_ROOT_RUNTIME
+    out_base = ds_dir
+    try:
+        os.makedirs(out_base, exist_ok=True)
+    except Exception:
+        pass
+
+    tmp_script = _prepare_script(
+        dataset_name=ds_name,
+        caption=caption,
+        data_root=DATA_ROOT_RUNTIME,
+        image_folder=img_folder_name,
+        control_folders=[],
+        models_root=models_root,
+        output_dir_base=out_base,
+        dataset_config=ds_conf,
+        override_max_epochs=max_epochs if max_epochs and max_epochs > 0 else None,
+        override_save_every=save_every if save_every and save_every > 0 else None,
+        override_run_name=output_name.strip(),
+        target_prefix=(target_prefix or ""),
+        target_suffix=(target_suffix or ""),
+        control_prefixes=[],
+        control_suffixes=[],
+        override_learning_rate=(learning_rate or None),
+        override_network_dim=int(network_dim) if network_dim is not None else None,
+        override_te_cache_bs=int(te_cache_batch_size) if te_cache_batch_size else None,
+        override_seed=int(seed) if seed is not None else None,
+    )
+
+    out_dir = os.path.join(out_base, output_name.strip())
+    run_out_dir = out_dir
+    ckpts = _list_checkpoints(out_dir)
+    used_script_path = os.path.join(out_base, "train_QIE_used.sh")
+    try:
+        shutil.copy2(str(tmp_script), used_script_path)
+        try:
+            os.chmod(used_script_path, 0o755)
+        except Exception:
+            pass
+        if used_script_path not in artifacts:
+            artifacts.append(used_script_path)
+    except Exception:
+        pass
+    yield (log_buf, ckpts, artifacts, run_out_dir)
+
+    output_json = os.path.join(out_base, "metadata.jsonl")
+    _sync_dataset_config_jsonl(ds_conf, output_json)
+    log_buf += f"[QIE] Generating layered metadata: {output_json}\n"
+    yield (log_buf, ckpts, artifacts, run_out_dir)
+
+    layer_prefixes = [layer_prefix or None for _ in range(LAYER_MAX)]
+    layer_suffixes = [layer_suffix or None for _ in range(LAYER_MAX)]
+    try:
+        count = _generate_layered_jsonl(
+            image_dir=img_dir,
+            caption=caption,
+            output_json=output_json,
+            control_dirs=layer_dirs_abs,
+            target_prefix=(target_prefix or ""),
+            target_suffix=(target_suffix or ""),
+            control_prefixes=layer_prefixes,
+            control_suffixes=layer_suffixes,
+            allow_single=True,
+        )
+        log_buf += f"[QIE] Layered metadata written: {count} entries\n"
+    except Exception as e:
+        log_buf += f"[ERROR] Layered metadata generation failed: {e}\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+
+    if os.path.isfile(output_json) and output_json not in artifacts:
+        artifacts.append(output_json)
+    yield (log_buf, ckpts, artifacts, run_out_dir)
+
+    if config_only:
+        log_buf += "[QIE] Config-only mode: skipping cache/training.\n"
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+        return
+
+    shell = _pick_shell()
+    log_buf += f"[QIE] Using shell: {shell}\n"
+    log_buf += f"[QIE] Running script: {tmp_script}\n"
+
+    child_env = os.environ.copy()
+    child_env["PYTHONUNBUFFERED"] = "1"
+    child_env["PYTHONIOENCODING"] = "utf-8"
+
+    proc = subprocess.Popen(
+        [shell, str(tmp_script)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        universal_newlines=True,
+        env=child_env,
+    )
+    try:
+        assert proc.stdout is not None
+        i = 0
+        for line in proc.stdout:
+            log_buf += line
+            i += 1
+            if i % 30 == 0:
+                ckpts = _list_checkpoints(out_dir)
+                metadata_json = os.path.join(out_base, "metadata.jsonl")
+                if os.path.isfile(metadata_json) and metadata_json not in artifacts:
+                    artifacts.append(metadata_json)
+            yield (log_buf, ckpts, artifacts, run_out_dir)
+    finally:
+        code = proc.wait()
+        try:
+            ckpts = _list_checkpoints(out_dir)
+        except Exception:
+            pass
+        log_buf += f"[QIE] Exit code: {code}\n"
+        metadata_json = os.path.join(out_base, "metadata.jsonl")
+        if os.path.isfile(metadata_json) and metadata_json not in artifacts:
+            artifacts.append(metadata_json)
+        yield (log_buf, ckpts, artifacts, run_out_dir)
+
+
 def build_ui() -> gr.Blocks:
     css = """
     .pad-section {
@@ -1167,8 +1410,24 @@ def build_ui() -> gr.Blocks:
     }
     """
     with gr.Blocks(title="Qwen-Image-Edit: Trainer", css=css) as demo:
+        # 回収ボタン: 直近の dataset_ ディレクトリからチェックポイントとスクリプト/設定を再取得
+        def _refresh_all() -> tuple:
+            try:
+                ds_dir = _find_latest_dataset_dir(DATA_ROOT_RUNTIME)
+            except Exception:
+                ds_dir = None
+            try:
+                ck = _list_checkpoints(ds_dir) if ds_dir else []
+            except Exception:
+                ck = []
+            try:
+                sc = _collect_scripts_and_config(ds_dir)
+            except Exception:
+                sc = _collect_scripts_and_config(None)
+            return ck, sc
+
         with gr.Tabs() as tabs:
-            with gr.TabItem("Training"):
+            with gr.TabItem("Edit"):
                 gr.Markdown("""
                 # Qwen-Image-Edit Trainer
                 学習に使う画像をアップロードし、必要ならファイル名の前後にある共通の文字（prefix/suffix）を指定して、
@@ -1355,28 +1614,126 @@ def build_ui() -> gr.Blocks:
                     outputs=[logs, ckpt_files, scripts_files, run_out_dir_box],
                 )
 
-                # 回収ボタン: 直近の dataset_ ディレクトリからチェックポイントとスクリプト/設定を再取得
-                def _refresh_all() -> tuple:
-                    try:
-                        ds_dir = _find_latest_dataset_dir(DATA_ROOT_RUNTIME)
-                    except Exception:
-                        ds_dir = None
-                    try:
-                        ck = _list_checkpoints(ds_dir) if ds_dir else []
-                    except Exception:
-                        ck = []
-                    try:
-                        sc = _collect_scripts_and_config(ds_dir)
-                    except Exception:
-                        sc = _collect_scripts_and_config(None)
-                    return ck, sc
-
                 refresh_scripts_btn.click(
                     fn=_refresh_all,
                     inputs=[],
                     outputs=[ckpt_files, scripts_files],
                 )
 
+            with gr.TabItem("Layered"):
+                gr.Markdown("""
+                # Qwen-Image-Layered Trainer
+                このタブは `QWEN_IMAGE_TYPE=layered` で起動したときのみ有効です。
+                """)
+
+                with gr.Accordion("Settings", elem_classes=["pad-section"]):
+                    with gr.Group():
+                        with gr.Row():
+                            output_name_layered = gr.Textbox(label="OUTPUT NAME", placeholder="my_lora_output", lines=1)
+                            caption_layered = gr.Textbox(label="CAPTION", placeholder="A photo of ...", lines=2)
+
+                        with gr.Row():
+                            lr_input_layered = gr.Textbox(label="Learning rate", value="1e-3")
+                            dim_input_layered = gr.Number(label="Network dim", value=4, precision=0)
+                            train_bs_layered = gr.Number(label="Batch size (dataset)", value=1, precision=0)
+                            seed_input_layered = gr.Number(label="Seed", value=42, precision=0)
+                            max_epochs_layered = gr.Number(label="Max epochs", value=100, precision=0)
+                            save_every_layered = gr.Number(label="Save every N epochs", value=10, precision=0)
+
+                        with gr.Row():
+                            tr_w_layered = gr.Number(label="Image resolution W", value=1024, precision=0)
+                            tr_h_layered = gr.Number(label="Image resolution H", value=1024, precision=0)
+                            te_bs_layered = gr.Number(label="TE cache batch size", value=16, precision=0)
+
+                with gr.Accordion("Base Image (image_path_0)", elem_classes=["pad-section_0"]):
+                    with gr.Group():
+                        with gr.Row():
+                            base_images_input = gr.File(label="Upload base images (image_path_0)", file_count="multiple", type="filepath", height=220, scale=3)
+                            base_gallery = gr.Gallery(label="Base preview", columns=4, height=220, object_fit='contain', preview=True, scale=3)
+                            with gr.Column(scale=1):
+                                with gr.Row():
+                                    base_prefix = gr.Textbox(label="Base prefix", placeholder="e.g., IMG_")
+                                    base_suffix = gr.Textbox(label="Base suffix", placeholder="e.g., _v2")
+                                with gr.Row():
+                                    layer_prefix = gr.Textbox(label="Layer prefix (all)", placeholder="")
+                                    layer_suffix = gr.Textbox(label="Layer suffix (all)", placeholder="")
+                                with gr.Accordion("prefix/sufixについて", open=False):
+                                    gr.Markdown("""
+                                    ファイル名の対応付けのルール:
+                                    - base画像のファイル名から Base prefix/suffix を取り除いたものを key とします。
+                                    - レイヤーは `Layer prefix + key + Layer suffix + .png` を探します。
+                                    - レイヤーが1枚のみのときは全ベース画像に適用します。
+                                    """)
+
+                layer_files: List[gr.File] = []
+                with gr.Accordion("Layer Images (image_path_1..32)", elem_classes=["pad-section_1"]):
+                    with gr.Group():
+                        for i in range(1, LAYER_MAX + 1, 2):
+                            with gr.Row():
+                                lf1 = gr.File(
+                                    label=f"Layer {i} (image_path_{i})",
+                                    file_count="multiple",
+                                    type="filepath",
+                                    height=120,
+                                    scale=1,
+                                )
+                                layer_files.append(lf1)
+                                if i + 1 <= LAYER_MAX:
+                                    lf2 = gr.File(
+                                        label=f"Layer {i + 1} (image_path_{i + 1})",
+                                        file_count="multiple",
+                                        type="filepath",
+                                        height=120,
+                                        scale=1,
+                                    )
+                                    layer_files.append(lf2)
+
+                with gr.Row():
+                    run_btn_layered = gr.Button("Start Training", variant="primary")
+                    config_btn_layered = gr.Button("設定のみ生成", variant="secondary")
+                run_out_dir_box_layered = gr.Textbox(label="出力フォルダ", lines=1, interactive=False)
+                scripts_files_layered = gr.Files(label="Scripts & Config (live)", interactive=False)
+                ckpt_files_layered = gr.Files(label="Checkpoints (live)", interactive=False)
+                logs_layered = gr.Textbox(label="Logs", lines=20)
+                with gr.Row():
+                    refresh_scripts_btn_layered = gr.Button("ファイルを再取得", variant="secondary")
+
+                base_images_input.change(fn=_files_to_gallery, inputs=base_images_input, outputs=base_gallery)
+
+                config_only_off_layered = gr.State(False)
+                config_only_on_layered = gr.State(True)
+
+                run_btn_layered.click(
+                    fn=run_training_layered,
+                    inputs=[
+                        output_name_layered, caption_layered, base_images_input, base_prefix, base_suffix,
+                        layer_prefix, layer_suffix,
+                        *layer_files,
+                        lr_input_layered, dim_input_layered,
+                        tr_w_layered, tr_h_layered, train_bs_layered, te_bs_layered,
+                        seed_input_layered, max_epochs_layered, save_every_layered, config_only_off_layered,
+                    ],
+                    outputs=[logs_layered, ckpt_files_layered, scripts_files_layered, run_out_dir_box_layered],
+                )
+                config_btn_layered.click(
+                    fn=run_training_layered,
+                    inputs=[
+                        output_name_layered, caption_layered, base_images_input, base_prefix, base_suffix,
+                        layer_prefix, layer_suffix,
+                        *layer_files,
+                        lr_input_layered, dim_input_layered,
+                        tr_w_layered, tr_h_layered, train_bs_layered, te_bs_layered,
+                        seed_input_layered, max_epochs_layered, save_every_layered, config_only_on_layered,
+                    ],
+                    outputs=[logs_layered, ckpt_files_layered, scripts_files_layered, run_out_dir_box_layered],
+                )
+
+                refresh_scripts_btn_layered.click(
+                    fn=_refresh_all,
+                    inputs=[],
+                    outputs=[ckpt_files_layered, scripts_files_layered],
+                )
+
             with gr.TabItem("Prompt Generator"):
                 gr.Markdown("""
                 # 🎨 A→B 変換プロンプト自動生成
@@ -1443,7 +1800,7 @@ if __name__ == "__main__":
     _startup_install_musubi_deps()
 
     # 2) Download models at startup (blocking by design)
-    _startup_download_models()
+    # _startup_download_models()
 
     # 3) Launch Gradio app
     ui = build_ui()