Upload folder using huggingface_hub

scripts/backup.py

@@ -0,0 +1,259 @@
+"""
+Auto-backup system: sync checkpoints, data, and configs to HuggingFace Hub.
+Supports resume training from any new VPS.
+
+Setup:
+  1. huggingface-cli login
+  2. python3 backup.py --init (tạo repos trên HF)
+  3. python3 backup.py --backup (push lên HF)
+  4. python3 backup.py --restore (pull về VPS mới)
+"""
+import argparse
+import subprocess
+import time
+import threading
+from pathlib import Path
+from huggingface_hub import HfApi, create_repo, snapshot_download, upload_folder, upload_file
+
+
+PROJECT_DIR = Path("/home/adminuser/chungcat")
+HF_ORG = None  # Set to your HF username or org
+
+REPOS = {
+    "checkpoints": "{user}/4k-image-model-checkpoints",
+    "data_meta": "{user}/4k-image-model-data",
+    "scripts": "{user}/4k-image-model-scripts",
+}
+
+BACKUP_PATHS = {
+    "checkpoints": [
+        PROJECT_DIR / "checkpoints",
+    ],
+    "data_meta": [
+        PROJECT_DIR / "data" / "raw" / "coyo_filtered",
+        PROJECT_DIR / "configs",
+    ],
+    "scripts": [
+        PROJECT_DIR / "scripts",
+        PROJECT_DIR / "configs",
+        PROJECT_DIR / "PLAN.md",
+    ],
+}
+
+
+def get_hf_user():
+    api = HfApi()
+    info = api.whoami()
+    return info["name"]
+
+
+def init_repos(user):
+    """Create HF repos if they don't exist."""
+    api = HfApi()
+    for key, repo_template in REPOS.items():
+        repo_id = repo_template.format(user=user)
+        try:
+            create_repo(repo_id, repo_type="model" if key == "checkpoints" else "dataset", exist_ok=True)
+            print(f"  Repo ready: {repo_id}")
+        except Exception as e:
+            print(f"  Error creating {repo_id}: {e}")
+
+
+def backup_checkpoints(user):
+    """Upload latest checkpoint to HF."""
+    api = HfApi()
+    repo_id = REPOS["checkpoints"].format(user=user)
+    ckpt_dir = PROJECT_DIR / "checkpoints"
+
+    if not ckpt_dir.exists():
+        print("  No checkpoints to backup")
+        return
+
+    # Find all checkpoint dirs
+    for model_dir in ckpt_dir.iterdir():
+        if not model_dir.is_dir():
+            continue
+
+        # Upload latest checkpoint only (save bandwidth)
+        checkpoints = sorted(model_dir.glob("checkpoint-*"), key=lambda p: int(p.name.split("-")[1]) if p.name.split("-")[1].isdigit() else 0)
+        final = model_dir / "final"
+
+        to_upload = None
+        if final.exists():
+            to_upload = final
+        elif checkpoints:
+            to_upload = checkpoints[-1]
+
+        if to_upload:
+            path_in_repo = f"{model_dir.name}/{to_upload.name}"
+            print(f"  Uploading {to_upload} → {repo_id}/{path_in_repo}")
+            upload_folder(
+                folder_path=str(to_upload),
+                repo_id=repo_id,
+                path_in_repo=path_in_repo,
+                repo_type="model",
+            )
+
+
+def backup_data_meta(user):
+    """Upload filtered parquets and configs."""
+    api = HfApi()
+    repo_id = REPOS["data_meta"].format(user=user)
+
+    for path in BACKUP_PATHS["data_meta"]:
+        if not path.exists():
+            continue
+        rel_path = path.relative_to(PROJECT_DIR)
+        print(f"  Uploading {rel_path} → {repo_id}")
+        upload_folder(
+            folder_path=str(path),
+            repo_id=repo_id,
+            path_in_repo=str(rel_path),
+            repo_type="dataset",
+        )
+
+
+def backup_scripts(user):
+    """Upload all scripts and configs."""
+    api = HfApi()
+    repo_id = REPOS["scripts"].format(user=user)
+
+    for path in BACKUP_PATHS["scripts"]:
+        if not path.exists():
+            continue
+        rel_path = path.relative_to(PROJECT_DIR)
+        if path.is_file():
+            print(f"  Uploading {rel_path}")
+            upload_file(
+                path_or_fileobj=str(path),
+                repo_id=repo_id,
+                path_in_repo=str(rel_path),
+                repo_type="dataset",
+            )
+        else:
+            print(f"  Uploading {rel_path}/")
+            upload_folder(
+                folder_path=str(path),
+                repo_id=repo_id,
+                path_in_repo=str(rel_path),
+                repo_type="dataset",
+            )
+
+
+def backup_all(user):
+    """Full backup."""
+    print("\n=== Backing up scripts ===")
+    backup_scripts(user)
+    print("\n=== Backing up data metadata ===")
+    backup_data_meta(user)
+    print("\n=== Backing up checkpoints ===")
+    backup_checkpoints(user)
+    print("\n=== Backup complete! ===")
+
+
+def restore(user):
+    """Restore everything from HF to a new VPS."""
+    print("\n=== Restoring from HuggingFace ===")
+
+    # Restore scripts
+    repo_id = REPOS["scripts"].format(user=user)
+    print(f"\n  Restoring scripts from {repo_id}...")
+    try:
+        snapshot_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            local_dir=str(PROJECT_DIR),
+        )
+    except Exception as e:
+        print(f"  Warning: {e}")
+
+    # Restore data metadata
+    repo_id = REPOS["data_meta"].format(user=user)
+    print(f"\n  Restoring data metadata from {repo_id}...")
+    try:
+        snapshot_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            local_dir=str(PROJECT_DIR),
+        )
+    except Exception as e:
+        print(f"  Warning: {e}")
+
+    # Restore checkpoints
+    repo_id = REPOS["checkpoints"].format(user=user)
+    print(f"\n  Restoring checkpoints from {repo_id}...")
+    try:
+        snapshot_download(
+            repo_id=repo_id,
+            repo_type="model",
+            local_dir=str(PROJECT_DIR / "checkpoints"),
+        )
+    except Exception as e:
+        print(f"  Warning: {e}")
+
+    print("\n=== Restore complete! ===")
+
+
+class AutoBackup:
+    """Background thread that backs up every N minutes."""
+
+    def __init__(self, user, interval_minutes=30):
+        self.user = user
+        self.interval = interval_minutes * 60
+        self.running = False
+        self.thread = None
+
+    def start(self):
+        self.running = True
+        self.thread = threading.Thread(target=self._loop, daemon=True)
+        self.thread.start()
+        print(f"Auto-backup started (every {self.interval // 60} minutes)")
+
+    def stop(self):
+        self.running = False
+        if self.thread:
+            self.thread.join()
+
+    def _loop(self):
+        while self.running:
+            time.sleep(self.interval)
+            if not self.running:
+                break
+            try:
+                print(f"\n[Auto-backup] Starting backup at {time.strftime('%H:%M:%S')}...")
+                backup_all(self.user)
+                print(f"[Auto-backup] Done at {time.strftime('%H:%M:%S')}")
+            except Exception as e:
+                print(f"[Auto-backup] Error: {e}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Backup/restore to HuggingFace Hub")
+    parser.add_argument("--init", action="store_true", help="Create HF repos")
+    parser.add_argument("--backup", action="store_true", help="Backup to HF")
+    parser.add_argument("--restore", action="store_true", help="Restore from HF")
+    parser.add_argument("--auto", action="store_true", help="Start auto-backup daemon")
+    parser.add_argument("--interval", type=int, default=30, help="Auto-backup interval (minutes)")
+    parser.add_argument("--user", default=None, help="HF username (auto-detected if logged in)")
+    args = parser.parse_args()
+
+    user = args.user or get_hf_user()
+    print(f"HuggingFace user: {user}")
+
+    if args.init:
+        print("\nInitializing repos...")
+        init_repos(user)
+    elif args.backup:
+        backup_all(user)
+    elif args.restore:
+        restore(user)
+    elif args.auto:
+        ab = AutoBackup(user, args.interval)
+        ab.start()
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            ab.stop()
+    else:
+        print("Specify --init, --backup, --restore, or --auto")

