#!/usr/bin/env python3 """ Auto quality check: generate full-quality 1024px samples, compare with previous step, upload to HF. Run after each 2000-step checkpoint. """ import sys import time import json import shutil from pathlib import Path import torch import numpy as np from PIL import Image PROMPTS = [ "a beautiful mountain landscape at sunset, 4k, highly detailed, cinematic lighting", "a cute cat sitting on a windowsill, natural lighting, sharp focus", "a futuristic city skyline at night with neon lights, cyberpunk, ultra detailed", "portrait of a woman with flowers in her hair, oil painting style, masterpiece", ] CKPT_DIR = Path("/data0/checkpoints/flux_lora_train") OUTPUT_DIR = Path("/data1/outputs/quality_check") HISTORY_FILE = OUTPUT_DIR / "history.json" def load_history(): if HISTORY_FILE.exists(): return json.loads(HISTORY_FILE.read_text()) return {} def save_history(history): HISTORY_FILE.write_text(json.dumps(history, indent=2)) def analyze_image(img): arr = np.array(img).astype(float) r, g, b = arr[:,:,0].mean(), arr[:,:,1].mean(), arr[:,:,2].mean() std = arr.std() gray = arr.mean(axis=2) dx = np.diff(gray, axis=1) dy = np.diff(gray, axis=0) edge = (np.abs(dx).mean() + np.abs(dy).mean()) / 2 sat = (arr.max(axis=2) - arr.min(axis=2)).mean() return {"std": round(std, 1), "edge": round(edge, 1), "sat": round(sat, 1), "rgb": f"({r:.0f},{g:.0f},{b:.0f})"} def generate_full_quality(step): from diffusers import FluxTransformer2DModel, FluxPipeline from peft import LoraConfig, get_peft_model, set_peft_model_state_dict import safetensors.torch ckpt_path = CKPT_DIR / f"checkpoint-{step}" / "adapter_model.safetensors" if not ckpt_path.exists(): print(f" Checkpoint {step} not found") return None print(f" Loading Flux Dev + LoRA (step {step})...") transformer = FluxTransformer2DModel.from_pretrained( "black-forest-labs/FLUX.1-dev", subfolder="transformer", torch_dtype=torch.bfloat16, cache_dir="/data0/models", ) lora_target_modules = [ "attn.to_q", "attn.to_k", "attn.to_v", "attn.to_out.0", "attn.add_k_proj", "attn.add_q_proj", "attn.add_v_proj", "attn.to_add_out", "ff.net.0.proj", "ff.net.2", "ff_context.net.0.proj", "ff_context.net.2", ] lora_config = LoraConfig(r=128, lora_alpha=64, target_modules=lora_target_modules, lora_dropout=0.0) transformer = get_peft_model(transformer, lora_config) state_dict = safetensors.torch.load_file(str(ckpt_path)) set_peft_model_state_dict(transformer, state_dict) transformer.eval() pipe = FluxPipeline.from_pretrained( "black-forest-labs/FLUX.1-dev", transformer=transformer, torch_dtype=torch.bfloat16, cache_dir="/data0/models", ) pipe = pipe.to("cuda:0") step_dir = OUTPUT_DIR / f"step_{step}" step_dir.mkdir(parents=True, exist_ok=True) results = [] print(f" Generating 4 images (1024px, 28 steps, guidance 3.5)...") for i, prompt in enumerate(PROMPTS): image = pipe(prompt=prompt, num_inference_steps=28, guidance_scale=3.5, height=1024, width=1024).images[0] image.save(step_dir / f"sample_{i}.png") stats = analyze_image(image) stats["prompt"] = prompt[:50] results.append(stats) print(f" Sample {i}: std={stats['std']}, sat={stats['sat']}, edge={stats['edge']}") del pipe, transformer torch.cuda.empty_cache() return results def compare_and_report(step, current_stats, history): print(f"\n{'='*60}") print(f" REPORT: Step {step}") print(f"{'='*60}") avg_std = np.mean([s["std"] for s in current_stats]) avg_edge = np.mean([s["edge"] for s in current_stats]) avg_sat = np.mean([s["sat"] for s in current_stats]) print(f" Avg std={avg_std:.1f}, edge={avg_edge:.1f}, sat={avg_sat:.1f}") # Compare with previous steps = sorted([int(k) for k in history.keys()]) if steps: prev_step = steps[-1] prev = history[str(prev_step)] prev_avg_std = np.mean([s["std"] for s in prev["stats"]]) prev_avg_edge = np.mean([s["edge"] for s in prev["stats"]]) prev_avg_sat = np.mean([s["sat"] for s in prev["stats"]]) print(f"\n vs Step {prev_step}:") print(f" Std: {prev_avg_std:.1f} → {avg_std:.1f} {'↑' if avg_std > prev_avg_std else '↓'} ({avg_std-prev_avg_std:+.1f})") print(f" Edge: {prev_avg_edge:.1f} → {avg_edge:.1f} {'↑' if avg_edge > prev_avg_edge else '↓'} ({avg_edge-prev_avg_edge:+.1f})") print(f" Sat: {prev_avg_sat:.1f} → {avg_sat:.1f} {'↑' if avg_sat > prev_avg_sat else '↓'} ({avg_sat-prev_avg_sat:+.1f})") # Verdict if avg_sat > 40 and avg_std > 50 and avg_edge > 5: verdict = "GOOD" elif avg_sat > 30 and avg_std > 40: verdict = "OK" else: verdict = "NEEDS MORE TRAINING" print(f"\n Verdict: {verdict}") print(f"{'='*60}\n") return {"avg_std": avg_std, "avg_edge": avg_edge, "avg_sat": avg_sat, "verdict": verdict} def upload_to_hf(step): from huggingface_hub import upload_folder token = open('/home/adminuser/.cache/huggingface/token').read().strip() repo_id = "memoryai/4k-training-samples" step_dir = OUTPUT_DIR / f"step_{step}" print(f" Uploading step_{step} to HF...") upload_folder( folder_path=str(step_dir), repo_id=repo_id, path_in_repo=f"step_{step}_fullquality", repo_type="dataset", token=token, ) print(f" Uploaded!") def main(): step = int(sys.argv[1]) if len(sys.argv) > 1 else None if step is None: # Auto-detect latest checkpoint checkpoints = sorted( [d for d in CKPT_DIR.iterdir() if d.is_dir() and d.name.startswith("checkpoint-")], key=lambda p: int(p.name.split("-")[1]), ) if not checkpoints: print("No checkpoints found") return step = int(checkpoints[-1].name.split("-")[1]) OUTPUT_DIR.mkdir(parents=True, exist_ok=True) history = load_history() # Skip if already done if str(step) in history: print(f" Step {step} already evaluated") return print(f"\n=== Quality Check: Step {step} ===") t0 = time.time() stats = generate_full_quality(step) if stats is None: return summary = compare_and_report(step, stats, history) # Save to history history[str(step)] = {"stats": stats, "summary": summary, "time": time.strftime("%Y-%m-%d %H:%M")} save_history(history) # Upload upload_to_hf(step) print(f" Total time: {time.time()-t0:.0f}s") if __name__ == "__main__": main()