Implement initial project structure and setup

app.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+import gradio as gr
+
+# Local modules
+from download_qwen_image_models import download_all_models, DEFAULT_MODELS_DIR
+
+
+# Defaults matching train_QIE.sh expectations
+DEFAULT_DATA_ROOT = "/workspace/data"
+DEFAULT_IMAGE_FOLDER = "image"
+DEFAULT_OUTPUT_DIR_BASE = "/workspace/auto/train_LoRA"
+DEFAULT_DATASET_CONFIG = "/workspace/auto/dataset_QIE.toml"
+DEFAULT_MODELS_ROOT = DEFAULT_MODELS_DIR  # "/workspace/Qwen-Image_models"
+WORKSPACE_AUTO_DIR = "/workspace/auto"
+
+
+TRAINING_DIR = Path(__file__).resolve().parent
+
+
+def _bash_quote(s: str) -> str:
+    """Return a POSIX-safe single-quoted string literal representing s."""
+    if s is None:
+        return "''"
+    return "'" + str(s).replace("'", "'\"'\"'") + "'"
+
+
+def _ensure_workspace_auto_files() -> None:
+    """Ensure /workspace/auto has required helper files from this repo.
+
+    Copies training/create_image_caption_json.py and training/dataset_QIE.toml
+    into /workspace/auto so that train_QIE.sh can run unmodified.
+    """
+    os.makedirs(WORKSPACE_AUTO_DIR, exist_ok=True)
+    src_py = TRAINING_DIR / "create_image_caption_json.py"
+    src_toml = TRAINING_DIR / "dataset_QIE.toml"
+    dst_py = Path(WORKSPACE_AUTO_DIR) / "create_image_caption_json.py"
+    dst_toml = Path(WORKSPACE_AUTO_DIR) / "dataset_QIE.toml"
+
+    try:
+        shutil.copy2(src_py, dst_py)
+    except Exception:
+        pass
+    try:
+        if src_toml.exists():
+            shutil.copy2(src_toml, dst_toml)
+    except Exception:
+        pass
+
+
+def _prepare_script(
+    dataset_name: str,
+    caption: str,
+    data_root: str,
+    image_folder: str,
+    control_folders: List[Optional[str]],
+    models_root: str,
+    output_dir_base: Optional[str] = None,
+    dataset_config: Optional[str] = None,
+) -> Path:
+    """Create a temporary copy of train_QIE.sh with injected variables.
+
+    Only variables that must vary per-run are replaced. The rest of the script
+    remains as-is to preserve behavior.
+    """
+    src = TRAINING_DIR / "train_QIE.sh"
+    txt = src.read_text(encoding="utf-8")
+
+    # Replace core variables
+    replacements = {
+        r"^DATA_ROOT=\".*\"": f"DATA_ROOT={_bash_quote(data_root)}",
+        r"^DATASET_NAME=\".*\"": f"DATASET_NAME={_bash_quote(dataset_name)}",
+        r"^CAPTION=\".*\"": f"CAPTION={_bash_quote(caption)}",
+        r"^IMAGE_FOLDER=\".*\"": f"IMAGE_FOLDER={_bash_quote(image_folder)}",
+    }
+    if output_dir_base:
+        replacements[r"^OUTPUT_DIR_BASE=\".*\""] = (
+            f"OUTPUT_DIR_BASE={_bash_quote(output_dir_base)}"
+        )
+    if dataset_config:
+        replacements[r"^DATASET_CONFIG=\".*\""] = (
+            f"DATASET_CONFIG={_bash_quote(dataset_config)}"
+        )
+
+    for pat, val in replacements.items():
+        txt = re.sub(pat, val, txt, flags=re.MULTILINE)
+
+    # Inject CONTROL_FOLDER_i if provided (uncomment/override or append)
+    for i in range(8):
+        val = control_folders[i] if i < len(control_folders) else None
+        if not val:
+            continue
+        # Try to replace commented placeholder first
+        pattern = rf"^#\s*CONTROL_FOLDER_{i}=\".*\""
+        if re.search(pattern, txt, flags=re.MULTILINE):
+            txt = re.sub(
+                pattern,
+                f"CONTROL_FOLDER_{i}={_bash_quote(val)}",
+                txt,
+                flags=re.MULTILINE,
+            )
+        else:
+            # Append after IMAGE_FOLDER definition
+            txt = re.sub(
+                r"^(IMAGE_FOLDER=.*)$",
+                rf"\1\nCONTROL_FOLDER_{i}={_bash_quote(val)}",
+                txt,
+                count=1,
+                flags=re.MULTILINE,
+            )
+
+    # Point model paths to the selected models_root
+    def _replace_model_path(txt: str, key: str, rel: str) -> str:
+        return re.sub(
+            rf"--{key} \"[^\"]+\"",
+            f"--{key} \"{models_root.rstrip('/')}/{rel}\"",
+            txt,
+        )
+
+    txt = _replace_model_path(txt, "vae", "vae/diffusion_pytorch_model.safetensors")
+    txt = _replace_model_path(txt, "text_encoder", "text_encoder/qwen_2.5_vl_7b.safetensors")
+    txt = _replace_model_path(txt, "dit", "dit/qwen_image_edit_2509_bf16.safetensors")
+
+    # Write to a temp file alongside this repo for easier inspection
+    run_dir = TRAINING_DIR / ".gradio_runs"
+    run_dir.mkdir(parents=True, exist_ok=True)
+    tmp = run_dir / f"train_QIE_run_{os.getpid()}.sh"
+    tmp.write_text(txt, encoding="utf-8", newline="\n")
+    try:
+        os.chmod(tmp, 0o755)
+    except Exception:
+        pass
+    return tmp
+
+
+def _pick_shell() -> str:
+    for sh in ("bash", "sh"):
+        if shutil.which(sh):
+            return sh
+    raise RuntimeError("No POSIX shell found. Please install bash or sh.")
+
+
+def run_training(
+    dataset_name: str,
+    caption: str,
+    data_root: str,
+    image_folder: str,
+    control0: str,
+    control1: str,
+    control2: str,
+    control3: str,
+    control4: str,
+    control5: str,
+    control6: str,
+    control7: str,
+    models_root: str,
+    output_dir_base: str,
+    dataset_config: str,
+) -> Iterable[str]:
+    # Basic validation
+    if not dataset_name.strip():
+        yield "[ERROR] DATASET_NAME is required."
+        return
+    if not caption.strip():
+        yield "[ERROR] CAPTION is required."
+        return
+
+    # Ensure /workspace/auto holds helper files expected by the script
+    _ensure_workspace_auto_files()
+
+    # Prepare script with user parameters
+    control_folders = [
+        c if c.strip() else None
+        for c in [control0, control1, control2, control3, control4, control5, control6, control7]
+    ]
+    tmp_script = _prepare_script(
+        dataset_name=dataset_name.strip(),
+        caption=caption,
+        data_root=data_root.strip() or DEFAULT_DATA_ROOT,
+        image_folder=image_folder.strip() or DEFAULT_IMAGE_FOLDER,
+        control_folders=control_folders,
+        models_root=models_root.strip() or DEFAULT_MODELS_ROOT,
+        output_dir_base=(output_dir_base.strip() or None),
+        dataset_config=(dataset_config.strip() or None),
+    )
+
+    shell = _pick_shell()
+    yield f"[QIE] Using shell: {shell}"
+    yield f"[QIE] Running script: {tmp_script}"
+
+    # Run and stream output
+    proc = subprocess.Popen(
+        [shell, str(tmp_script)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        universal_newlines=True,
+    )
+    try:
+        assert proc.stdout is not None
+        for line in proc.stdout:
+            yield line.rstrip("\n")
+    finally:
+        code = proc.wait()
+        yield f"[QIE] Exit code: {code}"
+
+
+def build_ui() -> gr.Blocks:
+    with gr.Blocks(title="Qwen-Image-Edit: Trainer") as demo:
+        gr.Markdown("""
+        # Qwen-Image-Edit Trainer
+        - Downloads required models on startup.
+        - Generates metadata and trains via `train_QIE.sh`.
+        - Paths are POSIX-style (e.g., /workspace/...).
+        """)
+
+        with gr.Row():
+            dataset_name = gr.Textbox(label="DATASET_NAME (folder under DATA_ROOT)", placeholder="my_dataset", lines=1)
+            caption = gr.Textbox(label="CAPTION", placeholder="A photo of ...", lines=2)
+
+        with gr.Row():
+            data_root = gr.Textbox(label="DATA_ROOT", value=DEFAULT_DATA_ROOT)
+            image_folder = gr.Textbox(label="IMAGE_FOLDER", value=DEFAULT_IMAGE_FOLDER)
+
+        with gr.Accordion("Control folders (optional)", open=False):
+            c0 = gr.Textbox(label="CONTROL_FOLDER_0")
+            c1 = gr.Textbox(label="CONTROL_FOLDER_1")
+            c2 = gr.Textbox(label="CONTROL_FOLDER_2")
+            c3 = gr.Textbox(label="CONTROL_FOLDER_3")
+            c4 = gr.Textbox(label="CONTROL_FOLDER_4")
+            c5 = gr.Textbox(label="CONTROL_FOLDER_5")
+            c6 = gr.Textbox(label="CONTROL_FOLDER_6")
+            c7 = gr.Textbox(label="CONTROL_FOLDER_7")
+
+        with gr.Row():
+            models_root = gr.Textbox(label="Models root", value=DEFAULT_MODELS_ROOT)
+            output_dir_base = gr.Textbox(label="OUTPUT_DIR_BASE", value=DEFAULT_OUTPUT_DIR_BASE)
+            dataset_config = gr.Textbox(label="DATASET_CONFIG", value=DEFAULT_DATASET_CONFIG)
+
+        run_btn = gr.Button("Start Training", variant="primary")
+        logs = gr.Textbox(label="Logs", lines=20)
+
+        run_btn.click(
+            fn=run_training,
+            inputs=[
+                dataset_name, caption, data_root, image_folder,
+                c0, c1, c2, c3, c4, c5, c6, c7,
+                models_root, output_dir_base, dataset_config,
+            ],
+            outputs=logs,
+        )
+
+    return demo
+
+
+def _startup_download_models() -> None:
+    models_dir = DEFAULT_MODELS_ROOT
+    print(f"[QIE] Ensuring models in: {models_dir}")
+    try:
+        download_all_models(models_dir)
+    except Exception as e:
+        print(f"[QIE] Model download failed: {e}")
+
+
+if __name__ == "__main__":
+    # 1) Download models at startup (blocking by design)
+    _startup_download_models()
+
+    # 2) Launch Gradio app
+    ui = build_ui()
+    ui.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+

create_image_caption_json.py

@@ -0,0 +1,138 @@
+import os
+import json
+from typing import List, Dict
+
+
+IMAGE_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.bmp', '.gif')
+
+
+def _join_posix(base: str, name: str) -> str:
+    """Join path segments with forward slashes, avoiding duplicate separators."""
+    if not base:
+        return name
+    return base.rstrip('/') + '/' + name.lstrip('/')
+
+
+def _list_images(input_folder: str) -> List[str]:
+    files = []
+    for entry in sorted(os.listdir(input_folder)):
+        if entry.lower().endswith(IMAGE_EXTENSIONS):
+            full = os.path.join(input_folder, entry)
+            if os.path.isfile(full):
+                files.append(entry)
+    return files
+
+
+def _validate_controls_strict(filenames: List[str], control_dirs: List[str]) -> None:
+    """Strictly validate that for each filename, a corresponding file exists
+    in every specified control directory. Raises SystemExit on failure.
+    """
+    if not control_dirs:
+        return
+
+    missing: List[str] = []
+    for fname in filenames:
+        for idx, cdir in enumerate(control_dirs):
+            expected = os.path.join(cdir, fname)
+            if not os.path.exists(expected):
+                label = f"control_dir_{idx}"
+                missing.append(f"[{label}] {expected}")
+
+    if missing:
+        print("エラー: 以下のファイルが見つかりませんでした（strict）:")
+        for m in missing:
+            print(" - " + m)
+        print(f"合計 {len(missing)} 件の不足が見つかりました。処理を中断します。")
+        raise SystemExit(1)
+
+
+def _build_entry(
+    image_dir: str,
+    control_dirs: List[str],
+    caption: str,
+    image_filename: str,
+) -> Dict[str, str]:
+    entry: Dict[str, str] = {
+        "image_path": _join_posix(image_dir, image_filename),
+        "caption": caption,
+    }
+
+    if len(control_dirs) == 1:
+        entry["control_path"] = _join_posix(control_dirs[0], image_filename)
+    elif len(control_dirs) > 1:
+        for i, cdir in enumerate(control_dirs):
+            entry[f"control_path_{i}"] = _join_posix(cdir, image_filename)
+
+    return entry
+
+
+def create_image_caption_json_unified(
+    input_folder: str,
+    image_dir: str,
+    control_dirs: List[str],
+    caption: str,
+    output_json: str,
+) -> None:
+    """
+    指定されたフォルダ内の画像ファイルを処理し、キャプションと共にJSONLファイルを作成します。
+
+    - コントロール無し: {image_path, caption}
+    - 単一コントロール(--control_dir_0のみ): {image_path, control_path, caption}
+    - 複数コントロール(--control_dir_0..7): {image_path, control_path_0..N, caption}
+
+    欠損ファイルは strict に扱い、不足があればエラー終了します。
+    """
+    filenames = _list_images(input_folder)
+
+    # strict: すべての control_dir に同名ファイルが存在することを確認
+    _validate_controls_strict(filenames, control_dirs)
+
+    out_dir = os.path.dirname(output_json)
+    if out_dir:
+        os.makedirs(out_dir, exist_ok=True)
+
+    count = 0
+    with open(output_json, 'w', encoding='utf-8') as f:
+        for fname in filenames:
+            entry = _build_entry(image_dir, control_dirs, caption, fname)
+            f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+            count += 1
+
+    print(f"処理が完了しました。{count}件を書き出しました。結果は {output_json} に保存されました。")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description='画像とコントロールの対応JSONLを生成（厳格チェック）。')
+    parser.add_argument('-i', '--input-folder', required=True, help='入力ディレクトリ（画像ファイルを列挙）')
+    parser.add_argument('-c', '--caption', required=True, help='キャプション')
+    parser.add_argument('-o', '--output-json', default='metadata.jsonl', help='出力JSONLパス（既定: metadata.jsonl）')
+    parser.add_argument('--image-dir', default='/workspace/data/image', help='image_pathの親ディレクトリパス（JSON出力用）')
+
+    # 最大 control_dir_0..7 まで受け付け
+    for i in range(8):
+        parser.add_argument(
+            f'--control_dir_{i}',
+            dest=f'control_dir_{i}',
+            default=None,
+            help=f'control_path_{i}の親ディレクトリパス（JSON出力用）',
+        )
+
+    args = parser.parse_args()
+
+    # 収集: 指定された control_dir_* のみ（順序は0->7）
+    control_dirs: List[str] = []
+    for i in range(8):
+        val = getattr(args, f'control_dir_{i}')
+        if val is not None:
+            control_dirs.append(val)
+
+    create_image_caption_json_unified(
+        input_folder=args.input_folder,
+        image_dir=args.image_dir,
+        control_dirs=control_dirs,
+        caption=args.caption,
+        output_json=args.output_json,
+    )
+