scripts/bootstrap.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+"""
+Bootstrap script for new VPS.
+Run this on a fresh VPS to restore everything and resume training.
+
+Usage:
+  curl -sSL <raw_url_of_this_script> | bash
+  OR
+  bash scripts/bootstrap.sh <hf_username>
+"""
+
+set -e
+
+HF_USER=${1:-""}
+PROJECT_DIR="/home/adminuser/chungcat"
+
+echo "=== 4K Image Model - VPS Bootstrap ==="
+echo ""
+
+# 1. Install system deps
+echo "[1/6] Installing system dependencies..."
+pip3 install torch torchvision torchaudio 2>/dev/null | tail -1
+pip3 install diffusers transformers accelerate deepspeed bitsandbytes peft \
+    datasets webdataset img2dataset wandb safetensors xformers \
+    opencv-python-headless tqdm anthropic huggingface_hub fastapi uvicorn 2>/dev/null | tail -1
+
+# 2. Login to HuggingFace
+echo "[2/6] Checking HuggingFace login..."
+if ! huggingface-cli whoami &>/dev/null; then
+    echo "  Please login to HuggingFace:"
+    huggingface-cli login
+fi
+
+if [ -z "$HF_USER" ]; then
+    HF_USER=$(python3 -c "from huggingface_hub import HfApi; print(HfApi().whoami()['name'])")
+fi
+echo "  User: $HF_USER"
+
+# 3. Create project structure
+echo "[3/6] Creating project structure..."
+mkdir -p $PROJECT_DIR/{data/{raw,processed,captions},models,scripts,configs,checkpoints,logs,outputs}
+
+# 4. Restore from HuggingFace
+echo "[4/6] Restoring from HuggingFace..."
+python3 $PROJECT_DIR/scripts/backup.py --restore --user $HF_USER 2>/dev/null || {
+    echo "  No backup found or restore failed. Starting fresh."
+}
+
+# 5. Verify GPU
+echo "[5/6] Verifying GPU..."
+python3 -c "
+import torch
+print(f'  PyTorch: {torch.__version__}')
+print(f'  CUDA: {torch.version.cuda}')
+print(f'  GPUs: {torch.cuda.device_count()}')
+for i in range(torch.cuda.device_count()):
+    print(f'    GPU {i}: {torch.cuda.get_device_name(i)} ({torch.cuda.get_device_properties(i).total_memory/1024**3:.0f}GB)')
+"
+
+# 6. Start auto-backup
+echo "[6/6] Starting auto-backup (every 30 min)..."
+nohup python3 $PROJECT_DIR/scripts/backup.py --auto --interval 30 --user $HF_USER > $PROJECT_DIR/logs/backup.log 2>&1 &
+echo "  Auto-backup PID: $!"
+
+echo ""
+echo "=== Bootstrap complete! ==="
+echo ""
+echo "Next steps:"
+echo "  - Check data: du -sh $PROJECT_DIR/data/"
+echo "  - Resume training: bash $PROJECT_DIR/scripts/training/run_train_flux.sh"
+echo "  - Manual backup: python3 $PROJECT_DIR/scripts/backup.py --backup"
+echo ""

scripts/data_collection/caption_opus.py

@@ -0,0 +1,136 @@
+"""
+Caption images using Anthropic Claude Opus 4.6 API.
+Generates detailed descriptions for fine-tuning Flux.
+"""
+import os
+import json
+import base64
+import argparse
+import time
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import anthropic
+from tqdm import tqdm
+
+INPUT_DIR = Path("/home/adminuser/chungcat/data/raw/unsplash")
+OUTPUT_DIR = Path("/home/adminuser/chungcat/data/captions")
+
+CAPTION_PROMPT = """Describe this image in detail for an AI image generation model. Include:
+- Main subject and composition
+- Colors, lighting, mood
+- Style (photographic, artistic, etc.)
+- Important details and textures
+- Background elements
+
+Write a single detailed paragraph, 2-4 sentences. Be specific and descriptive."""
+
+
+def encode_image(image_path):
+    with open(image_path, "rb") as f:
+        return base64.standard_b64encode(f.read()).decode("utf-8")
+
+
+def caption_image(client, image_path, model="claude-opus-4-6-20250219"):
+    img_data = encode_image(image_path)
+    suffix = image_path.suffix.lower()
+    media_type = "image/jpeg" if suffix in [".jpg", ".jpeg"] else "image/png"
+
+    response = client.messages.create(
+        model=model,
+        max_tokens=300,
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": media_type,
+                            "data": img_data,
+                        },
+                    },
+                    {"type": "text", "text": CAPTION_PROMPT},
+                ],
+            }
+        ],
+    )
+    return response.content[0].text
+
+
+def process_batch(client, images, output_dir, model, max_retries=3):
+    results = []
+    for img_path in images:
+        output_path = output_dir / f"{img_path.stem}.json"
+        if output_path.exists():
+            continue
+
+        for attempt in range(max_retries):
+            try:
+                caption = caption_image(client, img_path, model)
+                result = {
+                    "image": str(img_path),
+                    "caption": caption,
+                    "filename": img_path.name,
+                }
+                output_path.write_text(json.dumps(result, ensure_ascii=False))
+                results.append(result)
+                break
+            except anthropic.RateLimitError:
+                time.sleep(2 ** attempt)
+            except Exception as e:
+                print(f"Error {img_path.name}: {e}")
+                if attempt == max_retries - 1:
+                    print(f"  Skipping after {max_retries} retries")
+                time.sleep(1)
+
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Caption images with Claude Opus")
+    parser.add_argument("--input-dir", type=Path, default=INPUT_DIR)
+    parser.add_argument("--output-dir", type=Path, default=OUTPUT_DIR)
+    parser.add_argument("--model", default="claude-opus-4-6-20250219")
+    parser.add_argument("--batch-size", type=int, default=10)
+    parser.add_argument("--workers", type=int, default=5)
+    parser.add_argument("--max-images", type=int, default=None)
+    args = parser.parse_args()
+
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        raise ValueError("Set ANTHROPIC_API_KEY environment variable")
+
+    client = anthropic.Anthropic(api_key=api_key)
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    images = sorted(args.input_dir.glob("*.jpg")) + sorted(args.input_dir.glob("*.png"))
+    if args.max_images:
+        images = images[:args.max_images]
+
+    already_done = len(list(args.output_dir.glob("*.json")))
+    images = [img for img in images if not (args.output_dir / f"{img.stem}.json").exists()]
+
+    print(f"Total images: {len(images) + already_done}")
+    print(f"Already captioned: {already_done}")
+    print(f"To caption: {len(images)}")
+
+    batches = [images[i:i+args.batch_size] for i in range(0, len(images), args.batch_size)]
+
+    total_captioned = 0
+    with ThreadPoolExecutor(max_workers=args.workers) as executor:
+        futures = [
+            executor.submit(process_batch, client, batch, args.output_dir, args.model)
+            for batch in batches
+        ]
+        for future in tqdm(as_completed(futures), total=len(futures)):
+            results = future.result()
+            total_captioned += len(results)
+
+    print(f"\nDone! Captioned {total_captioned} new images")
+    print(f"Total captions: {already_done + total_captioned}")
+
+
+if __name__ == "__main__":
+    main()

scripts/data_collection/crawl_4k.py

@@ -0,0 +1,115 @@
+"""
+Crawl high-resolution 4K images for super-resolution training.
+Uses Unsplash API filtering for images >= 3840px width.
+"""
+import os
+import json
+import requests
+import argparse
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+DATA_DIR = Path("/home/adminuser/chungcat/data/raw/4k")
+METADATA_DIR = Path("/home/adminuser/chungcat/data/raw/4k_meta")
+MIN_WIDTH = 3840
+
+
+def fetch_page(access_key, query, page, per_page=30):
+    url = "https://api.unsplash.com/search/photos"
+    params = {
+        "query": query,
+        "page": page,
+        "per_page": per_page,
+        "client_id": access_key,
+    }
+    resp = requests.get(url, params=params, timeout=30)
+    resp.raise_for_status()
+    results = resp.json()["results"]
+    return [r for r in results if r["width"] >= MIN_WIDTH]
+
+
+def download_raw(photo, save_dir):
+    photo_id = photo["id"]
+    url = photo["urls"]["raw"]
+    save_path = save_dir / f"{photo_id}.jpg"
+
+    if save_path.exists():
+        return save_path, photo
+
+    try:
+        resp = requests.get(url, timeout=120)
+        resp.raise_for_status()
+        save_path.write_bytes(resp.content)
+        return save_path, photo
+    except Exception as e:
+        print(f"Failed {photo_id}: {e}")
+        return None, photo
+
+
+def save_metadata(photo, meta_dir):
+    meta = {
+        "id": photo["id"],
+        "width": photo["width"],
+        "height": photo["height"],
+        "description": photo.get("description", ""),
+        "alt_description": photo.get("alt_description", ""),
+        "user": photo["user"]["name"],
+        "tags": [t.get("title", "") for t in photo.get("tags", [])],
+    }
+    meta_path = meta_dir / f"{photo['id']}.json"
+    meta_path.write_text(json.dumps(meta, ensure_ascii=False))
+
+
+def crawl(access_key, queries, max_pages=200, workers=4):
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    METADATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    total = 0
+
+    for query in queries:
+        print(f"\n--- Crawling 4K: '{query}' ---")
+        for page in range(1, max_pages + 1):
+            try:
+                photos = fetch_page(access_key, query, page)
+            except Exception as e:
+                print(f"Page {page} failed: {e}")
+                break
+
+            if not photos:
+                break
+
+            with ThreadPoolExecutor(max_workers=workers) as executor:
+                futures = [
+                    executor.submit(download_raw, photo, DATA_DIR)
+                    for photo in photos
+                ]
+                for future in as_completed(futures):
+                    path, photo = future.result()
+                    if path:
+                        save_metadata(photo, METADATA_DIR)
+                        total += 1
+
+            if page % 10 == 0:
+                print(f"  Page {page}, total 4K images: {total}")
+
+    print(f"\nDone! Total 4K images: {total}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Crawl 4K images for SR training")
+    parser.add_argument("--access-key", required=True, help="Unsplash API access key")
+    parser.add_argument(
+        "--queries",
+        nargs="+",
+        default=[
+            "4k wallpaper", "high resolution landscape", "8k nature",
+            "ultra hd photography", "4k portrait", "high resolution architecture",
+            "macro photography", "aerial photography", "4k city",
+            "high resolution texture", "4k abstract", "detailed photography",
+        ],
+    )
+    parser.add_argument("--max-pages", type=int, default=200)
+    parser.add_argument("--workers", type=int, default=4)
+    args = parser.parse_args()
+
+    crawl(args.access_key, args.queries, args.max_pages, args.workers)

scripts/data_collection/crawl_pexels.py

