| |
| |
| |
| |
| |
| |
| |
| |
| """Generate independent PolyText PNGs with Qwen-Image or FLUX and optional PEFT LoRA.""" |
|
|
| import argparse |
| import fcntl |
| import json |
| import os |
| import re |
| import time |
| import zlib |
| from pathlib import Path |
| from typing import Any, Dict, List |
|
|
| import torch |
| from diffusers import DiffusionPipeline |
| from peft import PeftModel |
| from PIL import Image |
|
|
| DEFAULT_PROMPTS = Path(__file__).resolve().parent |
| SPLIT_FILES = ( |
| "critical_en.jsonl", |
| "optional_en.jsonl", |
| "critical_zh.jsonl", |
| "optional_zh.jsonl", |
| ) |
|
|
|
|
| def read_jsonl(path: Path) -> List[Dict[str, Any]]: |
| """Read nonempty JSONL records.""" |
| return [json.loads(line) for line in path.read_text().splitlines() if line.strip()] |
|
|
|
|
| def prompt_key(row: Dict[str, Any]) -> str: |
| """Return the collision-free pair/task key.""" |
| pair = row.get("pair_id") |
| task = row.get("task_type") |
| if not isinstance(pair, str) or not re.fullmatch(r"[A-Za-z0-9_-]+", pair): |
| raise ValueError(f"Invalid pair_id: {pair!r}") |
| if task not in ("critical", "optional"): |
| raise ValueError(f"Invalid task_type: {task!r}") |
| return f"{pair}_{task}" |
|
|
|
|
| def load_prompts(path: Path, mode: str) -> List[Dict[str, Any]]: |
| """Load and validate one language of benchmark prompts.""" |
| if path.is_dir(): |
| missing = [name for name in SPLIT_FILES if not (path / name).is_file()] |
| if missing: |
| raise FileNotFoundError(f"Prompt directory {path} is missing {missing}") |
| rows = [row for name in SPLIT_FILES for row in read_jsonl(path / name)] |
| else: |
| rows = read_jsonl(path) |
| selected = [] |
| seen = set() |
| for row in rows: |
| key = prompt_key(row) |
| if key in seen: |
| raise ValueError(f"Duplicate prompt ID: {key}") |
| seen.add(key) |
| if row.get("language") not in ("en", "zh"): |
| raise ValueError(f"Invalid language for {key}: {row.get('language')!r}") |
| targets = row.get("target_list") |
| if not isinstance(targets, list) or any( |
| not isinstance(target, str) or not target.strip() for target in targets |
| ): |
| raise ValueError(f"Invalid target_list for {key}: {targets!r}") |
| if bool(targets) != (row["task_type"] == "critical"): |
| raise ValueError(f"Target/task mismatch for {key}") |
| if not isinstance(row.get("prompt"), str) or not row["prompt"].strip(): |
| raise ValueError(f"Empty prompt for {key}") |
| if row["language"] == mode.lower(): |
| selected.append(row) |
| if not selected: |
| raise ValueError(f"No prompts for mode={mode} in {path}") |
| return selected |
|
|
|
|
| def make_seed(row: Dict[str, Any], repeat: int) -> int: |
| """Return the deterministic paired seed for one repeat.""" |
| return zlib.crc32(f"{row['pair_id']}_{repeat}".encode()) & 0xFFFFFFFF |
|
|
|
|
| def image_complete(path: Path, width: int, height: int) -> bool: |
| """Return whether an image decodes at the required resolution.""" |
| try: |
| with Image.open(path) as image: |
| image.load() |
| return image.size == (width, height) |
| except (OSError, ValueError): |
| return False |
|
|
|
|
| def image_jobs(rows: List[Dict[str, Any]], image_dir: Path, repeats: int) -> List[Dict[str, Any]]: |
| """Enumerate expected output images.""" |
| return [ |
| dict( |
| row=row, |
| repeat=repeat, |
| key=f"{prompt_key(row)}_{repeat}", |
| path=image_dir / f"{prompt_key(row)}_{repeat}.png", |
| ) |
| for row in rows |
| for repeat in range(1, repeats + 1) |
| ] |
|
|
|
|
| def shard_jobs( |
| jobs: List[Dict[str, Any]], |
| task_type: str, |
| node_index: int, |
| num_nodes: int, |
| rank: int, |
| world_size: int, |
| ) -> List[Dict[str, Any]]: |
| """Partition jobs across nodes and local workers without padding.""" |
| if num_nodes < 1 or not 0 <= node_index < num_nodes: |
| raise ValueError(f"Expected 0 <= node_index({node_index}) < num_nodes({num_nodes})") |
| if world_size < 1 or not 0 <= rank < world_size: |
| raise ValueError(f"Expected 0 <= rank({rank}) < world_size({world_size})") |
| selected = [job for job in jobs if task_type == "all" or job["row"]["task_type"] == task_type] |
| return selected[node_index::num_nodes][rank::world_size] |
|
|
|
|
| def atomic_json(path: Path, value: Any) -> None: |
| """Write JSON atomically.""" |
| path.parent.mkdir(parents=True, exist_ok=True) |
| temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp") |
| temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n") |
| temporary.replace(path) |
|
|
|
|
| def main() -> None: |
| """Run disjoint torchrun workers without padding or inter-rank collectives.""" |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--model-family", choices=["qwen", "flux"], required=True) |
| parser.add_argument("--mode", choices=["EN", "ZH"], default="EN") |
| parser.add_argument("--model_name", required=True) |
| parser.add_argument("--model_path", required=True) |
| parser.add_argument("--ckpt_path") |
| parser.add_argument("--gallery_output_dir", type=Path, required=True) |
| parser.add_argument("--negative_prompt", default=None) |
| parser.add_argument("--width", type=int, default=1024) |
| parser.add_argument("--height", type=int, default=1024) |
| parser.add_argument("--steps", type=int, default=50) |
| parser.add_argument("--repeats", type=int, default=4) |
| parser.add_argument("--prompts", type=Path, default=DEFAULT_PROMPTS) |
| parser.add_argument("--limit-prompts", type=int) |
| parser.add_argument("--dry-run", action="store_true") |
| parser.add_argument("--task-type", choices=["all", "critical", "optional"], default="all") |
| parser.add_argument("--node-index", type=int, default=0) |
| parser.add_argument("--num-nodes", type=int, default=1) |
| parser.add_argument("--progress-dir", type=Path) |
| args = parser.parse_args() |
| if min(args.width, args.height, args.steps, args.repeats) <= 0: |
| parser.error("Dimensions, steps and repeats must be positive") |
| if args.limit_prompts is not None and args.limit_prompts <= 0: |
| parser.error("limit-prompts must be positive") |
| rows = load_prompts(args.prompts, args.mode) |
| if args.limit_prompts: |
| rows = rows[: args.limit_prompts] |
| output = args.gallery_output_dir / f"{args.model_name}_{args.mode}" |
| jobs = image_jobs(rows, output, args.repeats) |
| rank, world = int(os.environ.get("RANK", 0)), int(os.environ.get("WORLD_SIZE", 1)) |
| local_rank = int(os.environ.get("LOCAL_RANK", 0)) |
| owned = shard_jobs(jobs, args.task_type, args.node_index, args.num_nodes, rank, world) |
| if args.dry_run: |
| print( |
| json.dumps( |
| dict( |
| output=str(output), |
| expected=len(jobs), |
| rank=rank, |
| owned=len(owned), |
| first=str(owned[0]["path"]) if owned else None, |
| ) |
| ) |
| ) |
| return |
| adapter = None |
| if args.ckpt_path and args.ckpt_path != "None": |
| adapter = Path(args.ckpt_path) |
| if adapter.is_file(): |
| adapter = adapter.parent |
| if ( |
| not (adapter / "adapter_config.json").is_file() |
| or not (adapter / "adapter_model.safetensors").is_file() |
| ): |
| raise FileNotFoundError(f"Incomplete PEFT adapter: {adapter}") |
| negative = args.negative_prompt |
| if negative in (None, "", "None"): |
| negative = " " if args.model_family == "qwen" else None |
| protocol = dict( |
| version=1, |
| prompts=rows, |
| model_path=args.model_path, |
| adapter=str(adapter.resolve()) if adapter else None, |
| adapter_stat=( |
| (adapter / "adapter_model.safetensors").stat().st_mtime_ns if adapter else None |
| ), |
| model_family=args.model_family, |
| width=args.width, |
| height=args.height, |
| steps=args.steps, |
| repeats=args.repeats, |
| negative_prompt=negative, |
| guidance=4.0 if args.model_family == "qwen" else 3.5, |
| seeds=( |
| "explicit_prompt_seeds_or_crc32(pair_id_repeat)" |
| if any("seeds" in row for row in rows) |
| else "crc32(pair_id_repeat)" |
| ), |
| ) |
| output.mkdir(parents=True, exist_ok=True) |
| with (output / ".generation.lock").open("a") as lock: |
| fcntl.flock(lock, fcntl.LOCK_EX) |
| manifest = output / "generation.json" |
| if manifest.exists(): |
| if json.loads(manifest.read_text()) != protocol: |
| raise ValueError("Generation settings changed; choose a new model/output directory") |
| elif any(output.glob("*.png")): |
| raise ValueError("Existing images lack generation provenance; choose a fresh directory") |
| else: |
| atomic_json(manifest, protocol) |
| pending = [job for job in owned if not image_complete(job["path"], args.width, args.height)] |
| initial_done = len(owned) - len(pending) |
| durations = [] |
| started_at = time.time() |
|
|
| def report(state: str, completed: int) -> None: |
| if args.progress_dir: |
| remaining = len(owned) - completed |
| seconds_per_image = sum(durations[-8:]) / len(durations[-8:]) if durations else None |
| atomic_json( |
| args.progress_dir / f"rank-{rank}.json", |
| dict( |
| rank=rank, |
| pid=os.getpid(), |
| observed_at=time.time(), |
| started_at=started_at, |
| state=state, |
| done=completed, |
| total=len(owned), |
| initial_done=initial_done, |
| eta_sec=( |
| remaining * seconds_per_image if seconds_per_image is not None else None |
| ), |
| seconds_per_image=seconds_per_image, |
| task_type=args.task_type, |
| node_index=args.node_index, |
| num_nodes=args.num_nodes, |
| ), |
| ) |
|
|
| report("loading", initial_done) |
| if not pending: |
| report("done", len(owned)) |
| print(f"Rank {rank}: all assigned images complete") |
| return |
| device = torch.device("cuda", local_rank) |
| torch.cuda.set_device(device) |
| pipe = DiffusionPipeline.from_pretrained(args.model_path, torch_dtype=torch.bfloat16).to(device) |
| pipe.set_progress_bar_config(disable=True) |
| if adapter: |
| pipe.transformer = PeftModel.from_pretrained(pipe.transformer, str(adapter)) |
| pipe.transformer.eval() |
| kwargs = dict(width=args.width, height=args.height, num_inference_steps=args.steps) |
| if args.model_family == "qwen": |
| kwargs.update(negative_prompt=negative, true_cfg_scale=4.0) |
| else: |
| kwargs.update(guidance_scale=3.5) |
| if negative is not None: |
| kwargs.update(negative_prompt=negative, true_cfg_scale=4.0) |
| for index, job in enumerate(pending): |
| image_started = time.monotonic() |
| with torch.inference_mode(): |
| image = pipe( |
| prompt=job["row"]["prompt"], |
| generator=torch.Generator(device=device).manual_seed( |
| make_seed(job["row"], job["repeat"]) |
| ), |
| **kwargs, |
| ).images[0] |
| tmp = job["path"].with_name(f".{job['key']}.{os.getpid()}.tmp") |
| image.save(tmp, format="PNG") |
| tmp.replace(job["path"]) |
| durations.append(time.monotonic() - image_started) |
| report("generating", initial_done + index + 1) |
| print(f"Rank {rank}: {index + 1}/{len(pending)} {job['path']}", flush=True) |
| report("done", len(owned)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
