Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,20 @@
+# Local env
+.venv/
+.DS_Store
+
+# Personal/source data
+00_raw/
+01_curated/
+02_captions/
+04_checkpoints/
+
+# Generated artifacts
+06_exports/
+07_kaggle/_kaggle_output_*/
+07_kaggle/checkpoints_dataset/
+07_kaggle/dataset/
+08_kaggle_eval/_kaggle_output_*/
+08_kaggle_eval/_pulled/
+
+# Temporary publish bundle output
+publish_bundle/

03_configs/auto_curate.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import csv
+import math
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+
+RAW_DIR = Path("/Users/mihai/mihai-lora-v2/00_raw")
+CURATED_DIR = Path("/Users/mihai/mihai-lora-v2/01_curated")
+SELECTION_CSV = CURATED_DIR / "selection.csv"
+
+TARGET_COUNT = 36
+MIN_SIDE = 720
+MAX_DHASH_DISTANCE = 6
+
+
+@dataclass
+class Item:
+    path: Path
+    width: int
+    height: int
+    sharpness: float
+    brightness: float
+    contrast: float
+    score: float
+    dhash: int
+
+
+def list_images(root: Path) -> list[Path]:
+    exts = {".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif"}
+    return sorted(
+        [p for p in root.iterdir() if p.is_file() and p.suffix.lower() in exts]
+    )
+
+
+def compute_dhash(gray: np.ndarray) -> int:
+    img = Image.fromarray(gray).resize((9, 8), Image.Resampling.BILINEAR)
+    arr = np.asarray(img, dtype=np.uint8)
+    bits = arr[:, 1:] > arr[:, :-1]
+    out = 0
+    for b in bits.flatten():
+        out = (out << 1) | int(bool(b))
+    return out
+
+
+def hamming(a: int, b: int) -> int:
+    return (a ^ b).bit_count()
+
+
+def laplacian_variance(gray: np.ndarray) -> float:
+    g = gray.astype(np.float32)
+    p = np.pad(g, ((1, 1), (1, 1)), mode="edge")
+    lap = p[:-2, 1:-1] + p[2:, 1:-1] + p[1:-1, :-2] + p[1:-1, 2:] - 4.0 * p[1:-1, 1:-1]
+    return float(np.var(lap))
+
+
+def image_metrics(path: Path) -> Item | None:
+    try:
+        with Image.open(path) as im:
+            im = im.convert("RGB")
+            w, h = im.size
+            if min(w, h) < MIN_SIDE:
+                return None
+            gray = np.asarray(im.convert("L"), dtype=np.uint8)
+            sharp = laplacian_variance(gray)
+            bright = float(np.mean(gray))
+            contrast = float(np.std(gray))
+            dh = compute_dhash(gray)
+    except Exception:
+        return None
+
+    return Item(
+        path=path,
+        width=w,
+        height=h,
+        sharpness=sharp,
+        brightness=bright,
+        contrast=contrast,
+        score=0.0,
+        dhash=dh,
+    )
+
+
+def robust_norm(vals: np.ndarray) -> np.ndarray:
+    if len(vals) == 0:
+        return vals
+    p10 = np.percentile(vals, 10)
+    p90 = np.percentile(vals, 90)
+    denom = max(1e-9, p90 - p10)
+    x = (vals - p10) / denom
+    return np.clip(x, 0.0, 1.0)
+
+
+def exposure_penalty(brightness: float) -> float:
+    center = 118.0
+    spread = 42.0
+    z = (brightness - center) / spread
+    return float(math.exp(-(z * z)))
+
+
+def curate(items: list[Item], target: int) -> tuple[list[Item], set[Path]]:
+    if not items:
+        return [], set()
+
+    sharp = robust_norm(np.array([i.sharpness for i in items], dtype=np.float32))
+    contrast = robust_norm(np.array([i.contrast for i in items], dtype=np.float32))
+
+    for idx, i in enumerate(items):
+        exp = exposure_penalty(i.brightness)
+        i.score = float(0.6 * sharp[idx] + 0.25 * contrast[idx] + 0.15 * exp)
+
+    ranked = sorted(items, key=lambda x: x.score, reverse=True)
+    keep: list[Item] = []
+    rejected: set[Path] = set()
+
+    for cand in ranked:
+        too_close = any(
+            hamming(cand.dhash, chosen.dhash) <= MAX_DHASH_DISTANCE for chosen in keep
+        )
+        if too_close:
+            rejected.add(cand.path)
+            continue
+        keep.append(cand)
+        if len(keep) >= target:
+            break
+
+    # If dedupe was too strict and we have fewer than target, backfill by score.
+    if len(keep) < target:
+        for cand in ranked:
+            if cand in keep:
+                continue
+            keep.append(cand)
+            if len(keep) >= target:
+                break
+
+    return keep, rejected
+
+
+def clear_curated_folder(curated_dir: Path) -> None:
+    for p in curated_dir.iterdir():
+        if p.is_file() and p.name not in {
+            ".gitkeep",
+            "curation-checklist.md",
+            "selection.csv",
+        }:
+            p.unlink()
+
+
+def main() -> None:
+    CURATED_DIR.mkdir(parents=True, exist_ok=True)
+    imgs = list_images(RAW_DIR)
+    items = [m for m in (image_metrics(p) for p in imgs) if m is not None]
+
+    keep, rejected_hash = curate(items, TARGET_COUNT)
+    keep_paths = {k.path for k in keep}
+
+    clear_curated_folder(CURATED_DIR)
+    for k in keep:
+        shutil.copy2(k.path, CURATED_DIR / k.path.name)
+
+    with SELECTION_CSV.open("w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(
+            [
+                "filename",
+                "keep",
+                "reason",
+                "score",
+                "sharpness",
+                "brightness",
+                "contrast",
+                "width",
+                "height",
+            ]
+        )
+        for it in sorted(items, key=lambda x: x.path.name):
+            if it.path in keep_paths:
+                reason = "selected_by_score"
+                keep_flag = "yes"
+            elif it.path in rejected_hash:
+                reason = "near_duplicate"
+                keep_flag = "no"
+            else:
+                reason = "below_cutoff"
+                keep_flag = "no"
+
+            w.writerow(
+                [
+                    it.path.name,
+                    keep_flag,
+                    reason,
+                    f"{it.score:.4f}",
+                    f"{it.sharpness:.2f}",
+                    f"{it.brightness:.2f}",
+                    f"{it.contrast:.2f}",
+                    it.width,
+                    it.height,
+                ]
+            )
+
+    print(f"raw_images={len(imgs)}")
+    print(f"usable_images={len(items)}")
+    print(f"curated_selected={len(keep)}")
+    print(f"selection_csv={SELECTION_CSV}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/build_eval_contact_sheet.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+
+ROOT = Path(
+    "/Users/mihai/mihai-lora-v2/07_kaggle/_kaggle_output_v18/output/mihai_lora_v2/eval"
+)
+OUT = Path("/Users/mihai/mihai-lora-v2/06_exports/eval_contact_sheet_v18.png")
+
+CHECKPOINTS = [
+    "mihai_lora_v2_000001200",
+    "mihai_lora_v2_000001400",
+    "mihai_lora_v2_000001500",
+    "mihai_lora_v2",
+]
+
+PROMPTS = [
+    "p1_seed43.png",
+    "p2_seed44.png",
+    "p3_seed45.png",
+]
+
+
+def main() -> None:
+    sample = Image.open(ROOT / CHECKPOINTS[0] / PROMPTS[0]).convert("RGB")
+    w, h = sample.size
+    pad = 20
+    label_h = 50
+    grid_w = len(CHECKPOINTS) * w + (len(CHECKPOINTS) + 1) * pad
+    grid_h = len(PROMPTS) * h + (len(PROMPTS) + 1) * pad + label_h
+
+    canvas = Image.new("RGB", (grid_w, grid_h), (20, 20, 20))
+    draw = ImageDraw.Draw(canvas)
+
+    # Column labels
+    for col, ck in enumerate(CHECKPOINTS):
+        x = pad + col * (w + pad)
+        draw.text((x, 10), ck, fill=(230, 230, 230))
+
+    for row, prompt in enumerate(PROMPTS):
+        y = label_h + pad + row * (h + pad)
+        for col, ck in enumerate(CHECKPOINTS):
+            x = pad + col * (w + pad)
+            img = Image.open(ROOT / ck / prompt).convert("RGB")
+            canvas.paste(img, (x, y))
+
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    canvas.save(OUT)
+    print(f"saved={OUT}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/build_replicate_bundle.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+ROOT = Path("/Users/mihai/mihai-lora-v2")
+CURATED_DIR = ROOT / "01_curated"
+CAPTIONS_DIR = ROOT / "02_captions"
+BUNDLE_DIR = ROOT / "03_configs" / "replicate_bundle"
+ZIP_BASE = ROOT / "03_configs" / "replicate_bundle_v2"
+
+
+def list_images() -> list[Path]:
+    exts = {".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif"}
+    return sorted(
+        [p for p in CURATED_DIR.iterdir() if p.is_file() and p.suffix.lower() in exts]
+    )
+
+
+def main() -> None:
+    if BUNDLE_DIR.exists():
+        shutil.rmtree(BUNDLE_DIR)
+    BUNDLE_DIR.mkdir(parents=True, exist_ok=True)
+
+    imgs = list_images()
+    copied = 0
+    for img in imgs:
+        txt = CAPTIONS_DIR / f"{img.stem}.txt"
+        if not txt.exists():
+            continue
+        shutil.copy2(img, BUNDLE_DIR / img.name)
+        shutil.copy2(txt, BUNDLE_DIR / txt.name)
+        copied += 1
+
+    zip_path = shutil.make_archive(str(ZIP_BASE), "zip", str(BUNDLE_DIR))
+    print(f"paired_items={copied}")
+    print(f"bundle_dir={BUNDLE_DIR}")
+    print(f"zip_file={zip_path}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/colab-free-runbook.md

@@ -0,0 +1,60 @@
+# Colab Free Runbook (Quality-first, no paid plan)
+
+This runbook assumes Colab paid plans are unavailable in your country.
+
+## Decision
+
+- Primary: Colab free tier with chunked resume-safe training.
+- Fallback: Kaggle notebook continuation from checkpoint.
+- Keep config stable for baseline quality comparison.
+
+## Prereqs
+
+- Prepared dataset: 36 image+caption pairs.
+- Trigger token: `mihai`.
+- Drive folder for persistence.
+
+## Drive layout
+
+- `MyDrive/mihai-lora-v2-colab/data`
+- `MyDrive/mihai-lora-v2-colab/checkpoints`
+- `MyDrive/mihai-lora-v2-colab/samples`
+- `MyDrive/mihai-lora-v2-colab/logs`
+
+## Baseline training settings
+
+- Model: `black-forest-labs/FLUX.1-dev`
+- Steps: `1600`
+- Chunk size: `400`
+- Learning rate: `0.00015`
+- LoRA rank: `16`
+- Resolution: `1024`
+- Batch size: `1`
+- Save every: `100`
+- Validation sample every: `100`
+
+## Chunk schedule
+
+- Session A: `0 -> 400`
+- Session B: `401 -> 800`
+- Session C: `801 -> 1200`
+- Session D: `1201 -> 1600`
+
+Always resume from the latest checkpoint in Drive.
+
+## Runtime rules
+
+- Never store active checkpoints in `/content` only.
+- After disconnect, reconnect runtime and resume.
+- Do not change dataset/captions/hparams mid-baseline.
+
+## Checkpoint selection
+
+Evaluate checkpoints at `1000, 1200, 1400, 1600` using fixed prompts and seeds.
+Pick best realism/likeness checkpoint, not necessarily the final step.
+
+## If Colab GPU is unavailable
+
+- Move to Kaggle notebook.
+- Use the same dataset, prompts, seeds, and hyperparameters.
+- Continue from last Drive checkpoint.

03_configs/colab_cells_template.py

@@ -0,0 +1,129 @@
+# Copy these blocks into a Colab notebook as separate cells.
+
+# CELL 1
+from google.colab import drive
+drive.mount('/content/drive')
+
+
+# CELL 2
+from pathlib import Path
+
+ROOT = Path('/content/drive/MyDrive/mihai-lora-v2-colab')
+DATA_DIR = ROOT / 'data'
+OUT_DIR = ROOT / 'checkpoints'
+SAMPLES_DIR = ROOT / 'samples'
+LOG_DIR = ROOT / 'logs'
+
+TRIGGER = 'mihai'
+TOTAL_STEPS = 1600
+CHUNK_SIZE = 400
+SAVE_EVERY = 100
+SAMPLE_EVERY = 100
+LR = 1.5e-4
+RANK = 16
+RESOLUTION = 1024
+BATCH_SIZE = 1
+
+for p in [DATA_DIR, OUT_DIR, SAMPLES_DIR, LOG_DIR]:
+    p.mkdir(parents=True, exist_ok=True)
+
+print('ROOT', ROOT)
+
+
+# CELL 3 (optional unzip)
+import zipfile
+
+SRC_ZIP = '/content/drive/MyDrive/replicate_bundle_v2.zip'
+if Path(SRC_ZIP).exists():
+    with zipfile.ZipFile(SRC_ZIP, 'r') as zf:
+        zf.extractall(DATA_DIR)
+    print('Extracted dataset zip.')
+else:
+    print('Dataset zip missing. Copy files manually into data/.')
+
+
+# CELL 4
+%cd /content
+!git clone https://github.com/ostris/ai-toolkit.git
+%cd /content/ai-toolkit
+!pip -q install -r requirements.txt
+!pip -q install accelerate bitsandbytes transformers diffusers safetensors
+
+
+# CELL 5
+import re
+
+def latest_ckpt(path: Path):
+    if not path.exists():
+        return None, 0
+    cands = []
+    for p in path.glob('**/*'):
+        if p.is_file() and p.suffix in {'.safetensors', '.pt', '.bin'}:
+            m = re.search(r'(\d+)', p.stem)
+            step = int(m.group(1)) if m else -1
+            cands.append((step, p))
+    if not cands:
+        return None, 0
+    step, p = sorted(cands, key=lambda x: x[0])[-1]
+    return str(p), max(step, 0)
+
+resume_path, done_steps = latest_ckpt(OUT_DIR)
+print('resume_path', resume_path)
+print('done_steps', done_steps)
+
+
+# CELL 6
+start_step = done_steps
+end_step = min(done_steps + CHUNK_SIZE, TOTAL_STEPS)
+print(f'Chunk {start_step} -> {end_step}')
+
+
+# CELL 7
+cfg_text = f"""
+job: extension
+config:
+  name: mihai_lora_v2
+  process:
+    - type: sd_trainer
+      training_folder: "{ROOT}/runs"
+      device: cuda:0
+      network:
+        type: lora
+        linear: {RANK}
+        linear_alpha: {RANK}
+      save:
+        dtype: float16
+        save_every: {SAVE_EVERY}
+        max_step_saves_to_keep: 20
+      datasets:
+        - folder_path: "{DATA_DIR}"
+          caption_ext: "txt"
+          default_caption: "photo of {TRIGGER}"
+          resolution: [{RESOLUTION}, {RESOLUTION}]
+      train:
+        batch_size: {BATCH_SIZE}
+        steps: {end_step}
+        lr: {LR}
+        gradient_accumulation_steps: 4
+      model:
+        name_or_path: "black-forest-labs/FLUX.1-dev"
+"""
+
+cfg_path = ROOT / 'train_chunk.yaml'
+cfg_path.write_text(cfg_text)
+print('Wrote', cfg_path)
+
+
+# CELL 8
+%cd /content/ai-toolkit
+resume_arg = f'--resume "{resume_path}"' if resume_path else ''
+cmd = f'python run.py --config "{ROOT}/train_chunk.yaml" {resume_arg}'
+print(cmd)
+!{cmd}
+
+
+# CELL 9
+resume_path, done_steps = latest_ckpt(OUT_DIR)
+print('latest', resume_path)
+print('done_steps', done_steps)
+print('target', TOTAL_STEPS)

03_configs/create_publish_bundle.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+ROOT = Path("/Users/mihai/mihai-lora-v2")
+BUNDLE = ROOT / "publish_bundle"
+
+FILES = [
+    ".gitignore",
+    "README-public.md",
+    "PUBLISHING.md",
+    "README.md",
+    "03_configs/auto_curate.py",
+    "03_configs/build_eval_contact_sheet.py",
+    "03_configs/build_replicate_bundle.py",
+    "02_captions/caption-template.txt",
+    "05_validation/fixed-prompts.txt",
+    "03_configs/colab-free-runbook.md",
+    "03_configs/colab_cells_template.py",
+    "03_configs/create_publish_bundle.py",
+    "03_configs/generate_captions.py",
+    "03_configs/kaggle-runbook.md",
+    "03_configs/kaggle_cli_workflow.sh",
+    "03_configs/monitor_kaggle_run.sh",
+    "03_configs/prepare_kaggle_assets.py",
+    "03_configs/prepare_kaggle_checkpoints.py",
+    "03_configs/replicate-v2-run-plan.md",
+    "03_configs/replicate_run_commands.md",
+    "07_kaggle/train_flux_lora.py",
+    "07_kaggle/kernel-metadata.template.json",
+    "07_kaggle/dataset-metadata.template.json",
+    "08_kaggle_eval/evaluate_checkpoints.py",
+    "08_kaggle_eval/kernel-metadata.json",
+]
+
+
+def copy_file(rel: str) -> None:
+    src = ROOT / rel
+    if not src.exists():
+        return
+    dst = BUNDLE / rel
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(src, dst)
+
+
+def main() -> None:
+    if BUNDLE.exists():
+        shutil.rmtree(BUNDLE)
+    BUNDLE.mkdir(parents=True, exist_ok=True)
+
+    for rel in FILES:
+        copy_file(rel)
+
+    print(f"bundle_created={BUNDLE}")
+    print(f"files_copied={len([p for p in BUNDLE.rglob('*') if p.is_file()])}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/generate_captions.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from pathlib import Path
+
+
+CURATED_DIR = Path("/Users/mihai/mihai-lora-v2/01_curated")
+CAPTIONS_DIR = Path("/Users/mihai/mihai-lora-v2/02_captions")
+TRIGGER = "mihai"
+
+BASE_CAPTIONS = [
+    "photo of {t}, professional headshot, natural skin texture, soft studio lighting, clean background",
+    "photo of {t}, business portrait, realistic lighting, subtle expression, office-style background",
+    "photo of {t}, close-up professional portrait, photorealistic, neutral background, high detail",
+    "photo of {t}, upper body business headshot, natural skin detail, soft key light, minimal background",
+]
+
+
+def list_curated_images() -> list[Path]:
+    exts = {".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif"}
+    return sorted(
+        [p for p in CURATED_DIR.iterdir() if p.is_file() and p.suffix.lower() in exts]
+    )
+
+
+def clear_old_captions() -> None:
+    for p in CAPTIONS_DIR.iterdir():
+        if (
+            p.is_file()
+            and p.suffix.lower() == ".txt"
+            and p.name != "caption-template.txt"
+        ):
+            p.unlink()
+
+
+def main() -> None:
+    CAPTIONS_DIR.mkdir(parents=True, exist_ok=True)
+    clear_old_captions()
+    imgs = list_curated_images()
+
+    for idx, img in enumerate(imgs):
+        template = BASE_CAPTIONS[idx % len(BASE_CAPTIONS)]
+        caption = template.format(t=TRIGGER)
+        out = CAPTIONS_DIR / f"{img.stem}.txt"
+        out.write_text(caption + "\n", encoding="utf-8")
+
+    print(f"curated_images={len(imgs)}")
+    print(f"captions_written={len(imgs)}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/kaggle-runbook.md

@@ -0,0 +1,42 @@
+# Kaggle Runbook (Free-tier)
+
+## Cost
+
+- Kaggle notebooks and GPU quota are free-tier based.
+- You do not pay by default.
+- Limits apply (GPU availability, weekly/session quotas).
+
+## One-time setup
+
+1. Install Kaggle credentials:
+   - Download `kaggle.json` from your Kaggle account.
+   - Place at `~/.kaggle/kaggle.json`.
+   - `chmod 600 ~/.kaggle/kaggle.json`
+2. Export username:
+   - `export KAGGLE_USERNAME="your-kaggle-username"`
+
+## Launch flow
+
+Run:
+
+```bash
+/Users/mihai/mihai-lora-v2/03_configs/kaggle_cli_workflow.sh
+```
+
+This will:
+
+- Prepare Kaggle dataset assets from `replicate_bundle_v2.zip`.
+- Create or version dataset `KAGGLE_USERNAME/mihai-lora-v2-data`.
+- Push kernel `KAGGLE_USERNAME/mihai-flux-lora-v2`.
+
+## Monitor job status
+
+```bash
+/Users/mihai/mihai-lora-v2/.venv/bin/kaggle kernels status KAGGLE_USERNAME/mihai-flux-lora-v2
+```
+
+## Kernel source
+
+- `07_kaggle/train_flux_lora.py`
+- Uses chunked training and resume detection.
+- Writes outputs to `/kaggle/working/output`.

03_configs/kaggle_cli_workflow.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+VENV_KAGGLE="/Users/mihai/mihai-lora-v2/.venv/bin/kaggle"
+ROOT="/Users/mihai/mihai-lora-v2"
+
+if [[ -z "${KAGGLE_USERNAME:-}" ]]; then
+  echo "KAGGLE_USERNAME is missing"
+  exit 1
+fi
+
+if [[ -z "${KAGGLE_API_TOKEN:-}" && ! -f "$HOME/.kaggle/kaggle.json" ]]; then
+  echo "Missing auth. Set KAGGLE_API_TOKEN or install ~/.kaggle/kaggle.json"
+  exit 1
+fi
+
+python3 "$ROOT/03_configs/prepare_kaggle_assets.py"
+
+echo "Creating or updating Kaggle dataset..."
+if "$VENV_KAGGLE" datasets status "${KAGGLE_USERNAME}/mihai-lora-v2-data" >/dev/null 2>&1; then
+  "$VENV_KAGGLE" datasets version -p "$ROOT/07_kaggle/dataset" -m "Update LoRA v2 training zip"
+else
+  "$VENV_KAGGLE" datasets create -p "$ROOT/07_kaggle/dataset"
+fi
+
+echo "Pushing Kaggle kernel..."
+"$VENV_KAGGLE" kernels push -p "$ROOT/07_kaggle"
+
+echo "Kernel launched. Monitor with:"
+echo "  $VENV_KAGGLE kernels status ${KAGGLE_USERNAME}/mihai-flux-lora-v2"

03_configs/monitor_kaggle_run.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ -z "${KAGGLE_API_TOKEN:-}" ]]; then
+  echo "KAGGLE_API_TOKEN is missing"
+  exit 1
+fi
+
+KERNEL_REF="mihaichindris/mihai-flux-lora-v2"
+OUT_DIR="/Users/mihai/mihai-lora-v2/07_kaggle/_kaggle_output_latest"
+KAGGLE_BIN="/Users/mihai/mihai-lora-v2/.venv/bin/kaggle"
+
+echo "Monitoring ${KERNEL_REF}..."
+while true; do
+  STATUS_LINE=$("$KAGGLE_BIN" kernels status "$KERNEL_REF")
+  echo "$(date '+%Y-%m-%d %H:%M:%S')  $STATUS_LINE"
+
+  if [[ "$STATUS_LINE" == *"RUNNING"* || "$STATUS_LINE" == *"QUEUED"* ]]; then
+    sleep 45
+    continue
+  fi
+
+  mkdir -p "$OUT_DIR"
+  "$KAGGLE_BIN" kernels output "$KERNEL_REF" -p "$OUT_DIR" || true
+  echo "Run finished with status: $STATUS_LINE"
+  echo "Outputs (if any) downloaded to: $OUT_DIR"
+  break
+done

03_configs/prepare_kaggle_assets.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+
+ROOT = Path("/Users/mihai/mihai-lora-v2")
+KAGGLE_DIR = ROOT / "07_kaggle"
+ZIP_SRC = ROOT / "03_configs" / "replicate_bundle_v2.zip"
+
+
+def fill_template(template_path: Path, out_path: Path, username: str) -> None:
+    text = template_path.read_text(encoding="utf-8")
+    text = text.replace("__KAGGLE_USERNAME__", username)
+    out_path.write_text(text, encoding="utf-8")
+
+
+def main() -> None:
+    username = os.getenv("KAGGLE_USERNAME", "")
+    if not username:
+        raise SystemExit("Set KAGGLE_USERNAME in your environment first.")
+
+    if not ZIP_SRC.exists():
+        raise SystemExit(f"Missing zip bundle: {ZIP_SRC}")
+
+    data_dir = KAGGLE_DIR / "dataset"
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    shutil.copy2(ZIP_SRC, data_dir / "replicate_bundle_v2.zip")
+
+    fill_template(
+        KAGGLE_DIR / "dataset-metadata.template.json",
+        data_dir / "dataset-metadata.json",
+        username,
+    )
+    fill_template(
+        KAGGLE_DIR / "kernel-metadata.template.json",
+        KAGGLE_DIR / "kernel-metadata.json",
+        username,
+    )
+
+    print(f"Prepared Kaggle assets for username={username}")
+    print(f"Dataset dir: {data_dir}")
+    print(f"Kernel metadata: {KAGGLE_DIR / 'kernel-metadata.json'}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/prepare_kaggle_checkpoints.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from pathlib import Path
+
+
+ROOT = Path("/Users/mihai/mihai-lora-v2")
+KAGGLE_DIR = ROOT / "07_kaggle"
+CHECKPOINT_DATASET_DIR = KAGGLE_DIR / "checkpoints_dataset"
+
+
+def latest_output_dir() -> Path:
+    candidates = list(KAGGLE_DIR.glob("_kaggle_output_v*/output/mihai_lora_v2"))
+    if not candidates:
+        raise SystemExit("No local Kaggle output folders found")
+
+    def version_key(p: Path) -> int:
+        name = p.parts[-3]  # _kaggle_output_v14
+        digits = "".join(ch for ch in name if ch.isdigit())
+        return int(digits) if digits else -1
+
+    return sorted(candidates, key=version_key)[-1]
+
+
+def main() -> None:
+    username = os.getenv("KAGGLE_USERNAME", "")
+    if not username:
+        raise SystemExit("Set KAGGLE_USERNAME first")
+
+    latest_out = latest_output_dir()
+    if not latest_out.exists():
+        raise SystemExit(f"Missing latest output folder: {latest_out}")
+
+    if CHECKPOINT_DATASET_DIR.exists():
+        shutil.rmtree(CHECKPOINT_DATASET_DIR)
+    CHECKPOINT_DATASET_DIR.mkdir(parents=True, exist_ok=True)
+
+    copied = 0
+    for p in sorted(latest_out.glob("*.safetensors")):
+        shutil.copy2(p, CHECKPOINT_DATASET_DIR / p.name)
+        copied += 1
+
+    opt = latest_out / "optimizer.pt"
+    if opt.exists():
+        shutil.copy2(opt, CHECKPOINT_DATASET_DIR / opt.name)
+
+    meta = {
+        "id": f"{username}/mihai-lora-v2-checkpoints",
+        "title": "Mihai LoRA v2 Checkpoints",
+        "licenses": [{"name": "CC0-1.0"}],
+    }
+    (CHECKPOINT_DATASET_DIR / "dataset-metadata.json").write_text(
+        json.dumps(meta, indent=2) + "\n", encoding="utf-8"
+    )
+
+    kernel_meta_path = KAGGLE_DIR / "kernel-metadata.json"
+    kernel_meta = json.loads(kernel_meta_path.read_text(encoding="utf-8"))
+    data_sources = set(kernel_meta.get("dataset_sources", []))
+    data_sources.add(f"{username}/mihai-lora-v2-data")
+    data_sources.add(f"{username}/mihai-lora-v2-checkpoints")
+    kernel_meta["dataset_sources"] = sorted(data_sources)
+    kernel_meta_path.write_text(
+        json.dumps(kernel_meta, indent=2) + "\n", encoding="utf-8"
+    )
+
+    print(f"copied_checkpoints={copied}")
+    print(f"source_output={latest_out}")
+    print(f"checkpoint_dataset_dir={CHECKPOINT_DATASET_DIR}")
+    print(f"kernel_sources={kernel_meta['dataset_sources']}")
+
+
+if __name__ == "__main__":
+    main()

03_configs/replicate-v2-run-plan.md

@@ -0,0 +1,69 @@
+# Replicate v2 run plan (FLUX.1-dev LoRA)
+
+This run plan is designed for `ostris/flux-dev-lora-trainer` and keeps your old model untouched.
+
+## Sources used
+
+- Replicate trainer README: recommends 1000-3000 steps and high-res images (~1024).
+- Replicate fast trainer README: supports subject/style mode, auto-captioning, and optional per-image `.txt` captions.
+- Hugging Face FLUX QLoRA post (consumer fine-tuning focus).
+- Recent community ComfyUI/ai-toolkit practice for identity LoRAs.
+
+## Dataset targets
+
+- 24-36 curated images.
+- Keep visual variety: lighting, angles, outfits, backgrounds.
+- Avoid low-quality, filtered, or heavily compressed images.
+- Caption style: include trigger token in every caption.
+- Current bundle: 36 image+caption pairs in `replicate_bundle_v2.zip`.
+
+## Trigger token
+
+- Primary token: `mihai`
+- Keep exact token stable across all runs.
+
+## Baseline run
+
+- steps: 1600
+- learning_rate: 0.00015
+- rank: 16
+- resolution: 1024
+- batch_size: 1
+
+Training type: subject
+
+Rationale: lower LR than old v1 (`0.0004`) to reduce overfitting/plastic artifacts.
+
+## Sweep matrix
+
+Run A (identity-stable)
+- steps: 1400
+- learning_rate: 0.00012
+- rank: 16
+
+Run B (baseline)
+- steps: 1600
+- learning_rate: 0.00015
+- rank: 16
+
+Run C (capacity test)
+- steps: 1800
+- learning_rate: 0.00012
+- rank: 32
+
+Optional Run D (faster convergence check)
+- trainer: replicate/fast-flux-trainer
+- steps: 1400
+- type: subject
+
+## Selection criteria
+
+- Face likeness at 100% zoom.
+- Natural skin texture (no wax/plastic look).
+- Eyes/teeth/ears symmetry and realism.
+- Consistency across business prompts.
+
+## Output naming
+
+- model: `mihai-chindris/image-generator-v2`
+- checkpoints: `v2-runA`, `v2-runB`, `v2-runC`

03_configs/replicate_run_commands.md

@@ -0,0 +1,49 @@
+# Replicate training commands
+
+Use this with `REPLICATE_API_TOKEN` set in your shell.
+
+## Option 1: Official FLUX trainer
+
+Endpoint model: `ostris/flux-dev-lora-trainer`
+
+```bash
+curl -s -X POST https://api.replicate.com/v1/trainings \
+  -H "Authorization: Bearer $REPLICATE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "version": "26dce37a",
+    "destination": "mihai-chindris/image-generator-v2",
+    "input": {
+      "trigger_word": "mihai",
+      "steps": 1600,
+      "learning_rate": 0.00015,
+      "lora_rank": 16,
+      "input_images": "https://YOUR_PUBLIC_FILE_URL/replicate_bundle_v2.zip"
+    }
+  }'
+```
+
+## Option 2: Fast FLUX trainer
+
+Endpoint model: `replicate/fast-flux-trainer`
+
+```bash
+curl -s -X POST https://api.replicate.com/v1/trainings \
+  -H "Authorization: Bearer $REPLICATE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "destination": "mihai-chindris/image-generator-v2-fast",
+    "input": {
+      "trigger_word": "mihai",
+      "type": "subject",
+      "steps": 1400,
+      "input_images": "https://YOUR_PUBLIC_FILE_URL/replicate_bundle_v2.zip"
+    }
+  }'
+```
+
+Notes:
+
+- Upload the zip to a public URL first (or use the Replicate web uploader).
+- Keep trigger word exactly `mihai`.
+- Start with one baseline run, then run sweep variants from `replicate-v2-run-plan.md`.

05_validation/fixed-prompts.txt

@@ -0,0 +1,12 @@
+# Fixed validation prompts (use for all runs)
+
+1. professional LinkedIn headshot of mihai, navy blazer, soft studio key light, neutral gray background, photorealistic
+2. corporate profile photo of mihai, white shirt and dark jacket, modern office blur background, natural skin texture
+3. executive headshot of mihai, slight smile, 85mm portrait look, clean background, realistic lighting
+4. business portrait of mihai, charcoal suit, daylight office window light, high realism, no stylization
+5. professional headshot of mihai, relaxed confident expression, simple studio backdrop, true-to-life skin detail
+6. LinkedIn profile portrait of mihai, upper torso framing, soft rim light, minimal background distractions
+
+# Negative prompt
+
+uncanny face, plastic skin, asymmetrical eyes, distorted teeth, warped ears, extra fingers, text, watermark, cartoon, painting

07_kaggle/dataset-metadata.template.json

@@ -0,0 +1,9 @@
+{
+  "id": "__KAGGLE_USERNAME__/mihai-lora-v2-data",
+  "title": "Mihai LoRA v2 Training Data",
+  "licenses": [
+    {
+      "name": "CC0-1.0"
+    }
+  ]
+}

07_kaggle/kernel-metadata.template.json

@@ -0,0 +1,15 @@
+{
+  "id": "__KAGGLE_USERNAME__/mihai-flux-lora-v2",
+  "title": "Mihai FLUX LoRA v2",
+  "code_file": "train_flux_lora.py",
+  "language": "python",
+  "kernel_type": "script",
+  "is_private": true,
+  "enable_gpu": true,
+  "enable_internet": true,
+  "dataset_sources": [
+    "__KAGGLE_USERNAME__/mihai-lora-v2-data"
+  ],
+  "competition_sources": [],
+  "kernel_sources": []
+}

07_kaggle/train_flux_lora.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+"""Kaggle training entrypoint for chunked FLUX LoRA runs.
+
+Run this script inside a Kaggle Code notebook/job.
+It expects:
+- Training zip in /kaggle/input/<dataset>/replicate_bundle_v2.zip
+- Optional previous checkpoints dataset mounted under /kaggle/input/<checkpoint-dataset>/
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import torch
+from diffusers import StableDiffusionXLPipeline
+
+
+def sh(cmd: str) -> None:
+    print(f"[cmd] {cmd}")
+    subprocess.run(cmd, shell=True, check=True)
+
+
+def resolve_hf_token() -> str | None:
+    for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN", "HUGGINGFACEHUB_API_TOKEN"):
+        val = os.getenv(key)
+        if val:
+            return val
+
+    try:
+        from kaggle_secrets import UserSecretsClient  # type: ignore
+
+        client = UserSecretsClient()
+        for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"):
+            try:
+                val = client.get_secret(key)
+                if val:
+                    return val
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    return None
+
+
+def latest_ckpt(root: Path) -> tuple[str | None, int]:
+    if not root.exists():
+        return None, 0
+    cands: list[tuple[int, Path]] = []
+    for p in root.glob("**/*"):
+        if p.is_file() and p.suffix in {".safetensors", ".pt", ".bin"}:
+            m = re.search(r"(\d+)(?!.*\d)", p.stem)
+            step = int(m.group(1)) if m else -1
+            cands.append((step, p))
+    if not cands:
+        return None, 0
+    step, path = sorted(cands, key=lambda x: x[0])[-1]
+    return str(path), max(step, 0)
+
+
+def find_training_zip(explicit: str | None) -> Path:
+    if explicit:
+        p = Path(explicit)
+        if p.exists():
+            return p
+    matches = glob.glob("/kaggle/input/*/replicate_bundle_v2.zip")
+    if not matches:
+        raise FileNotFoundError(
+            "Could not find replicate_bundle_v2.zip in /kaggle/input"
+        )
+    return Path(matches[0])
+
+
+def find_dataset_folder_with_pairs(root: str = "/kaggle/input") -> Path | None:
+    base = Path(root)
+    if not base.exists():
+        return None
+
+    image_exts = {".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif"}
+    for ds in sorted([p for p in base.iterdir() if p.is_dir()]):
+        images = [
+            p for p in ds.iterdir() if p.is_file() and p.suffix.lower() in image_exts
+        ]
+        if not images:
+            continue
+
+        pairs = 0
+        for img in images:
+            if (ds / f"{img.stem}.txt").exists():
+                pairs += 1
+
+        if pairs >= 10:
+            return ds
+
+    return None
+
+
+def write_config(
+    out_path: Path,
+    data_dir: Path,
+    run_root: Path,
+    trigger: str,
+    rank: int,
+    lr: float,
+    end_steps: int,
+) -> None:
+    text = f"""
+job: extension
+config:
+  name: mihai_lora_v2
+  process:
+    - type: sd_trainer
+      training_folder: "{run_root}"
+      device: cuda:0
+      network:
+        type: lora
+        linear: {rank}
+        linear_alpha: {rank}
+      save:
+        dtype: float16
+        save_every: 100
+        max_step_saves_to_keep: 30
+      datasets:
+        - folder_path: "{data_dir}"
+          caption_ext: "txt"
+          default_caption: "photo of {trigger}"
+          resolution: [768, 896, 1024]
+      train:
+        batch_size: 1
+        steps: {end_steps}
+        lr: {lr}
+        gradient_accumulation_steps: 4
+        train_unet: true
+        train_text_encoder: false
+        noise_scheduler: ddim
+        optimizer: adamw8bit
+        dtype: fp16
+      model:
+        name_or_path: "stabilityai/stable-diffusion-xl-base-1.0"
+        is_xl: true
+        low_vram: true
+"""
+    out_path.write_text(text.strip() + "\n", encoding="utf-8")
+
+
+def find_checkpoint_by_step(root: Path, step: int) -> Path | None:
+    pattern = f"*{step:07d}.safetensors"
+    matches = sorted(root.glob(pattern))
+    return matches[-1] if matches else None
+
+
+def hydrate_checkpoints_from_resume(resume_root: Path, ckpt_dir: Path) -> int:
+    ckpt_dir.mkdir(parents=True, exist_ok=True)
+    copied = 0
+    for p in resume_root.glob("**/*.safetensors"):
+        dst = ckpt_dir / p.name
+        if not dst.exists():
+            shutil.copy2(p, dst)
+            copied += 1
+    return copied
+
+
+def run_checkpoint_eval(ckpt_dir: Path, trigger: str) -> None:
+    candidates: list[Path] = []
+    for step in (1200, 1400, 1500, 1600):
+        ck = find_checkpoint_by_step(ckpt_dir, step)
+        if ck is not None:
+            candidates.append(ck)
+
+    final_ck = ckpt_dir / "mihai_lora_v2.safetensors"
+    if final_ck.exists():
+        candidates.append(final_ck)
+
+    dedup: list[Path] = []
+    seen = set()
+    for c in candidates:
+        if c.name not in seen:
+            dedup.append(c)
+            seen.add(c.name)
+    candidates = dedup
+
+    if not candidates:
+        print("No eval checkpoints found; skipping eval.")
+        return
+
+    out_dir = ckpt_dir / "eval"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+    )
+    pipe.enable_attention_slicing()
+    pipe.enable_vae_slicing()
+    pipe.enable_model_cpu_offload()
+
+    prompts = [
+        f"professional LinkedIn headshot of {trigger}, navy blazer, clean gray studio background, photorealistic",
+        f"corporate profile photo of {trigger}, white shirt and dark jacket, soft office blur background, realistic lighting",
+        f"executive headshot of {trigger}, slight smile, 85mm portrait style, natural skin texture",
+    ]
+
+    summary = []
+    for ckpt in candidates:
+        try:
+            pipe.unload_lora_weights()
+        except Exception:
+            pass
+        pipe.load_lora_weights(str(ckpt_dir), weight_name=ckpt.name)
+        ck_name = ckpt.stem
+        ck_out = out_dir / ck_name
+        ck_out.mkdir(parents=True, exist_ok=True)
+
+        for idx, prompt in enumerate(prompts, start=1):
+            seed = 42 + idx
+            gen = torch.Generator(device="cpu").manual_seed(seed)
+            image = pipe(
+                prompt=prompt,
+                negative_prompt="uncanny face, plastic skin, distorted teeth, asymmetrical eyes, watermark, text",
+                width=1024,
+                height=1024,
+                num_inference_steps=30,
+                guidance_scale=7.0,
+                generator=gen,
+            ).images[0]
+            out_path = ck_out / f"p{idx}_seed{seed}.png"
+            image.save(out_path)
+            summary.append(
+                {
+                    "checkpoint": ckpt.name,
+                    "prompt": idx,
+                    "seed": seed,
+                    "file": str(out_path),
+                }
+            )
+            print(f"eval_saved={out_path}")
+
+    (out_dir / "summary.json").write_text(
+        json.dumps(summary, indent=2), encoding="utf-8"
+    )
+    print(f"eval_total_images={len(summary)}")
+
+
+def run_linkedin_pack(ckpt_dir: Path, trigger: str) -> None:
+    preferred_steps = (1400, 1500, 1200)
+    selected: Path | None = None
+    for step in preferred_steps:
+        selected = find_checkpoint_by_step(ckpt_dir, step)
+        if selected is not None:
+            break
+
+    if selected is None:
+        final_ck = ckpt_dir / "mihai_lora_v2.safetensors"
+        if final_ck.exists():
+            selected = final_ck
+
+    if selected is None:
+        print("No checkpoint available for LinkedIn pack generation.")
+        return
+
+    out_dir = ckpt_dir / "linkedin_pack"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    prompts = [
+        f"professional LinkedIn headshot of {trigger}, navy blazer, clean gray studio background, photorealistic",
+        f"corporate profile portrait of {trigger}, white shirt and charcoal blazer, realistic office bokeh background",
+        f"executive headshot of {trigger}, subtle confident smile, 85mm portrait style, natural skin texture",
+        f"business profile image of {trigger}, modern office setting, polished attire, realistic studio lighting",
+        f"LinkedIn profile portrait of {trigger}, direct eye contact, minimal background, crisp professional look",
+        f"professional headshot of {trigger}, dark blazer, soft key light, true-to-life facial details",
+        f"corporate portrait of {trigger}, balanced lighting, neutral backdrop, authentic skin tones",
+        f"executive business headshot of {trigger}, approachable expression, clean composition, photorealistic",
+        f"high-end LinkedIn portrait of {trigger}, medium close-up, realistic color grading, professional style",
+        f"professional profile photo of {trigger}, office interior blur, natural expression, realistic details",
+    ]
+    seeds = (101, 202, 303)
+
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+    )
+    pipe.enable_attention_slicing()
+    pipe.enable_vae_slicing()
+    pipe.enable_model_cpu_offload()
+    pipe.load_lora_weights(str(ckpt_dir), weight_name=selected.name)
+
+    manifest: dict[str, object] = {"selected_checkpoint": selected.name, "images": []}
+    images = []
+    for p_idx, prompt in enumerate(prompts, start=1):
+        for seed in seeds:
+            gen = torch.Generator(device="cpu").manual_seed(seed)
+            image = pipe(
+                prompt=prompt,
+                negative_prompt="uncanny face, plastic skin, asymmetrical eyes, distorted teeth, watermark, text, cartoon",
+                width=1024,
+                height=1024,
+                num_inference_steps=30,
+                guidance_scale=7.0,
+                generator=gen,
+            ).images[0]
+            filename = f"p{p_idx:02d}_s{seed}.png"
+            out_path = out_dir / filename
+            image.save(out_path)
+            entry = {"file": str(out_path), "prompt_index": p_idx, "seed": seed}
+            images.append(entry)
+            print(f"pack_saved={out_path}")
+
+    manifest["images"] = images
+    (out_dir / "manifest.json").write_text(
+        json.dumps(manifest, indent=2), encoding="utf-8"
+    )
+    print(f"linkedin_pack_total={len(images)}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input-zip", default=None)
+    parser.add_argument("--start-step", type=int, default=0)
+    parser.add_argument("--chunk-size", type=int, default=400)
+    parser.add_argument("--total-steps", type=int, default=1500)
+    parser.add_argument("--trigger", default="mihai")
+    parser.add_argument("--rank", type=int, default=16)
+    parser.add_argument("--lr", type=float, default=0.0001)
+    parser.add_argument("--resume-root", default="/kaggle/input")
+    parser.add_argument("--eval-only", action="store_true")
+    args = parser.parse_args()
+    eval_after_train = True
+
+    print("Listing /kaggle/input:")
+    sh("ls -la /kaggle/input || true")
+
+    dataset_folder = find_dataset_folder_with_pairs("/kaggle/input")
+    training_zip: Path | None = None
+    if dataset_folder is None:
+        training_zip = find_training_zip(args.input_zip)
+
+    gpu_probe = subprocess.run(
+        "nvidia-smi -L", shell=True, capture_output=True, text=True
+    )
+    if gpu_probe.returncode != 0:
+        raise RuntimeError(
+            "No GPU runtime detected. Enable GPU accelerator in Kaggle and complete account verification requirements."
+        )
+    print(gpu_probe.stdout.strip())
+
+    data_dir = Path("/kaggle/working/data")
+    run_root = Path("/kaggle/working/output")
+    cfg_path = Path("/kaggle/working/train_chunk.yaml")
+    toolkit_dir = Path("/tmp/ai-toolkit")
+
+    if data_dir.exists():
+        shutil.rmtree(data_dir)
+    data_dir.mkdir(parents=True, exist_ok=True)
+    run_root.mkdir(parents=True, exist_ok=True)
+
+    if dataset_folder is not None:
+        print(f"Using mounted dataset folder directly: {dataset_folder}")
+        for item in dataset_folder.iterdir():
+            if item.is_file():
+                shutil.copy2(item, data_dir / item.name)
+    else:
+        assert training_zip is not None
+        sh(f'python -m zipfile -e "{training_zip}" "{data_dir}"')
+
+    if toolkit_dir.exists():
+        shutil.rmtree(toolkit_dir)
+    sh("git clone --depth 1 https://github.com/ostris/ai-toolkit /tmp/ai-toolkit")
+    sh("python -m pip install -q -r /tmp/ai-toolkit/requirements.txt")
+    sh(
+        "python -m pip install -q accelerate bitsandbytes transformers diffusers safetensors"
+    )
+
+    hf_token = resolve_hf_token()
+    if hf_token:
+        os.environ["HF_TOKEN"] = hf_token
+        os.environ["HUGGING_FACE_HUB_TOKEN"] = hf_token
+        print("HF token loaded from env or Kaggle secrets.")
+    else:
+        print(
+            "HF token not found. If FLUX repo is gated, add HF_TOKEN in Kaggle Secrets."
+        )
+
+    resume_path, discovered_steps = latest_ckpt(Path(args.resume_root))
+    start = max(args.start_step, discovered_steps)
+    end = min(start + args.chunk_size, args.total_steps)
+
+    ckpt_output_dir = run_root / "mihai_lora_v2"
+    hydrated = hydrate_checkpoints_from_resume(Path(args.resume_root), ckpt_output_dir)
+    print(f"hydrated_checkpoints={hydrated}")
+
+    if start >= args.total_steps:
+        print("All requested steps already completed.")
+        if args.eval_only or eval_after_train:
+            run_checkpoint_eval(ckpt_output_dir, args.trigger)
+            run_linkedin_pack(ckpt_output_dir, args.trigger)
+        return
+
+    write_config(cfg_path, data_dir, run_root, args.trigger, args.rank, args.lr, end)
+
+    cmd = f"cd /tmp/ai-toolkit && python run.py {cfg_path}"
+    sh(cmd)
+
+    latest_path, latest_step = latest_ckpt(run_root)
+    summary = {
+        "start_step": start,
+        "end_step": end,
+        "latest_checkpoint": latest_path,
+        "latest_step": latest_step,
+    }
+    Path("/kaggle/working/output/run_summary.json").write_text(
+        json.dumps(summary, indent=2),
+        encoding="utf-8",
+    )
+    print(json.dumps(summary, indent=2))
+
+    if eval_after_train and end >= args.total_steps:
+        run_checkpoint_eval(ckpt_output_dir, args.trigger)
+        run_linkedin_pack(ckpt_output_dir, args.trigger)
+
+
+if __name__ == "__main__":
+    main()

08_kaggle_eval/evaluate_checkpoints.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import torch
+from diffusers import StableDiffusionXLPipeline
+
+
+OUT_DIR = Path("/kaggle/working/eval_outputs")
+
+CHECKPOINTS = [
+    "mihai_lora_v2_000001200.safetensors",
+    "mihai_lora_v2_000001400.safetensors",
+    "mihai_lora_v2_000001500.safetensors",
+]
+
+PROMPTS = [
+    "professional LinkedIn headshot of mihai, navy blazer, clean gray studio background, photorealistic",
+    "corporate profile photo of mihai, white shirt and dark jacket, soft office blur background, realistic lighting",
+    "executive headshot of mihai, slight smile, 85mm portrait style, natural skin texture",
+]
+
+SEEDS = [11, 42]
+
+
+def build_pipe() -> StableDiffusionXLPipeline:
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+    )
+    pipe.enable_attention_slicing()
+    pipe.enable_vae_slicing()
+    pipe.enable_model_cpu_offload()
+    return pipe
+
+
+def resolve_checkpoint_dir() -> Path:
+    base = Path("/kaggle/input")
+    if not base.exists():
+        raise SystemExit("/kaggle/input missing")
+
+    for ds in sorted([p for p in base.iterdir() if p.is_dir()]):
+        if list(ds.glob("*.safetensors")):
+            return ds
+
+    raise SystemExit(
+        "No checkpoint dataset with .safetensors found under /kaggle/input"
+    )
+
+
+def main() -> None:
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    checkpoint_dir = resolve_checkpoint_dir()
+    print(f"checkpoint_dir={checkpoint_dir}")
+
+    pipe = build_pipe()
+
+    summary = []
+    for ckpt in CHECKPOINTS:
+        ckpt_path = checkpoint_dir / ckpt
+        if not ckpt_path.exists():
+            print(f"skip_missing_checkpoint={ckpt_path}")
+            continue
+
+        pipe.unload_lora_weights()
+        pipe.load_lora_weights(str(checkpoint_dir), weight_name=ckpt)
+
+        ckpt_dir = OUT_DIR / ckpt.replace(".safetensors", "")
+        ckpt_dir.mkdir(parents=True, exist_ok=True)
+
+        for p_idx, prompt in enumerate(PROMPTS, start=1):
+            for seed in SEEDS:
+                gen = torch.Generator(device="cpu").manual_seed(seed)
+                image = pipe(
+                    prompt=prompt,
+                    negative_prompt="uncanny face, plastic skin, distorted teeth, extra fingers, watermark, text",
+                    width=1024,
+                    height=1024,
+                    num_inference_steps=30,
+                    guidance_scale=7.0,
+                    generator=gen,
+                ).images[0]
+
+                out_name = f"p{p_idx}_seed{seed}.png"
+                out_path = ckpt_dir / out_name
+                image.save(out_path)
+                summary.append(
+                    {
+                        "checkpoint": ckpt,
+                        "prompt_index": p_idx,
+                        "seed": seed,
+                        "file": str(out_path),
+                    }
+                )
+                print(f"saved={out_path}")
+
+    (OUT_DIR / "summary.json").write_text(
+        json.dumps(summary, indent=2), encoding="utf-8"
+    )
+    print(f"total_images={len(summary)}")
+
+
+if __name__ == "__main__":
+    main()

08_kaggle_eval/kernel-metadata.json

@@ -0,0 +1,15 @@
+{
+  "id": "mihaichindris/mihai-lora-v2-eval",
+  "title": "Mihai LoRA v2 Eval",
+  "code_file": "evaluate_checkpoints.py",
+  "language": "python",
+  "kernel_type": "script",
+  "is_private": true,
+  "enable_gpu": true,
+  "enable_internet": true,
+  "dataset_sources": [
+    "mihaichindris/mihai-lora-v2-checkpoints"
+  ],
+  "competition_sources": [],
+  "kernel_sources": []
+}

PUBLISHING.md

@@ -0,0 +1,33 @@
+# Publishing Plan (code-only)
+
+## GitHub (Mihai Codes org)
+
+Recommended: publish this project as a workflow repo without personal data.
+
+1. Use `README-public.md` as repository README.
+2. Keep `.gitignore` as-is.
+3. Verify no files under data/output/checkpoints are tracked.
+4. Push only workflow scripts and docs.
+
+## Hugging Face
+
+Recommended: do not publish personal-face LoRA weights publicly.
+
+Safer alternatives:
+
+- Publish a Space or repo with training workflow docs only.
+- Publish a template model card with no weights.
+
+If you keep an existing personal model on HF:
+
+- Prefer switching visibility to **private** first.
+- Keep or delete based on your risk tolerance; if uncertain, keep private.
+
+## Existing HF model decision
+
+For `mihai-chindris/image-generator`:
+
+- If you do not actively need public access, set it to **private** now.
+- Delete only if you are sure you never need it again.
+
+Reason: it is identity-linked and publicly downloadable; private mode gives you immediate risk reduction without irreversible loss.

README-public.md

@@ -0,0 +1,24 @@
+# mihai-lora-v2 (workflow-only)
+
+This repository contains the reproducible training workflow used to run a personal SDXL LoRA pipeline on free Kaggle GPU, including checkpoint continuation, checkpoint evaluation, and LinkedIn-style gallery generation.
+
+No personal training images, captions, generated portraits, or model checkpoints are included.
+
+## Included
+
+- Kaggle training script (`07_kaggle/train_flux_lora.py`)
+- Config/run automation scripts (`03_configs/*`)
+- Evaluation script templates (`08_kaggle_eval/*`)
+- Runbook and process notes
+
+## Excluded
+
+- Raw/curated personal photos
+- Captions tied to personal data
+- Checkpoints and model weights
+- Generated output galleries
+- API tokens and credentials
+
+## Privacy note
+
+If you publish similar work, keep biometric data and personal LoRA weights private unless you explicitly want public distribution.

README.md

@@ -0,0 +1,24 @@
+# mihai-lora-v2 (workflow-only)
+
+This repository contains the reproducible training workflow used to run a personal SDXL LoRA pipeline on free Kaggle GPU, including checkpoint continuation, checkpoint evaluation, and LinkedIn-style gallery generation.
+
+No personal training images, captions, generated portraits, or model checkpoints are included.
+
+## Included
+
+- Kaggle training script (`07_kaggle/train_flux_lora.py`)
+- Config/run automation scripts (`03_configs/*`)
+- Evaluation script templates (`08_kaggle_eval/*`)
+- Runbook and process notes
+
+## Excluded
+
+- Raw/curated personal photos
+- Captions tied to personal data
+- Checkpoints and model weights
+- Generated output galleries
+- API tokens and credentials
+
+## Privacy note
+
+If you publish similar work, keep biometric data and personal LoRA weights private unless you explicitly want public distribution.