@@ -0,0 +1,104 @@
+import os
+import json
+import requests
+import argparse
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+DATA_DIR = Path("/home/adminuser/chungcat/data/raw/pexels")
+METADATA_DIR = Path("/home/adminuser/chungcat/data/raw/pexels_meta")
+
+
+def fetch_page(api_key, query, page, per_page=80, min_width=1024):
+    url = "https://api.pexels.com/v1/search"
+    headers = {"Authorization": api_key}
+    params = {"query": query, "page": page, "per_page": per_page}
+    resp = requests.get(url, headers=headers, params=params, timeout=30)
+    resp.raise_for_status()
+    photos = resp.json()["photos"]
+    return [p for p in photos if p["width"] >= min_width]
+
+
+def download_image(photo, save_dir):
+    photo_id = photo["id"]
+    url = photo["src"]["original"]
+    save_path = save_dir / f"{photo_id}.jpg"
+
+    if save_path.exists():
+        return save_path, photo
+
+    try:
+        resp = requests.get(url, timeout=60)
+        resp.raise_for_status()
+        save_path.write_bytes(resp.content)
+        return save_path, photo
+    except Exception as e:
+        print(f"Failed {photo_id}: {e}")
+        return None, photo
+
+
+def save_metadata(photo, meta_dir):
+    meta = {
+        "id": photo["id"],
+        "width": photo["width"],
+        "height": photo["height"],
+        "alt": photo.get("alt", ""),
+        "photographer": photo["photographer"],
+        "src": photo["src"],
+    }
+    meta_path = meta_dir / f"{photo['id']}.json"
+    meta_path.write_text(json.dumps(meta, ensure_ascii=False))
+
+
+def crawl(api_key, queries, max_pages=100, workers=8):
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    METADATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    total_downloaded = 0
+
+    for query in queries:
+        print(f"\n--- Crawling: '{query}' ---")
+        for page in range(1, max_pages + 1):
+            try:
+                photos = fetch_page(api_key, query, page)
+            except Exception as e:
+                print(f"Page {page} failed: {e}")
+                break
+
+            if not photos:
+                break
+
+            with ThreadPoolExecutor(max_workers=workers) as executor:
+                futures = [
+                    executor.submit(download_image, photo, DATA_DIR)
+                    for photo in photos
+                ]
+                for future in as_completed(futures):
+                    path, photo = future.result()
+                    if path:
+                        save_metadata(photo, METADATA_DIR)
+                        total_downloaded += 1
+
+            if page % 10 == 0:
+                print(f"  Page {page}, total: {total_downloaded}")
+
+    print(f"\nDone! Total images: {total_downloaded}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Crawl Pexels images")
+    parser.add_argument("--api-key", required=True, help="Pexels API key")
+    parser.add_argument(
+        "--queries",
+        nargs="+",
+        default=[
+            "landscape", "portrait", "architecture", "nature", "city",
+            "food", "technology", "art", "abstract", "animals",
+            "fashion", "interior", "street photography", "ocean", "mountain",
+        ],
+    )
+    parser.add_argument("--max-pages", type=int, default=100)
+    parser.add_argument("--workers", type=int, default=8)
+    args = parser.parse_args()
+
+    crawl(args.api_key, args.queries, args.max_pages, args.workers)

scripts/data_collection/crawl_unsplash.py

@@ -0,0 +1,122 @@
+import os
+import json
+import requests
+import argparse
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+
+DATA_DIR = Path("/home/adminuser/chungcat/data/raw/unsplash")
+METADATA_DIR = Path("/home/adminuser/chungcat/data/raw/unsplash_meta")
+
+
+def fetch_page(access_key, query, page, per_page=30, min_width=1024):
+    url = "https://api.unsplash.com/search/photos"
+    params = {
+        "query": query,
+        "page": page,
+        "per_page": per_page,
+        "client_id": access_key,
+    }
+    resp = requests.get(url, params=params, timeout=30)
+    resp.raise_for_status()
+    results = resp.json()["results"]
+    return [r for r in results if r["width"] >= min_width]
+
+
+def download_image(photo, resolution="regular", save_dir=None):
+    photo_id = photo["id"]
+    url = photo["urls"][resolution]
+    ext = "jpg"
+    save_path = save_dir / f"{photo_id}.{ext}"
+
+    if save_path.exists():
+        return save_path, photo
+
+    try:
+        resp = requests.get(url, timeout=60)
+        resp.raise_for_status()
+        save_path.write_bytes(resp.content)
+        return save_path, photo
+    except Exception as e:
+        print(f"Failed {photo_id}: {e}")
+        return None, photo
+
+
+def save_metadata(photo, meta_dir):
+    photo_id = photo["id"]
+    meta = {
+        "id": photo_id,
+        "width": photo["width"],
+        "height": photo["height"],
+        "description": photo.get("description", ""),
+        "alt_description": photo.get("alt_description", ""),
+        "urls": photo["urls"],
+        "user": photo["user"]["name"],
+        "tags": [t.get("title", "") for t in photo.get("tags", [])],
+    }
+    meta_path = meta_dir / f"{photo_id}.json"
+    meta_path.write_text(json.dumps(meta, ensure_ascii=False))
+
+
+def crawl(access_key, queries, max_pages=100, resolution="regular", workers=8):
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    METADATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    total_downloaded = 0
+
+    for query in queries:
+        print(f"\n--- Crawling: '{query}' ---")
+        for page in range(1, max_pages + 1):
+            try:
+                photos = fetch_page(access_key, query, page)
+            except Exception as e:
+                print(f"Page {page} failed: {e}")
+                break
+
+            if not photos:
+                print(f"No more results for '{query}' at page {page}")
+                break
+
+            with ThreadPoolExecutor(max_workers=workers) as executor:
+                futures = []
+                for photo in photos:
+                    futures.append(
+                        executor.submit(download_image, photo, resolution, DATA_DIR)
+                    )
+
+                for future in as_completed(futures):
+                    path, photo = future.result()
+                    if path:
+                        save_metadata(photo, METADATA_DIR)
+                        total_downloaded += 1
+
+            if page % 10 == 0:
+                print(f"  Page {page}, total downloaded: {total_downloaded}")
+
+    print(f"\nDone! Total images: {total_downloaded}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Crawl Unsplash images")
+    parser.add_argument("--access-key", required=True, help="Unsplash API access key")
+    parser.add_argument(
+        "--queries",
+        nargs="+",
+        default=[
+            "landscape", "portrait", "architecture", "nature", "city",
+            "food", "technology", "art", "abstract", "animals",
+            "fashion", "interior", "street photography", "ocean", "mountain",
+        ],
+    )
+    parser.add_argument("--max-pages", type=int, default=100)
+    parser.add_argument(
+        "--resolution",
+        choices=["raw", "full", "regular", "small"],
+        default="full",
+        help="Image resolution (full=max quality)",
+    )
+    parser.add_argument("--workers", type=int, default=8)
+    args = parser.parse_args()
+
+    crawl(args.access_key, args.queries, args.max_pages, args.resolution, args.workers)

scripts/data_collection/create_sr_pairs.py

@@ -0,0 +1,124 @@
+"""
+Tạo training pairs cho super-resolution:
+- Lấy ảnh 4K gốc làm target (ground truth)
+- Downscale xuống 2K và 1K làm input
+- Thêm degradation (noise, blur, compression) cho realistic
+"""
+import argparse
+import random
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+INPUT_DIR = Path("/home/adminuser/chungcat/data/raw/4k")
+OUTPUT_BASE = Path("/home/adminuser/chungcat/data/processed")
+
+
+def add_degradation(img, level="light"):
+    if level == "none":
+        return img
+
+    if random.random() < 0.3:
+        ksize = random.choice([3, 5])
+        img = cv2.GaussianBlur(img, (ksize, ksize), 0)
+
+    if random.random() < 0.3:
+        noise = np.random.normal(0, random.uniform(1, 5), img.shape).astype(np.float32)
+        img = np.clip(img.astype(np.float32) + noise, 0, 255).astype(np.uint8)
+
+    if random.random() < 0.3:
+        quality = random.randint(70, 95)
+        _, encoded = cv2.imencode(".jpg", img, [cv2.IMWRITE_JPEG_QUALITY, quality])
+        img = cv2.imdecode(encoded, cv2.IMREAD_COLOR)
+
+    return img
+
+
+def process_image(img_path, output_dirs, target_sizes, degradation="light"):
+    try:
+        img = cv2.imread(str(img_path), cv2.IMREAD_COLOR)
+        if img is None:
+            return None
+
+        h, w = img.shape[:2]
+        if w < 3840 or h < 2160:
+            return None
+
+        stem = img_path.stem
+
+        # Crop to 4096x4096 or keep aspect ratio
+        # For training, use random crops
+        crop_size_4k = 4096
+        crop_size_2k = 2048
+        crop_size_1k = 1024
+
+        if h >= crop_size_4k and w >= crop_size_4k:
+            y = random.randint(0, h - crop_size_4k)
+            x = random.randint(0, w - crop_size_4k)
+            crop_4k = img[y:y+crop_size_4k, x:x+crop_size_4k]
+        else:
+            crop_4k = cv2.resize(img, (crop_size_4k, crop_size_4k), interpolation=cv2.INTER_LANCZOS4)
+
+        # Downscale to 2K
+        crop_2k = cv2.resize(crop_4k, (crop_size_2k, crop_size_2k), interpolation=cv2.INTER_AREA)
+
+        # Downscale to 1K
+        crop_1k = cv2.resize(crop_4k, (crop_size_1k, crop_size_1k), interpolation=cv2.INTER_AREA)
+
+        # Add degradation to inputs
+        crop_2k_degraded = add_degradation(crop_2k, degradation)
+        crop_1k_degraded = add_degradation(crop_1k, degradation)
+
+        # Save
+        cv2.imwrite(str(output_dirs["4k"] / f"{stem}.png"), crop_4k)
+        cv2.imwrite(str(output_dirs["2k"] / f"{stem}.png"), crop_2k_degraded)
+        cv2.imwrite(str(output_dirs["1k"] / f"{stem}.png"), crop_1k_degraded)
+
+        return stem
+    except Exception as e:
+        print(f"Error processing {img_path}: {e}")
+        return None
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Create SR training pairs from 4K images")
+    parser.add_argument("--input-dir", type=Path, default=INPUT_DIR)
+    parser.add_argument("--output-dir", type=Path, default=OUTPUT_BASE / "sr_pairs")
+    parser.add_argument("--degradation", choices=["none", "light", "heavy"], default="light")
+    parser.add_argument("--workers", type=int, default=16)
+    parser.add_argument("--max-images", type=int, default=None)
+    args = parser.parse_args()
+
+    output_dirs = {
+        "4k": args.output_dir / "4k_target",
+        "2k": args.output_dir / "2k_input",
+        "1k": args.output_dir / "1k_input",
+    }
+    for d in output_dirs.values():
+        d.mkdir(parents=True, exist_ok=True)
+
+    images = list(args.input_dir.glob("*.jpg")) + list(args.input_dir.glob("*.png"))
+    if args.max_images:
+        images = images[:args.max_images]
+
+    print(f"Processing {len(images)} images...")
+
+    processed = 0
+    with ProcessPoolExecutor(max_workers=args.workers) as executor:
+        futures = [
+            executor.submit(process_image, img, output_dirs, None, args.degradation)
+            for img in images
+        ]
+        for future in tqdm(as_completed(futures), total=len(futures)):
+            result = future.result()
+            if result:
+                processed += 1
+
+    print(f"Done! Processed {processed}/{len(images)} images")
+
+
+if __name__ == "__main__":
+    main()