dataset_QIE.toml

@@ -0,0 +1,11 @@
+[general]
+resolution = [1024, 1024]
+caption_extension = ".txt"
+batch_size = 1
+enable_bucket = true
+bucket_no_upscale = false
+
+[[datasets]]
+image_jsonl_file = "/workspace/data/zeke_/metadata.jsonl"
+cache_directory = "/cache"
+qwen_image_edit_control_resolution = [1024, 1024]

download_qwen_image_models.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+import os
+from typing import Dict
+from huggingface_hub import hf_hub_download
+
+# Enable hf_transfer for faster downloads
+os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+DEFAULT_MODELS_DIR = os.environ.get("QWEN_IMAGE_MODELS_DIR", 
+                                    "/workspace/Qwen-Image_models")
+# Temporary download root (requested: use /tmp instead of /workspace)
+TMP_DOWNLOAD_ROOT = os.environ.get("QWEN_IMAGE_TMP_DIR", "/tmp/qie_downloads")
+
+
+def _ensure_dirs(root: str) -> None:
+    os.makedirs(root, exist_ok=True)
+    os.makedirs(os.path.join(root, "dit"), exist_ok=True)
+    os.makedirs(os.path.join(root, "vae"), exist_ok=True)
+    os.makedirs(os.path.join(root, "text_encoder"), exist_ok=True)
+
+
+def _download_then_place(*, repo_id: str, filename: str, subfolder: str,
+                         component: str, models_dir: str) -> str:
+    """Download to /tmp and move to the final models_dir/component/filename.
+
+    Returns absolute path to the final placed file.
+    """
+    # Ensure temp and final directories
+    tmp_dir = os.path.join(TMP_DOWNLOAD_ROOT, component)
+    os.makedirs(tmp_dir, exist_ok=True)
+    final_dir = os.path.join(models_dir, component)
+    os.makedirs(final_dir, exist_ok=True)
+
+    print(f"[QIE] Downloading {component}: {repo_id}/{subfolder}/{filename}")
+    tmp_path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        subfolder=subfolder,
+        local_dir=tmp_dir,
+    )
+
+    final_path = os.path.join(final_dir, filename)
+    try:
+        # If target exists, replace it
+        if os.path.exists(final_path):
+            try:
+                os.remove(final_path)
+            except FileNotFoundError:
+                pass
+        # Move downloaded file into place
+        if os.path.abspath(tmp_path) != os.path.abspath(final_path):
+            os.replace(tmp_path, final_path)
+    except Exception:
+        # Fallback: copy if replace fails (e.g., cross-device)
+        import shutil
+        shutil.copy2(tmp_path, final_path)
+    return final_path
+
+
+def download_all_models(models_dir: str = DEFAULT_MODELS_DIR) -> Dict[str, str]:
+    """Download required Qwen-Image-Edit models into models_dir.
+
+    Returns a dict of component -> local file path.
+    """
+    _ensure_dirs(models_dir)
+
+    print(f"[QIE] Models directory: {models_dir}")
+
+    print("[QIE] Download dir (tmp):", TMP_DOWNLOAD_ROOT)
+    print("[QIE] Final models dir:", models_dir)
+
+    # Download to /tmp then move to final path
+    dit_path = _download_then_place(
+        repo_id="Comfy-Org/Qwen-Image-Edit_ComfyUI",
+        filename="qwen_image_edit_2509_bf16.safetensors",
+        subfolder="split_files/diffusion_models",
+        component="dit",
+        models_dir=models_dir,
+    )
+
+    print("[QIE] Downloading VAE model(s)...")
+    vae_main = _download_then_place(
+        repo_id="Qwen/Qwen-Image-Edit",
+        filename="diffusion_pytorch_model.safetensors",
+        subfolder="vae",
+        component="vae",
+        models_dir=models_dir,
+    )
+    vae_alt = _download_then_place(
+        repo_id="Comfy-Org/Qwen-Image_ComfyUI",
+        filename="qwen_image_vae.safetensors",
+        subfolder="split_files/vae",
+        component="vae",
+        models_dir=models_dir,
+    )
+
+    print("[QIE] Downloading Text Encoder...")
+    te_path = _download_then_place(
+        repo_id="Comfy-Org/Qwen-Image_ComfyUI",
+        filename="qwen_2.5_vl_7b.safetensors",
+        subfolder="split_files/text_encoders",
+        component="text_encoder",
+        models_dir=models_dir,
+    )
+
+    print("[QIE] All models downloaded successfully!")
+    return {
+        "dit": dit_path,
+        "vae_main": vae_main,
+        "vae_alt": vae_alt,
+        "text_encoder": te_path,
+        "root": models_dir,
+    }
+
+
+if __name__ == "__main__":
+    download_all_models()

