| """Generate the pilot training set.
|
|
|
| Clean backgrounds only -- the pilot answers "can SD1.5 + a TE LoRA learn
|
| Devanagari glyph shapes at all", so scene compositing is deliberately out of
|
| scope (see PLAN.md §4b: that decision is deferred until the pilot reports).
|
|
|
| Hard invariants, asserted rather than assumed:
|
| * font em size >= MIN_EM (the measured VAE floor -- FINDINGS.md §2)
|
| * text fits the canvas with margin
|
| * caption fits CLIP's 77-token window, template included
|
| * fg/bg luminance contrast is real
|
| """
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import json
|
| import pathlib
|
| import random
|
| import sys
|
|
|
| sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
| import numpy as np
|
| from PIL import Image, ImageFilter
|
|
|
| from data.captions import make_caption
|
| from render.shaper import load_face, render_line
|
|
|
| RES = 512
|
| MIN_EM = 32
|
| MAX_EM = 120
|
| MARGIN = 24
|
| MAX_TOKENS = 77
|
|
|
|
|
| def load_words(path: pathlib.Path) -> list[str]:
|
| out = []
|
| for line in path.read_text(encoding="utf-8").splitlines():
|
| line = line.strip()
|
| if line and not line.startswith("#"):
|
| out.append(line)
|
| return out
|
|
|
|
|
| def luminance(rgb) -> float:
|
| r, g, b = [c / 255 for c in rgb]
|
| return 0.2126 * r + 0.7152 * g + 0.0722 * b
|
|
|
|
|
| def pick_colors(rng: random.Random) -> tuple[tuple, tuple]:
|
| """Foreground/background with guaranteed contrast.
|
|
|
| Low-contrast text would be destroyed by the VAE just as surely as small
|
| text, so this is enforced, not sampled and hoped for.
|
| """
|
| for _ in range(64):
|
| if rng.random() < 0.45:
|
| bg = tuple(rng.randint(190, 255) for _ in range(3))
|
| fg = tuple(rng.randint(0, 70) for _ in range(3))
|
| elif rng.random() < 0.5:
|
| bg = tuple(rng.randint(0, 80) for _ in range(3))
|
| fg = tuple(rng.randint(185, 255) for _ in range(3))
|
| else:
|
| bg = tuple(rng.randint(0, 255) for _ in range(3))
|
| fg = tuple(rng.randint(0, 255) for _ in range(3))
|
| if abs(luminance(fg) - luminance(bg)) >= 0.35:
|
| return fg, bg
|
| return (0, 0, 0), (255, 255, 255)
|
|
|
|
|
| def make_background(rng: random.Random, bg: tuple) -> Image.Image:
|
| kind = rng.random()
|
| if kind < 0.55:
|
| return Image.new("RGB", (RES, RES), bg)
|
| if kind < 0.85:
|
|
|
| other = tuple(max(0, min(255, c + rng.randint(-45, 45))) for c in bg)
|
| ramp = np.linspace(0.0, 1.0, RES, dtype=np.float32)
|
|
|
| a = (np.tile(ramp[:, None], (1, RES)) if rng.random() < 0.5
|
| else np.tile(ramp[None, :], (RES, 1)))[..., None]
|
| arr = np.array(bg, dtype=np.float32) * (1 - a) + np.array(other, dtype=np.float32) * a
|
| assert arr.shape == (RES, RES, 3), f"bad gradient shape {arr.shape}"
|
| return Image.fromarray(arr.astype(np.uint8))
|
|
|
| base = np.array(Image.new("RGB", (RES, RES), bg), dtype=np.float32)
|
| base += np.random.normal(0, 6, base.shape)
|
| img = Image.fromarray(np.clip(base, 0, 255).astype(np.uint8))
|
| return img.filter(ImageFilter.GaussianBlur(0.6))
|
|
|
|
|
| def render_sample(word: str, fonts: list[str], rng: random.Random):
|
| """Returns (image, mask, meta) or None if no valid layout was found."""
|
| avail = RES - 2 * MARGIN
|
| for _ in range(12):
|
| font = rng.choice(fonts)
|
|
|
|
|
|
|
| try:
|
| ref = load_face(f"fonts/{font}", 64)
|
| rm, _ = render_line(ref, word, pad=6)
|
| except Exception:
|
| continue
|
| fit = int(64 * min(avail / rm.width, avail / rm.height))
|
| hi = min(MAX_EM, fit)
|
| if hi < MIN_EM:
|
| continue
|
| em = rng.randint(MIN_EM, hi)
|
| try:
|
| face = load_face(f"fonts/{font}", em)
|
| mask, m = render_line(face, word, pad=6)
|
| except Exception:
|
| continue
|
| if mask.width > avail or mask.height > avail:
|
| continue
|
| assert em >= MIN_EM, "VAE floor violated"
|
|
|
| fg, bg = pick_colors(rng)
|
| img = make_background(rng, bg)
|
| x = rng.randint(MARGIN, RES - MARGIN - mask.width)
|
| y = rng.randint(MARGIN, RES - MARGIN - mask.height)
|
| img.paste(fg, (x, y), mask)
|
|
|
| full_mask = Image.new("L", (RES, RES), 0)
|
| full_mask.paste(mask, (x, y))
|
| assert img.size == (RES, RES), f"bad canvas {img.size}"
|
| return img, full_mask, {
|
| "font": font, "em": em, "x": x, "y": y,
|
| "w": mask.width, "h": mask.height, "glyphs": m["n_glyphs"],
|
| }
|
| return None
|
|
|
|
|
| def main() -> int:
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--n", type=int, default=4000)
|
| ap.add_argument("--out", default="data/pilot")
|
| ap.add_argument("--holdout", type=int, default=20, help="words reserved for eval")
|
| ap.add_argument("--seed", type=int, default=0)
|
| ap.add_argument("--masks", action="store_true", help="also write glyph masks")
|
| args = ap.parse_args()
|
|
|
| rng = random.Random(args.seed)
|
| np.random.seed(args.seed)
|
|
|
| from transformers import CLIPTokenizer
|
|
|
| try:
|
| tok = CLIPTokenizer.from_pretrained("models/clip")
|
| except Exception:
|
| tok = CLIPTokenizer.from_pretrained(
|
| "stable-diffusion-v1-5/stable-diffusion-v1-5", subfolder="tokenizer")
|
|
|
| words = load_words(pathlib.Path("corpus/pilot_words.txt"))
|
| fonts = [l.strip() for l in pathlib.Path("configs/fonts_ok.txt")
|
| .read_text(encoding="utf-8").splitlines() if l.strip()]
|
| if not fonts:
|
| print("no usable fonts -- run src/diag/font_audit.py"); return 1
|
|
|
|
|
|
|
| shuffled = words[:]
|
| rng.shuffle(shuffled)
|
| holdout = sorted(shuffled[: args.holdout])
|
| train = sorted(shuffled[args.holdout:])
|
|
|
| out = pathlib.Path(args.out)
|
| (out / "images").mkdir(parents=True, exist_ok=True)
|
| if args.masks:
|
| (out / "masks").mkdir(parents=True, exist_ok=True)
|
|
|
| recs, skipped, over = [], 0, 0
|
| for i in range(args.n):
|
| word = rng.choice(train)
|
| got = render_sample(word, fonts, rng)
|
| if got is None:
|
| skipped += 1
|
| continue
|
| img, mask, meta = got
|
|
|
| cap = make_caption(word, rng)
|
| n_tok = len(tok(cap)["input_ids"])
|
| if n_tok > MAX_TOKENS:
|
| over += 1
|
| continue
|
|
|
| name = f"{i:06d}"
|
| img.save(out / "images" / f"{name}.jpg", quality=95)
|
| if args.masks:
|
| mask.save(out / "masks" / f"{name}.png")
|
| recs.append({"file": f"images/{name}.jpg", "text": word,
|
| "caption": cap, "tokens": n_tok, **meta})
|
|
|
| with (out / "metadata.jsonl").open("w", encoding="utf-8") as fh:
|
| for r in recs:
|
| fh.write(json.dumps(r, ensure_ascii=False) + "\n")
|
| (out / "train_words.txt").write_text("\n".join(train) + "\n", encoding="utf-8")
|
| (out / "holdout_words.txt").write_text("\n".join(holdout) + "\n", encoding="utf-8")
|
|
|
| ems = [r["em"] for r in recs]
|
| print(f"wrote {len(recs)} samples to {out}")
|
| print(f" skipped(layout)={skipped} skipped(tokens)={over}")
|
| print(f" train words={len(train)} holdout={len(holdout)}")
|
| print(f" em size: min={min(ems)} max={max(ems)} mean={sum(ems)/len(ems):.1f}")
|
| print(f" tokens : max={max(r['tokens'] for r in recs)}")
|
| print(f" fonts used: {len({r['font'] for r in recs})}/{len(fonts)}")
|
| print(f"\nholdout: {' '.join(holdout)}")
|
| return 0
|
|
|
|
|
| if __name__ == "__main__":
|
| raise SystemExit(main())
|
|
|