scripts/data_collection/download_coyo_images.py

@@ -0,0 +1,72 @@
+"""
+Download images from filtered COYO parquet using img2dataset.
+"""
+import subprocess
+import argparse
+from pathlib import Path
+
+import pandas as pd
+
+
+def download_from_parquet(parquet_path, output_dir, resolution=1024, workers=32, thread_count=128):
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # img2dataset needs url + caption columns
+    df = pd.read_parquet(parquet_path)
+    print(f"Total URLs to download: {len(df)}")
+
+    # Save as temporary parquet with required columns
+    tmp_parquet = output_dir / "_urls.parquet"
+    df_out = df[["url", "text"]].rename(columns={"url": "URL", "text": "TEXT"})
+    df_out.to_parquet(tmp_parquet, index=False)
+
+    cmd = [
+        "img2dataset",
+        "--url_list", str(tmp_parquet),
+        "--input_format", "parquet",
+        "--url_col", "URL",
+        "--caption_col", "TEXT",
+        "--output_format", "webdataset",
+        "--output_folder", str(output_dir / "shards"),
+        "--processes_count", str(workers),
+        "--thread_count", str(thread_count),
+        "--image_size", str(resolution),
+        "--resize_mode", "center_crop",
+        "--resize_only_if_bigger", "True",
+        "--number_sample_per_shard", "1000",
+        "--save_additional_columns", '["aesthetic_score_laion_v2"]',
+        "--retries", "2",
+        "--disallowed_header_directives", '["noai", "noimageai", "noindex"]',
+    ]
+
+    print(f"Running img2dataset...")
+    print(f"  Resolution: {resolution}px")
+    print(f"  Workers: {workers}")
+    print(f"  Output: {output_dir / 'shards'}")
+
+    subprocess.run(cmd, check=True)
+    print("Download complete!")
+
+    # Cleanup temp file
+    tmp_parquet.unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Download images from filtered COYO")
+    parser.add_argument(
+        "--parquet",
+        type=Path,
+        default=Path("/home/adminuser/chungcat/data/raw/coyo_filtered/coyo_aesthetic.parquet"),
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("/home/adminuser/chungcat/data/processed/flux_train"),
+    )
+    parser.add_argument("--resolution", type=int, default=1024)
+    parser.add_argument("--workers", type=int, default=32)
+    parser.add_argument("--threads", type=int, default=128)
+    args = parser.parse_args()
+
+    download_from_parquet(args.parquet, args.output_dir, args.resolution, args.workers, args.threads)

scripts/data_collection/download_laion.py

@@ -0,0 +1,146 @@
+"""
+Download LAION-Aesthetics dataset (aesthetic score >= 6.0).
+High-quality images with captions, suitable for Flux fine-tuning.
+Uses img2dataset for fast parallel downloading.
+"""
+import subprocess
+import argparse
+from pathlib import Path
+
+OUTPUT_DIR = Path("/home/adminuser/chungcat/data/raw/laion")
+PARQUET_DIR = Path("/home/adminuser/chungcat/data/raw/laion_meta")
+
+
+def download_metadata():
+    """Download LAION-Aesthetics v2 6+ metadata (parquet files with URLs + captions)."""
+    PARQUET_DIR.mkdir(parents=True, exist_ok=True)
+
+    print("Downloading LAION-Aesthetics v2 6+ metadata...")
+    # This subset contains ~600K images with aesthetic score >= 6.0
+    url = "https://huggingface.co/datasets/laion/laion2B-en-aesthetic/resolve/main"
+
+    subprocess.run([
+        "pip3", "install", "huggingface_hub[cli]"
+    ], capture_output=True)
+
+    subprocess.run([
+        "python3", "-c", f"""
+from huggingface_hub import snapshot_download
+snapshot_download(
+    repo_id="laion/laion2B-en-aesthetic",
+    repo_type="dataset",
+    local_dir="{PARQUET_DIR}",
+    allow_patterns=["*.parquet"],
+    max_workers=8,
+)
+print("Metadata download complete!")
+"""
+    ], check=True)
+
+
+def download_images(num_images=1000000, resolution=1024, workers=64):
+    """Download images using img2dataset from parquet metadata."""
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    parquet_files = list(PARQUET_DIR.glob("**/*.parquet"))
+    if not parquet_files:
+        print("No parquet files found. Run with --download-meta first.")
+        return
+
+    print(f"Found {len(parquet_files)} parquet files")
+    print(f"Downloading up to {num_images} images at {resolution}px...")
+
+    # img2dataset handles parallel download, resize, and WebDataset output
+    cmd = [
+        "img2dataset",
+        "--url_list", str(parquet_files[0]),
+        "--input_format", "parquet",
+        "--url_col", "URL",
+        "--caption_col", "TEXT",
+        "--output_format", "webdataset",
+        "--output_folder", str(OUTPUT_DIR),
+        "--processes_count", str(workers),
+        "--thread_count", "128",
+        "--image_size", str(resolution),
+        "--resize_mode", "center_crop",
+        "--resize_only_if_bigger", "True",
+        "--enable_wandb", "False",
+        "--number_sample_per_shard", "1000",
+        "--save_additional_columns", '["AESTHETIC_SCORE","WIDTH","HEIGHT"]',
+        "--max_shard_retry", "3",
+    ]
+
+    if num_images:
+        cmd.extend(["--max_shard_retry", "3"])
+
+    print(f"Running: {' '.join(cmd)}")
+    subprocess.run(cmd, check=True)
+    print("Download complete!")
+
+
+def download_images_multi(num_workers=64, resolution=1024):
+    """Download from all parquet files."""
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    parquet_files = sorted(PARQUET_DIR.glob("**/*.parquet"))
+    if not parquet_files:
+        print("No parquet files found. Run with --download-meta first.")
+        return
+
+    print(f"Found {len(parquet_files)} parquet files")
+
+    for i, pf in enumerate(parquet_files):
+        shard_output = OUTPUT_DIR / f"shard_{i:04d}"
+        shard_output.mkdir(parents=True, exist_ok=True)
+
+        print(f"\n[{i+1}/{len(parquet_files)}] Processing {pf.name}...")
+
+        cmd = [
+            "img2dataset",
+            "--url_list", str(pf),
+            "--input_format", "parquet",
+            "--url_col", "URL",
+            "--caption_col", "TEXT",
+            "--output_format", "webdataset",
+            "--output_folder", str(shard_output),
+            "--processes_count", str(num_workers),
+            "--thread_count", "128",
+            "--image_size", str(resolution),
+            "--resize_mode", "center_crop",
+            "--resize_only_if_bigger", "True",
+            "--enable_wandb", "False",
+            "--number_sample_per_shard", "1000",
+            "--save_additional_columns", '["AESTHETIC_SCORE","WIDTH","HEIGHT"]',
+        ]
+
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Error on {pf.name}: {e}")
+            continue
+
+    print("\nAll shards downloaded!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Download LAION-Aesthetics dataset")
+    parser.add_argument("--download-meta", action="store_true", help="Download metadata parquet files")
+    parser.add_argument("--download-images", action="store_true", help="Download images from first parquet")
+    parser.add_argument("--download-all", action="store_true", help="Download from all parquet files")
+    parser.add_argument("--resolution", type=int, default=1024)
+    parser.add_argument("--workers", type=int, default=64)
+    parser.add_argument("--max-images", type=int, default=1000000)
+    args = parser.parse_args()
+
+    if args.download_meta:
+        download_metadata()
+    elif args.download_images:
+        download_images(args.max_images, args.resolution, args.workers)
+    elif args.download_all:
+        download_images_multi(args.workers, args.resolution)
+    else:
+        print("Specify --download-meta, --download-images, or --download-all")
+        print("\nWorkflow:")
+        print("  1. python3 download_laion.py --download-meta")
+        print("  2. python3 download_laion.py --download-images --max-images 1000000")
+        print("  Or: python3 download_laion.py --download-all")

scripts/data_collection/filter_coyo.py