train_QIE.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+
+# ==============================
+# Generate metadata.jsonl before training
+# Configure variables directly in this file.
+# No environment variable overrides are used.
+# ==============================
+
+DATA_ROOT="/workspace/data"
+DATASET_NAME=""
+
+# Required inputs
+CAPTION=""
+
+IMAGE_FOLDER="image"
+
+# CONTROL_FOLDER_0=""
+# CONTROL_FOLDER_1=""
+# CONTROL_FOLDER_2=""
+# CONTROL_FOLDER_3=""
+# CONTROL_FOLDER_4=""
+# CONTROL_FOLDER_5=""
+# CONTROL_FOLDER_6=""
+# CONTROL_FOLDER_7=""
+
+RUN_NAME="${DATASET_NAME%/}"
+DATASET_DIR="${DATA_ROOT%/}/${DATASET_NAME}"
+
+OUTPUT_DIR_BASE="/workspace/auto/train_LoRA"
+DATASET_CONFIG="/workspace/auto/dataset_QIE.toml"
+OUTPUT_JSON="${DATASET_DIR%/}/metadata.jsonl"
+
+# Build control args from folder names with auto-detect fallback
+CONTROL_ARGS=()
+for i in {0..7}; do
+  var="CONTROL_FOLDER_${i}"
+  folder_name=${!var}
+  cpath=""
+  if [[ -n "$folder_name" ]]; then
+    cpath="${DATASET_DIR%/}/$folder_name"
+  elif [[ -d "${DATASET_DIR%/}/control_${i}" ]]; then
+    cpath="${DATASET_DIR%/}/control_${i}"
+  elif [[ $i -eq 0 && -d "${DATASET_DIR%/}/control" ]]; then
+    # Special fallback: allow single control folder named "control" for control_0
+    cpath="${DATASET_DIR%/}/control"
+  fi
+  [[ -n "$cpath" ]] && CONTROL_ARGS+=("--control_dir_${i}" "$cpath")
+done
+
+# Sync dataset config's image_jsonl_file with OUTPUT_JSON if present
+if [[ -f "$DATASET_CONFIG" ]]; then
+  python - "$DATASET_CONFIG" "$OUTPUT_JSON" <<'PY'
+import sys, re
+path, out = sys.argv[1], sys.argv[2]
+txt = open(path, 'r', encoding='utf-8').read()
+new = re.sub(r"(?m)^\s*image_jsonl_file\s*=.*$", f'image_jsonl_file = "{out}"', txt)
+if new == txt and 'image_jsonl_file' not in txt:
+    new = txt.rstrip('\n') + f"\nimage_jsonl_file = \"{out}\"\n"
+open(path, 'w', encoding='utf-8').write(new)
+print(f"[QIE] Updated {path}: image_jsonl_file -> {out}")
+PY
+else
+  echo "[QIE] WARN: Dataset config not found at $DATASET_CONFIG. Ensure it points to $OUTPUT_JSON"
+fi
+
+cd /workspace/auto
+
+echo "[QIE] Generating metadata: $OUTPUT_JSON"
+python create_image_caption_json.py \
+  -i "${DATASET_DIR%/}/${IMAGE_FOLDER}" \
+  -c "$CAPTION" \
+  -o "$OUTPUT_JSON" \
+  --image-dir "${DATASET_DIR%/}/${IMAGE_FOLDER}" \
+  "${CONTROL_ARGS[@]}"
+
+cd /musubi-tuner
+
+python qwen_image_cache_latents.py  \
+--dataset_config "$DATASET_CONFIG" \
+--vae "/workspace/Qwen-Image_models/vae/diffusion_pytorch_model.safetensors" \
+--edit_plus \
+--vae_spatial_tile_sample_min_size 16384
+
+python qwen_image_cache_text_encoder_outputs.py  \
+--dataset_config "$DATASET_CONFIG"  \
+--text_encoder "/workspace/Qwen-Image_models/text_encoder/qwen_2.5_vl_7b.safetensors" \
+--edit_plus \
+--batch_size 16
+
+accelerate launch src/musubi_tuner/qwen_image_train_network.py \
+--edit_plus \
+--dit "/workspace/Qwen-Image_models/dit/qwen_image_edit_2509_bf16.safetensors" \
+--vae "/workspace/Qwen-Image_models/vae/diffusion_pytorch_model.safetensors" \
+--text_encoder "/workspace/Qwen-Image_models/text_encoder/qwen_2.5_vl_7b.safetensors" \
+--dataset_config "$DATASET_CONFIG"  \
+--mixed_precision bf16 \
+--sdpa \
+--timestep_sampling shift \
+--weighting_scheme none \
+--discrete_flow_shift 2.0  \
+--optimizer_type adamw8bit \
+--learning_rate 1e-3 \
+--gradient_checkpointing \
+--max_data_loader_n_workers 2 \
+--persistent_data_loader_workers \
+--network_module networks.lora_qwen_image \
+--network_dim 4 \
+--max_train_epochs 100 \
+--save_every_n_epochs 10 \
+--seed 42 \
+--output_dir "${OUTPUT_DIR_BASE}/${RUN_NAME}" \
+--output_name "${RUN_NAME}" \
+--ddp_gradient_as_bucket_view \
+--ddp_static_graph