@@ -0,0 +1,116 @@
+"""
+Filter COYO-700M dataset by aesthetic score and resolution,
+then download images using img2dataset.
+"""
+import argparse
+import pandas as pd
+from pathlib import Path
+
+COYO_DIR = Path("/home/adminuser/chungcat/data/raw/coyo/data")
+OUTPUT_DIR = Path("/home/adminuser/chungcat/data/raw/coyo_filtered")
+
+
+def filter_parquet(
+    input_dir,
+    output_path,
+    min_aesthetic=6.0,
+    min_width=1024,
+    min_height=1024,
+    max_nsfw=0.3,
+    min_clip_score=0.25,
+    max_watermark=0.5,
+    max_records=None,
+):
+    parquet_files = sorted(input_dir.glob("*.parquet"))
+    print(f"Found {len(parquet_files)} parquet files")
+
+    all_filtered = []
+
+    for pf in parquet_files:
+        print(f"\nProcessing {pf.name}...")
+        df = pd.read_parquet(pf)
+        print(f"  Total records: {len(df)}")
+
+        filtered = df[
+            (df["aesthetic_score_laion_v2"] >= min_aesthetic)
+            & (df["width"] >= min_width)
+            & (df["height"] >= min_height)
+            & (df["nsfw_score_opennsfw2"] <= max_nsfw)
+            & (df["clip_similarity_vitl14"] >= min_clip_score)
+            & (df["watermark_score"] <= max_watermark)
+        ].copy()
+
+        print(f"  After filter: {len(filtered)}")
+        all_filtered.append(filtered)
+
+    result = pd.concat(all_filtered, ignore_index=True)
+    print(f"\nTotal filtered: {len(result)}")
+
+    if max_records and len(result) > max_records:
+        result = result.sort_values("aesthetic_score_laion_v2", ascending=False).head(max_records)
+        print(f"Trimmed to top {max_records} by aesthetic score")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    result.to_parquet(output_path, index=False)
+    print(f"Saved to {output_path}")
+
+    print(f"\nStats:")
+    print(f"  Aesthetic score: {result['aesthetic_score_laion_v2'].mean():.2f} avg")
+    print(f"  Resolution: {result['width'].mean():.0f}x{result['height'].mean():.0f} avg")
+    print(f"  CLIP score: {result['clip_similarity_vitl14'].mean():.3f} avg")
+
+    return result
+
+
+def filter_4k(input_dir, output_path, min_width=3840, min_height=2160, max_nsfw=0.3):
+    """Filter specifically for 4K+ images for SR training."""
+    parquet_files = sorted(input_dir.glob("*.parquet"))
+    all_filtered = []
+
+    for pf in parquet_files:
+        print(f"Processing {pf.name} for 4K...")
+        df = pd.read_parquet(pf)
+        filtered = df[
+            (df["width"] >= min_width)
+            & (df["height"] >= min_height)
+            & (df["nsfw_score_opennsfw2"] <= max_nsfw)
+        ].copy()
+        print(f"  4K images: {len(filtered)}")
+        all_filtered.append(filtered)
+
+    result = pd.concat(all_filtered, ignore_index=True)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    result.to_parquet(output_path, index=False)
+    print(f"\nTotal 4K images: {len(result)}")
+    print(f"Saved to {output_path}")
+    return result
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Filter COYO dataset")
+    parser.add_argument("--input-dir", type=Path, default=COYO_DIR)
+    parser.add_argument("--output-dir", type=Path, default=OUTPUT_DIR)
+    parser.add_argument("--min-aesthetic", type=float, default=6.0)
+    parser.add_argument("--min-width", type=int, default=1024)
+    parser.add_argument("--min-height", type=int, default=1024)
+    parser.add_argument("--max-nsfw", type=float, default=0.3)
+    parser.add_argument("--min-clip", type=float, default=0.25)
+    parser.add_argument("--max-watermark", type=float, default=0.5)
+    parser.add_argument("--max-records", type=int, default=None)
+    parser.add_argument("--filter-4k", action="store_true", help="Filter for 4K+ images only")
+    args = parser.parse_args()
+
+    if args.filter_4k:
+        filter_4k(args.input_dir, args.output_dir / "coyo_4k.parquet")
+    else:
+        filter_parquet(
+            args.input_dir,
+            args.output_dir / "coyo_aesthetic.parquet",
+            min_aesthetic=args.min_aesthetic,
+            min_width=args.min_width,
+            min_height=args.min_height,
+            max_nsfw=args.max_nsfw,
+            min_clip_score=args.min_clip,
+            max_watermark=args.max_watermark,
+            max_records=args.max_records,
+        )

scripts/data_collection/prepare_webdataset.py

@@ -0,0 +1,68 @@
+"""
+Prepare dataset for Flux fine-tuning.
+Combines images + captions into WebDataset format (tar shards).
+"""
+import json
+import io
+import argparse
+from pathlib import Path
+
+import webdataset as wds
+from PIL import Image
+from tqdm import tqdm
+
+IMAGE_DIR = Path("/home/adminuser/chungcat/data/raw/unsplash")
+CAPTION_DIR = Path("/home/adminuser/chungcat/data/captions")
+OUTPUT_DIR = Path("/home/adminuser/chungcat/data/processed/flux_train")
+
+
+def create_webdataset(image_dir, caption_dir, output_dir, shard_size=1000):
+    output_dir.mkdir(parents=True, exist_ok=True)
+    pattern = str(output_dir / "shard-%06d.tar")
+
+    captions = list(caption_dir.glob("*.json"))
+    print(f"Found {len(captions)} captions")
+
+    with wds.ShardWriter(pattern, maxcount=shard_size) as sink:
+        written = 0
+        for cap_path in tqdm(captions):
+            meta = json.loads(cap_path.read_text())
+            stem = cap_path.stem
+
+            img_path = image_dir / f"{stem}.jpg"
+            if not img_path.exists():
+                img_path = image_dir / f"{stem}.png"
+            if not img_path.exists():
+                continue
+
+            try:
+                img = Image.open(img_path).convert("RGB")
+                img = img.resize((1024, 1024), Image.LANCZOS)
+
+                img_bytes = io.BytesIO()
+                img.save(img_bytes, format="JPEG", quality=95)
+                img_bytes = img_bytes.getvalue()
+
+                sample = {
+                    "__key__": stem,
+                    "jpg": img_bytes,
+                    "txt": meta["caption"],
+                    "json": json.dumps(meta).encode(),
+                }
+                sink.write(sample)
+                written += 1
+            except Exception as e:
+                print(f"Error {stem}: {e}")
+
+    print(f"Done! Written {written} samples to {output_dir}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Prepare WebDataset for Flux training")
+    parser.add_argument("--image-dir", type=Path, default=IMAGE_DIR)
+    parser.add_argument("--caption-dir", type=Path, default=CAPTION_DIR)
+    parser.add_argument("--output-dir", type=Path, default=OUTPUT_DIR)
+    parser.add_argument("--shard-size", type=int, default=1000)
+    args = parser.parse_args()
+
+    create_webdataset(args.image_dir, args.caption_dir, args.output_dir, args.shard_size)

scripts/serving/api_server.py

@@ -0,0 +1,136 @@
+"""
+FastAPI server for 4K image generation.
+"""
+import asyncio
+import uuid
+import time
+from pathlib import Path
+
+import torch
+from fastapi import FastAPI, BackgroundTasks
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+from inference import load_flux_pipeline, load_sr_model, generate_4k
+
+app = FastAPI(title="4K Image Generation API")
+
+# Global models (loaded on startup)
+flux_pipe = None
+sr_stage2 = None
+sr_stage3 = None
+jobs = {}
+
+OUTPUT_DIR = Path("/home/adminuser/chungcat/outputs/api")
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    resolution: str = "4k"  # "1k", "2k", "4k"
+    steps: int = 28
+    guidance_scale: float = 3.5
+
+
+class JobStatus(BaseModel):
+    job_id: str
+    status: str  # "pending", "processing", "completed", "failed"
+    resolution: str
+    elapsed_seconds: float = 0
+    result_url: str = None
+    error: str = None
+
+
+@app.on_event("startup")
+async def startup():
+    global flux_pipe, sr_stage2, sr_stage3
+
+    flux_pipe = load_flux_pipeline(
+        "black-forest-labs/FLUX.1-schnell",
+        lora_path=Path("/home/adminuser/chungcat/checkpoints/flux_lora/final"),
+        device="cuda:0",
+    )
+    sr_stage2 = load_sr_model(
+        "/home/adminuser/chungcat/checkpoints/sr_stage2/final/model.pt",
+        device="cuda:1",
+    )
+    sr_stage3 = load_sr_model(
+        "/home/adminuser/chungcat/checkpoints/sr_stage3/final/model.pt",
+        device="cuda:1",
+    )
+    print("All models loaded!")
+
+
+def process_job(job_id: str, request: GenerateRequest):
+    jobs[job_id]["status"] = "processing"
+    t0 = time.time()
+
+    try:
+        image = generate_4k(
+            prompt=request.prompt,
+            flux_pipe=flux_pipe,
+            sr_stage2=sr_stage2,
+            sr_stage3=sr_stage3,
+            output_path=OUTPUT_DIR / job_id,
+            num_inference_steps=request.steps,
+            guidance_scale=request.guidance_scale,
+        )
+
+        jobs[job_id]["status"] = "completed"
+        jobs[job_id]["elapsed_seconds"] = time.time() - t0
+
+        stem = request.prompt[:50].replace(" ", "_").replace("/", "_")
+        res_suffix = request.resolution
+        jobs[job_id]["result_url"] = f"/result/{job_id}/{stem}_{res_suffix}.png"
+
+    except Exception as e:
+        jobs[job_id]["status"] = "failed"
+        jobs[job_id]["error"] = str(e)
+        jobs[job_id]["elapsed_seconds"] = time.time() - t0
+
+
+@app.post("/generate", response_model=JobStatus)
+async def generate(request: GenerateRequest, background_tasks: BackgroundTasks):
+    job_id = str(uuid.uuid4())[:8]
+    jobs[job_id] = {
+        "job_id": job_id,
+        "status": "pending",
+        "resolution": request.resolution,
+        "elapsed_seconds": 0,
+    }
+
+    background_tasks.add_task(process_job, job_id, request)
+    return JobStatus(**jobs[job_id])
+
+
+@app.get("/status/{job_id}", response_model=JobStatus)
+async def get_status(job_id: str):
+    if job_id not in jobs:
+        return JobStatus(job_id=job_id, status="not_found", resolution="")
+    return JobStatus(**jobs[job_id])
+
+
+@app.get("/result/{job_id}/{filename}")
+async def get_result(job_id: str, filename: str):
+    file_path = OUTPUT_DIR / job_id / filename
+    if not file_path.exists():
+        return {"error": "File not found"}
+    return FileResponse(file_path, media_type="image/png")
+
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok",
+        "gpu_0": torch.cuda.get_device_name(0),
+        "gpu_1": torch.cuda.get_device_name(1),
+        "gpu_0_memory_used": f"{torch.cuda.memory_allocated(0) / 1024**3:.1f} GB",
+        "gpu_1_memory_used": f"{torch.cuda.memory_allocated(1) / 1024**3:.1f} GB",
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

scripts/serving/inference.py

@@ -0,0 +1,134 @@
+"""
+Inference pipeline: Generate 4K image from text prompt.
+Stage 1 (Flux) → Stage 2 (SR 1K→2K) → Stage 3 (SR 2K→4K)
+"""
+import argparse
+import time
+from pathlib import Path
+
+import torch
+from PIL import Image
+from diffusers import FluxPipeline
+from peft import PeftModel
+
+from train_sr import SRUNet
+
+
+def load_flux_pipeline(base_model, lora_path=None, device="cuda:0"):
+    print(f"Loading Flux from {base_model}...")
+    pipe = FluxPipeline.from_pretrained(
+        base_model,
+        torch_dtype=torch.bfloat16,
+    ).to(device)
+
+    if lora_path:
+        print(f"Loading LoRA from {lora_path}...")
+        pipe.transformer = PeftModel.from_pretrained(pipe.transformer, lora_path)
+
+    return pipe
+
+
+def load_sr_model(checkpoint_path, base_channels=64, device="cuda:1"):
+    print(f"Loading SR model from {checkpoint_path}...")
+    model = SRUNet(in_channels=3, out_channels=3, base_channels=base_channels, scale_factor=2)
+    state_dict = torch.load(checkpoint_path, map_location="cpu")
+    model.load_state_dict(state_dict)
+    model = model.to(device, dtype=torch.bfloat16)
+    model.eval()
+    return model
+
+
+def image_to_tensor(image, device):
+    from torchvision import transforms
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
+    ])
+    return transform(image).unsqueeze(0).to(device, dtype=torch.bfloat16)
+
+
+def tensor_to_image(tensor):
+    tensor = tensor.squeeze(0).float().cpu()
+    tensor = tensor * 0.5 + 0.5
+    tensor = tensor.clamp(0, 1)
+    from torchvision.transforms.functional import to_pil_image
+    return to_pil_image(tensor)
+
+
+@torch.no_grad()
+def generate_4k(prompt, flux_pipe, sr_stage2, sr_stage3, output_path, num_inference_steps=28, guidance_scale=3.5):
+    print(f"\nGenerating: '{prompt}'")
+    t0 = time.time()
+
+    # Stage 1: Generate 1024px with Flux
+    print("  Stage 1: Generating 1024px...")
+    image_1k = flux_pipe(
+        prompt=prompt,
+        num_inference_steps=num_inference_steps,
+        guidance_scale=guidance_scale,
+        width=1024,
+        height=1024,
+    ).images[0]
+    t1 = time.time()
+    print(f"    Done in {t1-t0:.1f}s")
+
+    # Stage 2: Upscale 1K → 2K
+    print("  Stage 2: Upscaling to 2K...")
+    device_sr = next(sr_stage2.parameters()).device
+    input_tensor = image_to_tensor(image_1k, device_sr)
+    output_2k = sr_stage2(input_tensor)
+    image_2k = tensor_to_image(output_2k)
+    t2 = time.time()
+    print(f"    Done in {t2-t1:.1f}s ({image_2k.size[0]}x{image_2k.size[1]})")
+
+    # Stage 3: Upscale 2K → 4K
+    print("  Stage 3: Upscaling to 4K...")
+    input_tensor = image_to_tensor(image_2k, device_sr)
+    output_4k = sr_stage3(input_tensor)
+    image_4k = tensor_to_image(output_4k)
+    t3 = time.time()
+    print(f"    Done in {t3-t2:.1f}s ({image_4k.size[0]}x{image_4k.size[1]})")
+
+    # Save all stages
+    output_path = Path(output_path)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    stem = prompt[:50].replace(" ", "_").replace("/", "_")
+    image_1k.save(output_path / f"{stem}_1k.png")
+    image_2k.save(output_path / f"{stem}_2k.png")
+    image_4k.save(output_path / f"{stem}_4k.png")
+
+    print(f"\n  Total time: {t3-t0:.1f}s")
+    print(f"  Saved to: {output_path}")
+
+    return image_4k
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate 4K images")
+    parser.add_argument("--prompt", required=True, help="Text prompt")
+    parser.add_argument("--flux-model", default="black-forest-labs/FLUX.1-schnell")
+    parser.add_argument("--lora-path", type=Path, default=None)
+    parser.add_argument("--sr-stage2", type=Path, default=Path("/home/adminuser/chungcat/checkpoints/sr_stage2/final/model.pt"))
+    parser.add_argument("--sr-stage3", type=Path, default=Path("/home/adminuser/chungcat/checkpoints/sr_stage3/final/model.pt"))
+    parser.add_argument("--output-dir", type=Path, default=Path("/home/adminuser/chungcat/outputs"))
+    parser.add_argument("--steps", type=int, default=28)
+    parser.add_argument("--guidance-scale", type=float, default=3.5)
+    parser.add_argument("--flux-device", default="cuda:0")
+    parser.add_argument("--sr-device", default="cuda:1")
+    args = parser.parse_args()
+
+    # Load models
+    flux_pipe = load_flux_pipeline(args.flux_model, args.lora_path, args.flux_device)
+    sr_stage2 = load_sr_model(args.sr_stage2, device=args.sr_device)
+    sr_stage3 = load_sr_model(args.sr_stage3, device=args.sr_device)
+
+    # Generate
+    generate_4k(
+        args.prompt, flux_pipe, sr_stage2, sr_stage3,
+        args.output_dir, args.steps, args.guidance_scale,
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/training/run_train_flux.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Launch Flux LoRA training on 2x H100
+# Usage: bash scripts/training/run_train_flux.sh
+
+export PYTHONPATH="/home/adminuser/chungcat:$PYTHONPATH"
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+accelerate launch \
+    --config_file /home/adminuser/chungcat/configs/accelerate_config.yaml \
+    /home/adminuser/chungcat/scripts/training/train_flux_lora.py \
+    --model-name "black-forest-labs/FLUX.1-schnell" \
+    --data-dir "/home/adminuser/chungcat/data/processed/flux_train/shards" \
+    --output-dir "/home/adminuser/chungcat/checkpoints/flux_lora" \
+    --resolution 1024 \
+    --batch-size 1 \
+    --gradient-accumulation 4 \
+    --learning-rate 1e-4 \
+    --lr-scheduler cosine \
+    --lr-warmup-steps 500 \
+    --max-train-steps 100000 \
+    --save-steps 5000 \
+    --lora-rank 128 \
+    --lora-alpha 128 \
+    --mixed-precision bf16 \
+    --seed 42

scripts/training/run_train_sr_stage2.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Launch SR Stage 2 training (1K → 2K)
+# Usage: bash scripts/training/run_train_sr_stage2.sh
+
+export PYTHONPATH="/home/adminuser/chungcat:$PYTHONPATH"
+
+accelerate launch \
+    --config_file /home/adminuser/chungcat/configs/accelerate_config.yaml \
+    /home/adminuser/chungcat/scripts/training/train_sr.py \
+    --stage 2 \
+    --batch-size 4 \
+    --learning-rate 2e-4 \
+    --max-steps 200000 \
+    --save-steps 10000 \
+    --base-channels 64 \
+    --perceptual-weight 0.1

scripts/training/run_train_sr_stage3.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Launch SR Stage 3 training (2K → 4K)
+# Usage: bash scripts/training/run_train_sr_stage3.sh
+
+export PYTHONPATH="/home/adminuser/chungcat:$PYTHONPATH"
+
+accelerate launch \
+    --config_file /home/adminuser/chungcat/configs/accelerate_config.yaml \
+    /home/adminuser/chungcat/scripts/training/train_sr.py \
+    --stage 3 \
+    --batch-size 2 \
+    --learning-rate 1e-4 \
+    --max-steps 200000 \
+    --save-steps 10000 \
+    --base-channels 64 \
+    --perceptual-weight 0.1

scripts/training/train_flux_lora.py

@@ -0,0 +1,240 @@
+"""
+Fine-tune Flux model using LoRA on downloaded COYO dataset.
+Uses diffusers + accelerate + DeepSpeed for multi-GPU training.
+"""
+import argparse
+import math
+from pathlib import Path
+
+import torch
+import webdataset as wds
+from PIL import Image
+from torchvision import transforms
+from diffusers import FluxPipeline, FluxTransformer2DModel
+from diffusers.training_utils import compute_snr
+from peft import LoraConfig, get_peft_model
+from accelerate import Accelerator
+from accelerate.utils import ProjectConfiguration
+from transformers import CLIPTextModel, CLIPTokenizer, T5EncoderModel, T5TokenizerFast
+import wandb
+
+
+def get_train_transforms(resolution=1024):
+    return transforms.Compose([
+        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.LANCZOS),
+        transforms.CenterCrop(resolution),
+        transforms.ToTensor(),
+        transforms.Normalize([0.5], [0.5]),
+    ])
+
+
+def create_webdataset(data_dir, resolution=1024, batch_size=4):
+    transform = get_train_transforms(resolution)
+
+    def preprocess(sample):
+        image = sample["jpg"]
+        if isinstance(image, bytes):
+            import io
+            image = Image.open(io.BytesIO(image)).convert("RGB")
+        caption = sample["txt"]
+        if isinstance(caption, bytes):
+            caption = caption.decode("utf-8")
+        return {"image": transform(image), "caption": caption}
+
+    tar_files = sorted(Path(data_dir).glob("*.tar"))
+    if not tar_files:
+        raise ValueError(f"No tar files found in {data_dir}")
+
+    dataset = (
+        wds.WebDataset([str(f) for f in tar_files], shardshuffle=True)
+        .shuffle(1000)
+        .decode("pil")
+        .map(preprocess)
+        .batched(batch_size)
+    )
+    return dataset
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fine-tune Flux with LoRA")
+    parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-schnell")
+    parser.add_argument("--data-dir", type=Path, default=Path("/home/adminuser/chungcat/data/processed/flux_train/shards"))
+    parser.add_argument("--output-dir", type=Path, default=Path("/home/adminuser/chungcat/checkpoints/flux_lora"))
+    parser.add_argument("--resolution", type=int, default=1024)
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--gradient-accumulation", type=int, default=4)
+    parser.add_argument("--learning-rate", type=float, default=1e-4)
+    parser.add_argument("--lr-scheduler", default="cosine")
+    parser.add_argument("--lr-warmup-steps", type=int, default=500)
+    parser.add_argument("--max-train-steps", type=int, default=100000)
+    parser.add_argument("--save-steps", type=int, default=5000)
+    parser.add_argument("--lora-rank", type=int, default=128)
+    parser.add_argument("--lora-alpha", type=int, default=128)
+    parser.add_argument("--mixed-precision", default="bf16")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--use-wandb", action="store_true")
+    parser.add_argument("--wandb-project", default="flux-finetune")
+    args = parser.parse_args()
+
+    # Setup accelerator
+    project_config = ProjectConfiguration(
+        project_dir=str(args.output_dir),
+        logging_dir=str(args.output_dir / "logs"),
+    )
+    accelerator = Accelerator(
+        mixed_precision=args.mixed_precision,
+        gradient_accumulation_steps=args.gradient_accumulation,
+        project_config=project_config,
+    )
+
+    if accelerator.is_main_process:
+        args.output_dir.mkdir(parents=True, exist_ok=True)
+        if args.use_wandb:
+            wandb.init(project=args.wandb_project, config=vars(args))
+
+    # Load model
+    print(f"Loading model: {args.model_name}")
+    pipe = FluxPipeline.from_pretrained(
+        args.model_name,
+        torch_dtype=torch.bfloat16,
+    )
+
+    transformer = pipe.transformer
+    text_encoder = pipe.text_encoder
+    text_encoder_2 = pipe.text_encoder_2
+    tokenizer = pipe.tokenizer
+    tokenizer_2 = pipe.tokenizer_2
+    vae = pipe.vae
+
+    # Freeze everything except transformer
+    vae.requires_grad_(False)
+    text_encoder.requires_grad_(False)
+    text_encoder_2.requires_grad_(False)
+
+    # Apply LoRA to transformer
+    lora_config = LoraConfig(
+        r=args.lora_rank,
+        lora_alpha=args.lora_alpha,
+        target_modules=["to_q", "to_k", "to_v", "to_out.0", "proj_in", "proj_out"],
+        lora_dropout=0.05,
+    )
+    transformer = get_peft_model(transformer, lora_config)
+    transformer.print_trainable_parameters()
+
+    # Optimizer
+    optimizer = torch.optim.AdamW(
+        transformer.parameters(),
+        lr=args.learning_rate,
+        weight_decay=0.01,
+    )
+
+    # Learning rate scheduler
+    from diffusers.optimization import get_scheduler
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps,
+        num_training_steps=args.max_train_steps,
+    )
+
+    # Dataset
+    print(f"Loading dataset from {args.data_dir}")
+    train_dataset = create_webdataset(args.data_dir, args.resolution, args.batch_size)
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset, batch_size=None, num_workers=4, pin_memory=True
+    )
+
+    # Prepare with accelerator
+    transformer, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+        transformer, optimizer, train_dataloader, lr_scheduler
+    )
+
+    # Move frozen models to device
+    vae.to(accelerator.device, dtype=torch.bfloat16)
+    text_encoder.to(accelerator.device, dtype=torch.bfloat16)
+    text_encoder_2.to(accelerator.device, dtype=torch.bfloat16)
+
+    # Training loop
+    global_step = 0
+    print(f"Starting training for {args.max_train_steps} steps...")
+
+    transformer.train()
+    for batch in train_dataloader:
+        if global_step >= args.max_train_steps:
+            break
+
+        with accelerator.accumulate(transformer):
+            images = batch["image"].to(accelerator.device, dtype=torch.bfloat16)
+            captions = batch["caption"]
+
+            # Encode images to latents
+            with torch.no_grad():
+                latents = vae.encode(images).latent_dist.sample()
+                latents = (latents - vae.config.shift_factor) * vae.config.scaling_factor
+
+            # Encode text
+            with torch.no_grad():
+                text_input_ids = tokenizer(
+                    captions, padding="max_length", max_length=77,
+                    truncation=True, return_tensors="pt"
+                ).input_ids.to(accelerator.device)
+                encoder_hidden_states = text_encoder(text_input_ids)[0]
+
+                text_input_ids_2 = tokenizer_2(
+                    captions, padding="max_length", max_length=512,
+                    truncation=True, return_tensors="pt"
+                ).input_ids.to(accelerator.device)
+                pooled_prompt_embeds = text_encoder_2(text_input_ids_2)[0]
+
+            # Sample noise and timesteps
+            noise = torch.randn_like(latents)
+            timesteps = torch.randint(0, 1000, (latents.shape[0],), device=latents.device).long()
+
+            # Add noise to latents
+            noisy_latents = pipe.scheduler.add_noise(latents, noise, timesteps)
+
+            # Predict noise
+            model_pred = transformer(
+                hidden_states=noisy_latents,
+                timestep=timesteps,
+                encoder_hidden_states=encoder_hidden_states,
+                pooled_projections=pooled_prompt_embeds,
+                return_dict=False,
+            )[0]
+
+            # Loss
+            loss = torch.nn.functional.mse_loss(model_pred, noise, reduction="mean")
+
+            accelerator.backward(loss)
+            if accelerator.sync_gradients:
+                accelerator.clip_grad_norm_(transformer.parameters(), 1.0)
+            optimizer.step()
+            lr_scheduler.step()
+            optimizer.zero_grad()
+
+        if accelerator.sync_gradients:
+            global_step += 1
+
+            if global_step % 100 == 0:
+                if accelerator.is_main_process:
+                    print(f"Step {global_step}/{args.max_train_steps}, Loss: {loss.item():.4f}, LR: {lr_scheduler.get_last_lr()[0]:.2e}")
+                    if args.use_wandb:
+                        wandb.log({"loss": loss.item(), "lr": lr_scheduler.get_last_lr()[0], "step": global_step})
+
+            if global_step % args.save_steps == 0:
+                if accelerator.is_main_process:
+                    save_path = args.output_dir / f"checkpoint-{global_step}"
+                    accelerator.unwrap_model(transformer).save_pretrained(save_path)
+                    print(f"Saved checkpoint to {save_path}")
+
+    # Save final model
+    if accelerator.is_main_process:
+        final_path = args.output_dir / "final"
+        accelerator.unwrap_model(transformer).save_pretrained(final_path)
+        print(f"Training complete! Final model saved to {final_path}")
+        if args.use_wandb:
+            wandb.finish()
+
+
+if __name__ == "__main__":
+    main()

scripts/training/train_sr.py

@@ -0,0 +1,315 @@
+"""
+Train Super-Resolution model (Stage 2: 1K→2K, Stage 3: 2K→4K).
+Uses a diffusion-based SR approach similar to StableSR/SUPIR.
+"""
+import argparse
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+from PIL import Image
+from accelerate import Accelerator
+from accelerate.utils import ProjectConfiguration
+from tqdm import tqdm
+import wandb
+
+
+class SRDataset(Dataset):
+    def __init__(self, input_dir, target_dir, input_size, target_size):
+        self.input_dir = Path(input_dir)
+        self.target_dir = Path(target_dir)
+        self.input_size = input_size
+        self.target_size = target_size
+
+        self.input_files = sorted(self.input_dir.glob("*.png"))
+        self.target_files = sorted(self.target_dir.glob("*.png"))
+
+        # Match by filename
+        input_stems = {f.stem: f for f in self.input_files}
+        target_stems = {f.stem: f for f in self.target_files}
+        common = set(input_stems.keys()) & set(target_stems.keys())
+
+        self.pairs = [(input_stems[s], target_stems[s]) for s in sorted(common)]
+        print(f"Found {len(self.pairs)} image pairs")
+
+        self.input_transform = transforms.Compose([
+            transforms.Resize((input_size, input_size), interpolation=transforms.InterpolationMode.LANCZOS),
+            transforms.ToTensor(),
+            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
+        ])
+        self.target_transform = transforms.Compose([
+            transforms.Resize((target_size, target_size), interpolation=transforms.InterpolationMode.LANCZOS),
+            transforms.ToTensor(),
+            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
+        ])
+
+    def __len__(self):
+        return len(self.pairs)
+
+    def __getitem__(self, idx):
+        input_path, target_path = self.pairs[idx]
+        input_img = Image.open(input_path).convert("RGB")
+        target_img = Image.open(target_path).convert("RGB")
+        return {
+            "input": self.input_transform(input_img),
+            "target": self.target_transform(target_img),
+        }
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.conv1 = nn.Conv2d(channels, channels, 3, padding=1)
+        self.conv2 = nn.Conv2d(channels, channels, 3, padding=1)
+        self.norm1 = nn.GroupNorm(8, channels)
+        self.norm2 = nn.GroupNorm(8, channels)
+
+    def forward(self, x):
+        residual = x
+        x = F.silu(self.norm1(self.conv1(x)))
+        x = self.norm2(self.conv2(x))
+        return x + residual
+
+
+class SRUNet(nn.Module):
+    """Simple U-Net based super-resolution model."""
+    def __init__(self, in_channels=3, out_channels=3, base_channels=64, scale_factor=2):
+        super().__init__()
+        self.scale_factor = scale_factor
+
+        # Encoder
+        self.enc1 = nn.Sequential(
+            nn.Conv2d(in_channels, base_channels, 3, padding=1),
+            ResidualBlock(base_channels),
+            ResidualBlock(base_channels),
+        )
+        self.enc2 = nn.Sequential(
+            nn.Conv2d(base_channels, base_channels * 2, 3, stride=2, padding=1),
+            ResidualBlock(base_channels * 2),
+            ResidualBlock(base_channels * 2),
+        )
+        self.enc3 = nn.Sequential(
+            nn.Conv2d(base_channels * 2, base_channels * 4, 3, stride=2, padding=1),
+            ResidualBlock(base_channels * 4),
+            ResidualBlock(base_channels * 4),
+        )
+
+        # Bottleneck
+        self.bottleneck = nn.Sequential(
+            ResidualBlock(base_channels * 4),
+            ResidualBlock(base_channels * 4),
+        )
+
+        # Decoder
+        self.dec3 = nn.Sequential(
+            nn.ConvTranspose2d(base_channels * 4, base_channels * 2, 4, stride=2, padding=1),
+            ResidualBlock(base_channels * 2),
+            ResidualBlock(base_channels * 2),
+        )
+        self.dec2 = nn.Sequential(
+            nn.ConvTranspose2d(base_channels * 4, base_channels, 4, stride=2, padding=1),
+            ResidualBlock(base_channels),
+            ResidualBlock(base_channels),
+        )
+        self.dec1 = nn.Sequential(
+            ResidualBlock(base_channels * 2),
+            ResidualBlock(base_channels),
+        )
+
+        # Upscale + output
+        self.upscale = nn.Sequential(
+            nn.Conv2d(base_channels, base_channels * (scale_factor ** 2), 3, padding=1),
+            nn.PixelShuffle(scale_factor),
+            nn.Conv2d(base_channels, out_channels, 3, padding=1),
+            nn.Tanh(),
+        )
+
+    def forward(self, x):
+        # Encoder
+        e1 = self.enc1(x)
+        e2 = self.enc2(e1)
+        e3 = self.enc3(e2)
+
+        # Bottleneck
+        b = self.bottleneck(e3)
+
+        # Decoder with skip connections
+        d3 = self.dec3(b)
+        d3 = torch.cat([d3, e2], dim=1)
+        d2 = self.dec2(d3)
+        d2 = torch.cat([d2, e1], dim=1)
+        d1 = self.dec1(d2)
+
+        # Upscale
+        out = self.upscale(d1)
+        return out
+
+
+class PerceptualLoss(nn.Module):
+    """VGG-based perceptual loss."""
+    def __init__(self):
+        super().__init__()
+        from torchvision.models import vgg19, VGG19_Weights
+        vgg = vgg19(weights=VGG19_Weights.DEFAULT).features
+        self.blocks = nn.ModuleList([
+            vgg[:4],   # relu1_2
+            vgg[4:9],  # relu2_2
+            vgg[9:18], # relu3_4
+        ])
+        for p in self.parameters():
+            p.requires_grad = False
+
+    def forward(self, x, target):
+        loss = 0.0
+        for block in self.blocks:
+            x = block(x)
+            with torch.no_grad():
+                target = block(target)
+            loss += F.l1_loss(x, target)
+        return loss
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Train SR model")
+    parser.add_argument("--stage", type=int, choices=[2, 3], required=True, help="Stage 2 (1K→2K) or Stage 3 (2K→4K)")
+    parser.add_argument("--input-dir", type=Path, default=None)
+    parser.add_argument("--target-dir", type=Path, default=None)
+    parser.add_argument("--output-dir", type=Path, default=None)
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--learning-rate", type=float, default=2e-4)
+    parser.add_argument("--max-steps", type=int, default=200000)
+    parser.add_argument("--save-steps", type=int, default=10000)
+    parser.add_argument("--base-channels", type=int, default=64)
+    parser.add_argument("--perceptual-weight", type=float, default=0.1)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--use-wandb", action="store_true")
+    args = parser.parse_args()
+
+    # Set defaults based on stage
+    sr_pairs_dir = Path("/home/adminuser/chungcat/data/processed/sr_pairs")
+    if args.stage == 2:
+        args.input_dir = args.input_dir or sr_pairs_dir / "1k_input"
+        args.target_dir = args.target_dir or sr_pairs_dir / "2k_target"
+        args.output_dir = args.output_dir or Path("/home/adminuser/chungcat/checkpoints/sr_stage2")
+        input_size, target_size = 1024, 2048
+    else:
+        args.input_dir = args.input_dir or sr_pairs_dir / "2k_input"
+        args.target_dir = args.target_dir or sr_pairs_dir / "4k_target"
+        args.output_dir = args.output_dir or Path("/home/adminuser/chungcat/checkpoints/sr_stage3")
+        input_size, target_size = 2048, 4096
+
+    # Accelerator
+    project_config = ProjectConfiguration(project_dir=str(args.output_dir))
+    accelerator = Accelerator(
+        mixed_precision="bf16",
+        project_config=project_config,
+    )
+
+    if accelerator.is_main_process:
+        args.output_dir.mkdir(parents=True, exist_ok=True)
+        if args.use_wandb:
+            wandb.init(project=f"sr-stage{args.stage}", config=vars(args))
+
+    # Model
+    model = SRUNet(
+        in_channels=3,
+        out_channels=3,
+        base_channels=args.base_channels,
+        scale_factor=2,
+    )
+
+    # Losses
+    l1_loss = nn.L1Loss()
+    perceptual_loss = PerceptualLoss()
+
+    # Optimizer
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=0.01)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.max_steps)
+
+    # Dataset
+    dataset = SRDataset(args.input_dir, args.target_dir, input_size, target_size)
+    dataloader = DataLoader(
+        dataset, batch_size=args.batch_size, shuffle=True,
+        num_workers=8, pin_memory=True, drop_last=True,
+    )
+
+    # Prepare
+    model, optimizer, dataloader, scheduler = accelerator.prepare(
+        model, optimizer, dataloader, scheduler
+    )
+    perceptual_loss.to(accelerator.device)
+
+    # Training
+    global_step = 0
+    print(f"Starting SR Stage {args.stage} training...")
+    print(f"  Input: {input_size}px → Target: {target_size}px")
+    print(f"  Dataset: {len(dataset)} pairs")
+    print(f"  Max steps: {args.max_steps}")
+
+    model.train()
+    while global_step < args.max_steps:
+        for batch in dataloader:
+            if global_step >= args.max_steps:
+                break
+
+            input_imgs = batch["input"]
+            target_imgs = batch["target"]
+
+            # Forward
+            pred = model(input_imgs)
+
+            # Resize pred to match target if needed
+            if pred.shape != target_imgs.shape:
+                pred = F.interpolate(pred, size=target_imgs.shape[2:], mode="bilinear", align_corners=False)
+
+            # Losses
+            loss_l1 = l1_loss(pred, target_imgs)
+            loss_perceptual = perceptual_loss(pred, target_imgs)
+            loss = loss_l1 + args.perceptual_weight * loss_perceptual
+
+            # Backward
+            accelerator.backward(loss)
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+
+            global_step += 1
+
+            if global_step % 100 == 0 and accelerator.is_main_process:
+                print(f"Step {global_step}/{args.max_steps} | L1: {loss_l1.item():.4f} | Perceptual: {loss_perceptual.item():.4f} | Total: {loss.item():.4f}")
+                if args.use_wandb:
+                    wandb.log({
+                        "loss_l1": loss_l1.item(),
+                        "loss_perceptual": loss_perceptual.item(),
+                        "loss_total": loss.item(),
+                        "lr": scheduler.get_last_lr()[0],
+                        "step": global_step,
+                    })
+
+            if global_step % args.save_steps == 0 and accelerator.is_main_process:
+                save_path = args.output_dir / f"checkpoint-{global_step}"
+                save_path.mkdir(parents=True, exist_ok=True)
+                torch.save(
+                    accelerator.unwrap_model(model).state_dict(),
+                    save_path / "model.pt",
+                )
+                print(f"Saved checkpoint: {save_path}")
+
+    # Save final
+    if accelerator.is_main_process:
+        final_path = args.output_dir / "final"
+        final_path.mkdir(parents=True, exist_ok=True)
+        torch.save(
+            accelerator.unwrap_model(model).state_dict(),
+            final_path / "model.pt",
+        )
+        print(f"Training complete! Model saved to {final_path}")
+        if args.use_wandb:
+            wandb.finish()
+
+
+if __name__ == "__main__":
+    main()