"""Recaption BLIP3o-Recap webdataset shards with Qwen2.5-VL-3B-Instruct (vLLM, one process per GPU). Each image keeps its original caption and gets two new ones; one jsonl per shard with ``{key, source_shard, orig_caption, recap_1, recap_2}``. Rejected samples (see ``violations``) are resampled. Resumable: keys already in a shard's jsonl are skipped and finished shards have a ``.done`` marker. python recaption.py run --shards data/*.tar --out out/ [--limit 1000] [--focus] python recaption.py stats out/*.jsonl [--sim 500] python recaption.py export --src out/ --out hf/recaptions --manifest subset_manifest.json # needs pyarrow """ import argparse import io import json import os import random import re import tarfile import time from concurrent.futures import ThreadPoolExecutor from pathlib import Path MODEL = "Qwen/Qwen2.5-VL-3B-Instruct" MAX_PIXELS = 640 * 28 * 28 SYSTEM = "You are an image captioner. Describe only what is visible." USER = """Describe this image in ONE paragraph of 70–90 words. Order: main subject(s) (count, category, color, size, pose/action) → spatial relations (left/right, front/behind, near/far) → background and setting → lighting, viewpoint, and medium (photo, illustration, 3D render, etc.). Rules: - Start directly with the main subject. Never begin with "The image", "This picture", "In this photo", or similar. - State only what is clearly visible. No guesses ("likely", "possibly", "suggesting", "appears to be"), no mood words ("serene", "vibrant", "charming", "picturesque"), no interpretation of purpose or meaning. - Quote visible text only if it is legible. - No lists, no line breaks, no concluding summary sentence.""" # --focus: appended to the second caption's prompt only, so the two captions differ in emphasis FOCUS = "\nPut extra emphasis on colors, materials, and attributes of each object rather than on the layout." # Decode-time ban of the filtered phrases (the prompt is kept verbatim): without it, Qwen2.5-VL-3B starts ~60% of # captions with "The image ..." and uses one of the banned words in ~80%, so resampling alone cannot fix them. # Openers go through vLLM bad_words (multi-token, works); words through logit_bias (see ban_bias). _SPEC = ("likely", "possibly", "appears", "suggesting", "serene", "vibrant", "charming", "picturesque") # beyond the spec list: inflections and the substitutes the model switches to once the spec words are banned _EXTRA = ("appear", "appeared", "appearing", "suggest", "suggests", "suggested", "seem", "seems", "seemed", "seemingly", "indicating", "indicates", "indicate", "indicated", "indicative", "perhaps", "probably", "might", "possible", "tranquil", "peaceful", "idyllic", "cozy", "inviting", "stunning", "breathtaking", "bustling", "overall", "atmosphere", "ambiance", "ambience", # summary sentences ("The overall ...") and mood # second round, from word counts on the first 177k full-run captions "calm", "lively", "festive", "scenic", "striking", "dramatic", "majestic", "grand", "dynamic", "typical", "emphasizing", "emphasizes", "emphasize", "emphasized", "enjoy", "enjoys", "enjoying", "welcoming", "relaxed", "relaxing", "pleasant", "playful", "harmonious", "elegant", "whimsical", "energetic", "cheerful", "celebratory", "celebrating", "intimate", "aesthetic", "iconic", "mood", "moody", # third round (fixed after the full run with `fix`): guesses that still leaked "potentially", "presumably", "apparently", "supposedly", "hinting", "hints", "implies", "implying", "impression") # interpretive phrases ("creating a sense of calm"), banned through bad_words like the openers _PHRASES = ["creating a", "sense of", "giving a", "giving it", "giving the scene", "giving the image", "adding a", "natural beauty", "looks like", "look like", "what looks", "could be", "may be"] _WORDS = _SPEC + _EXTRA _OPENERS = [f"{a} {b}" for a in ("The", "This", "These") for b in ("image", "picture", "photo", "photograph", "scene", "illustration", "snapshot")] + ["In this", "In the image", "In the picture", "In the photo"] # caption-initial "The"/"This"/"These" (no leading space: a different token from mid-sentence " The"); the model # otherwise dodges every banned opener with "The main object in the image is ...", "The mainsubject ...", etc. _FIRST = ("The", "This", "These") def ban_bias(tokenizer) -> dict[int, float]: """logit_bias -100 on every single-token form of _WORDS (" vibrant", "Appear", ...). vLLM's ``bad_words`` cannot ban them: it keeps the space-prefixed form only when it tokenizes to as many tokens as the bare word, and e.g. "vibrant" is v|ibr|ant while " vibrant" is one token, so mid-sentence uses pass. Rare multi-token forms (sentence-initial "Vibrant") are left to the filter. """ forms = [p + c for x in _WORDS for c in (x, x.capitalize()) for p in ("", " ")] ids = [tokenizer.encode(f, add_special_tokens=False) for f in forms] ids += [tokenizer.encode(f, add_special_tokens=False) for f in _FIRST] return {i[0]: -100.0 for i in ids if len(i) == 1} _OPENER = re.compile( r"^\W*(?:(?:the|this|these)\s+(?:image|picture|photo|photograph|scene|illustration|snapshot)s?\b" r"|in\s+(?:this|the)\s+(?:image|picture|photo|photograph|scene|illustration)\b)", re.I, ) _OPENER_X = re.compile(r"^\W*the\s+main", re.I) _BANNED = re.compile(rf"\b(?:{'|'.join(_SPEC)})\b", re.I) _BANNED_X = re.compile(rf"\b(?:{'|'.join(_EXTRA + tuple(_PHRASES))})\b", re.I) _LIST = re.compile(r"(?:^|\n)\s*(?:[-*•]|\d+[.)])\s") # CJK / kana / Hangul outside quotes: the model drifting into Chinese ("piles of salt结晶"); quoted signage is kept _CJK = re.compile(r"[぀-ヿ㐀-䶿一-鿿가-힯]") _QUOTED = re.compile(r"\"[^\"]*\"|“[^”]*”|「[^」]*」|'[^']*'") def cap(text: str, finished: bool = True, max_words: int | None = None) -> str: """Drop a cut-off last sentence; with ``max_words``, also keep only the whole sentences that fit.""" sents = re.split(r"(?<=[.!?])\s+", text.strip()) if not finished or not sents[-1].endswith((".", "!", "?", '"')): sents = sents[:-1] out, n = [], 0 for x in sents: n += len(x.split()) if max_words and n > max_words: break out.append(x) return " ".join(out) def violations(text: str, finished: bool = True, strict: bool = True) -> list[str]: """Reasons a caption is rejected (empty list = accepted); ``strict=False``: the spec rules only.""" out = [] if _OPENER.search(text) or strict and _OPENER_X.search(text): out.append("opener") bare = _QUOTED.sub("", text) # quoted visible text ("Enjoy the simple things") is kept verbatim if _BANNED.search(bare) or strict and _BANNED_X.search(bare): out.append("banned_word") if "\n" in text.strip() or _LIST.search(text): out.append("newline_list") if _CJK.search(bare): out.append("lang_drift") if len(text.split()) < 60: # no upper bound: max_tokens=160 keeps it far below BERT's 512 tokens out.append("length") if not finished: out.append("truncated") return out def prompt(focus: bool) -> str: return ( f"<|im_start|>system\n{SYSTEM}<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>" f"{USER}{FOCUS if focus else ''}<|im_end|>\n<|im_start|>assistant\n" ) def read_shard(path: Path): """Yield ``(key, jpg bytes, caption)`` from a webdataset tar (members of a key are adjacent).""" cur, parts = None, {} with tarfile.open(path, "r|*") as tar: for m in tar: if not m.isfile(): continue key, ext = m.name.rsplit(".", 1) if key != cur: if cur is not None and "jpg" in parts: yield cur, parts["jpg"], parts.get("txt", b"").decode("utf-8", "replace").strip() cur, parts = key, {} parts[ext] = tar.extractfile(m).read() if cur is not None and "jpg" in parts: yield cur, parts["jpg"], parts.get("txt", b"").decode("utf-8", "replace").strip() def load_image(data: bytes): """Decode and shrink to at most MAX_PIXELS so the processor's own resize is cheap.""" from PIL import Image im = Image.open(io.BytesIO(data)) if im.width * im.height > 4 * MAX_PIXELS: # JPEG DCT-domain downscale, much faster than a full decode im.draft("RGB", (im.width // 2, im.height // 2)) im = im.convert("RGB") s = (MAX_PIXELS / (im.width * im.height)) ** 0.5 if s < 1: im = im.resize((max(28, round(im.width * s)), max(28, round(im.height * s))), Image.BICUBIC) return im def claim(out: Path, shard: Path) -> bool: if (out / f"{shard.stem}.done").exists(): return False try: os.close(os.open(out / f"{shard.stem}.lock", os.O_CREAT | os.O_EXCL)) return True except FileExistsError: return False def _patch_bad_words() -> None: """Ban both the bare and the space-prefixed token sequence of every bad word. vLLM keeps the space-prefixed variant only when it has as many tokens as the bare word, so mid-sentence " giving a" (bare g|iving| a) or " whimsical" (bare wh|ims|ical) were never banned. The bad_words kernel itself handles any token sequence; only this expansion (run in the frontend process) is replaced. """ from vllm import SamplingParams def update_from_tokenizer(self, tokenizer) -> None: if not self.bad_words: return ids = [] for w in self.bad_words: for prefix in ("", " "): t = tokenizer.encode(prefix + w.lstrip(), add_special_tokens=False) if t and t not in ids: ids.append(t) self._bad_words_token_ids = ids SamplingParams.update_from_tokenizer = update_from_tokenizer def engine(args): os.environ.setdefault("VLLM_MAX_NUM_BAD_WORDS", "1024") # ~400 sequences with every word form os.environ.setdefault("VLLM_MAX_BAD_WORDS_TOTAL_TOKENS", "4096") from vllm import LLM, SamplingParams _patch_bad_words() llm = LLM( model=args.model, max_model_len=2048, gpu_memory_utilization=args.gpu_mem, enable_prefix_caching=True, limit_mm_per_prompt={"image": 1}, mm_processor_kwargs={"max_pixels": MAX_PIXELS}, seed=args.seed, ) words = [c for x in _WORDS for c in (x, x.capitalize())] # multi-token forms; logit_bias covers single tokens ban = {"bad_words": _OPENERS + _PHRASES + words, "logit_bias": ban_bias(llm.get_tokenizer())} ban = {} if args.no_ban else ban sp = lambda n: SamplingParams(n=n, temperature=0.8, top_p=0.9, max_tokens=160, **ban) # noqa: E731 return llm, sp def run(args): out = Path(args.out) out.mkdir(parents=True, exist_ok=True) llm, sp = engine(args) pool = ThreadPoolExecutor(args.workers) rank = os.environ.get("CUDA_VISIBLE_DEVICES", "0") for shard in map(Path, args.shards): if not claim(out, shard): continue dst = out / f"{shard.stem}.jsonl" seen = {json.loads(l)["key"] for l in open(dst)} if dst.exists() else set() stats = {"images": 0, "samples": 0, "rejected": 0, "reasons": {}, "fallback": [], "gen_s": 0.0} sp_path = out / f"{shard.stem}.stats.json" if sp_path.exists() and seen: stats = json.load(open(sp_path)) t0, done = time.time(), len(seen) items = ((k, j, c) for k, j, c in read_shard(shard) if k not in seen) with open(dst, "a") as f: while True: chunk = [x for _, x in zip(range(args.chunk), items)] if args.limit: chunk = chunk[: max(0, args.limit - done)] if not chunk: break imgs = list(pool.map(lambda x: load_image(x[1]), chunk)) tg = time.time() rows = recaption(llm, sp, imgs, args.focus, args.retries, stats) stats["gen_s"] += time.time() - tg for (key, _, cap), (r1, r2, ok) in zip(chunk, rows): f.write(json.dumps({"key": key, "source_shard": shard.name, "orig_caption": cap, "recap_1": r1, "recap_2": r2}) + "\n") if not ok: stats["fallback"].append(key) f.flush() done += len(chunk) stats["images"] = done json.dump(stats, open(sp_path, "w")) print(f"[gpu{rank}] {shard.name} {done} imgs {len(chunk) / (time.time() - tg + 1e-9):.1f} img/s " f"(chunk) rej {stats['rejected'] / max(1, stats['samples']):.3f}", flush=True) if args.limit and done >= args.limit: break stats["wall_s"] = stats.get("wall_s", 0) + time.time() - t0 json.dump(stats, open(sp_path, "w")) if not args.limit: (out / f"{shard.stem}.done").touch() (out / f"{shard.stem}.lock").unlink(missing_ok=True) def recaption(llm, sp, imgs, focus, retries, stats, todo=None): """Two accepted captions per image; resample rejected ones up to ``retries`` times, then keep the best. ``todo``: the ``(image, slot)`` pairs to generate (default: both slots of every image); others come back None. """ good = [[[], []] for _ in imgs] # per image, per slot (recap_1 / recap_2): accepted texts best = [[None, None] for _ in imgs] # fallback: (n violations, text) with fewest violations # slot 0 and slot 1 share the same prompt unless --focus, in which case slot 1 gets the FOCUS sentence todo = todo or [(i, s) for i in range(len(imgs)) for s in (0, 1)] asked = set(todo) for attempt in range(retries + 1): if not todo: break reqs, owners = [], [] if focus: for i, s in todo: reqs.append(({"prompt": prompt(s == 1), "multi_modal_data": {"image": imgs[i]}}, 1)) owners.append([(i, s)]) else: # one request per image with n = number of missing slots, so both samples share the prefill by_img = {} for i, s in todo: by_img.setdefault(i, []).append(s) for i, slots in by_img.items(): reqs.append(({"prompt": prompt(False), "multi_modal_data": {"image": imgs[i]}}, len(slots))) owners.append([(i, s) for s in slots]) by_n = {} for k, (_, n) in enumerate(reqs): by_n.setdefault(n, []).append(k) outs = [None] * len(reqs) for n, ks in by_n.items(): for k, o in zip(ks, llm.generate([reqs[k][0] for k in ks], sp(n), use_tqdm=False)): outs[k] = o todo = [] for o, own in zip(outs, owners): for c, (i, s) in zip(o.outputs, own): raw = c.text.strip() text = cap(raw, c.finish_reason == "stop") # cut off at max_tokens: drop the partial sentence stats["capped"] = stats.get("capped", 0) + (text != raw) v = violations(text) stats["samples"] += 1 if v: stats["rejected"] += 1 for r in v: stats["reasons"][r] = stats["reasons"].get(r, 0) + 1 if best[i][s] is None or len(v) < best[i][s][0]: best[i][s] = (len(v), text) todo.append((i, s)) else: good[i][s].append(text) rows = [] for i in range(len(imgs)): r = [None if (i, s) not in asked else good[i][s][0] if good[i][s] else best[i][s][1] for s in (0, 1)] rows.append((r[0], r[1], all(good[i][s] for s in (0, 1) if (i, s) in asked))) return rows def fix(args): """Regenerate, in finished shards, only the captions that violate the current rules (one slot at a time). Each shard's jsonl is rewritten atomically and marked ``.fixed``; workers claim shards like ``run``. """ out = Path(args.out) llm, sp = engine(args) pool = ThreadPoolExecutor(args.workers) rank = os.environ.get("CUDA_VISIBLE_DEVICES", "0") for shard in map(Path, args.shards): stem = shard.stem if not (out / f"{stem}.done").exists() or (out / f"{stem}.fixed").exists(): continue try: # own lock name: ``claim`` skips shards that are already .done os.close(os.open(out / f"{stem}.fixlock", os.O_CREAT | os.O_EXCL)) except FileExistsError: continue if (out / f"{stem}.fixed").exists(): # finished by another worker between the check and the claim (out / f"{stem}.fixlock").unlink(missing_ok=True) continue rows = [json.loads(l) for l in open(out / f"{stem}.jsonl")] bad = {r["key"]: [s for s in (0, 1) if violations(r[f"recap_{s + 1}"])] for r in rows} bad = {k: v for k, v in bad.items() if v} st = {"images": len(bad), "slots": sum(map(len, bad.values())), "samples": 0, "rejected": 0, "reasons": {}, "fallback": []} items = [(k, j) for k, j, _ in read_shard(shard) if k in bad] new, t0 = {}, time.time() for c in range(0, len(items), args.chunk): chunk = items[c : c + args.chunk] imgs = list(pool.map(lambda x: load_image(x[1]), chunk)) todo = [(i, s) for i, (k, _) in enumerate(chunk) for s in bad[k]] for (k, _), (r1, r2, ok) in zip(chunk, recaption(llm, sp, imgs, False, args.retries, st, todo)): new[k] = (r1, r2) if not ok: st["fallback"].append(k) tmp = out / f"{stem}.jsonl.tmp" with open(tmp, "w") as f: for r in rows: for s, t in enumerate(new.get(r["key"], (None, None))): if t is not None: r[f"recap_{s + 1}"] = t f.write(json.dumps(r) + "\n") os.replace(tmp, out / f"{stem}.jsonl") sj = out / f"{stem}.stats.json" allst = json.load(open(sj)) allst["fix"] = st json.dump(allst, open(sj, "w")) (out / f"{stem}.fixed").touch() (out / f"{stem}.fixlock").unlink(missing_ok=True) print(f"[gpu{rank}] fixed {stem}: {st['slots']} captions of {st['images']} images in " f"{time.time() - t0:.0f}s, still violating {len(st['fallback'])}", flush=True) def _ngrams(t: str, n: int = 2) -> set: w = re.findall(r"\w+", t.lower()) return {tuple(w[i : i + n]) for i in range(len(w) - n + 1)} def _lcs(a: list, b: list) -> int: prev = [0] * (len(b) + 1) for x in a: cur = [0] for j, y in enumerate(b): cur.append(prev[j] + 1 if x == y else max(prev[j + 1], cur[j])) prev = cur return prev[-1] def similarity(a: str, b: str) -> dict: """Bigram Jaccard and ROUGE-L F1 between two captions.""" ga, gb = _ngrams(a), _ngrams(b) wa, wb = re.findall(r"\w+", a.lower()), re.findall(r"\w+", b.lower()) l = _lcs(wa, wb) return {"jaccard2": len(ga & gb) / max(1, len(ga | gb)), "rougeL": 2 * l / max(1, len(wa) + len(wb))} def stats(args): rows = [json.loads(l) for p in args.files for l in open(p)] agg = {"images": 0, "samples": 0, "rejected": 0, "reasons": {}, "fallback": 0, "gen_s": 0.0, "wall_s": 0.0} for p in args.files: s = json.load(open(Path(p).with_suffix(".stats.json"))) for k in ("images", "samples", "rejected", "gen_s", "wall_s"): agg[k] += s.get(k, 0) agg["fallback"] += len(s["fallback"]) for r, c in s["reasons"].items(): agg["reasons"][r] = agg["reasons"].get(r, 0) + c first = 2 * agg["images"] # first-pass samples print(json.dumps(agg, indent=1)) print(f"img/s (generation only) {agg['images'] / agg['gen_s']:.2f}, (wall) {agg['images'] / agg['wall_s']:.2f}") print(f"rejected / all samples {agg['rejected'] / agg['samples']:.3f}; resample overhead " f"{agg['samples'] / first - 1:.3f}; images with a fallback caption {agg['fallback'] / agg['images']:.4f}") for strict in (False, True): final = [violations(r[k], strict=strict) for r in rows for k in ("recap_1", "recap_2")] print(f"final captions still violating ({'extended' if strict else 'spec'} rules) " f"{sum(map(bool, final)) / len(final):.4f}") wc = sorted(len(r[k].split()) for r in rows for k in ("recap_1", "recap_2")) print(f"words: p5 {wc[len(wc) // 20]} median {wc[len(wc) // 2]} p95 {wc[19 * len(wc) // 20]}") rng = random.Random(0) sub = rng.sample(rows, min(args.sim, len(rows))) pair = [similarity(r["recap_1"], r["recap_2"]) for r in sub] other = [similarity(r["recap_1"], rng.choice(rows)["recap_2"]) for r in sub] # different images: floor orig = [similarity(r["recap_1"], r["orig_caption"]) for r in sub] for name, s in (("recap_1 vs recap_2 (same image)", pair), ("recap_1 vs orig (same image)", orig), ("recap_1 vs recap_2 (random image)", other)): print(f"{name}: " + ", ".join(f"{k} {sum(x[k] for x in s) / len(s):.3f}" for k in s[0])) def export(args): """One parquet per shard (tar order, keys unique), row counts checked against the subset manifest.""" import pyarrow as pa import pyarrow.parquet as pq src, out = Path(args.src), Path(args.out) out.mkdir(parents=True, exist_ok=True) cols = ("key", "source_shard", "orig_caption", "recap_1", "recap_2") total = 0 for sh in json.load(open(args.manifest))["shards"]: stem = Path(sh["file"]).stem assert (src / f"{stem}.done").exists(), f"{stem} not finished" rows, seen = [], set() for line in open(src / f"{stem}.jsonl"): try: r = json.loads(line) except json.JSONDecodeError: # a line cut by a killed worker continue if r["key"] not in seen: seen.add(r["key"]) rows.append(r) assert len(rows) == sh["pairs"], f"{stem}: {len(rows)} rows, manifest {sh['pairs']}" pq.write_table(pa.table({c: [r[c] for r in rows] for c in cols}), out / f"{stem}.parquet", compression="zstd") total += len(rows) print(f"{total} rows -> {out}") if __name__ == "__main__": ap = argparse.ArgumentParser() sub = ap.add_subparsers(dest="cmd", required=True) r = sub.add_parser("run") r.add_argument("--shards", nargs="+", required=True) r.add_argument("--out", required=True) r.add_argument("--model", default=MODEL) r.add_argument("--limit", type=int, default=0, help="images per shard (test runs; no .done marker)") r.add_argument("--chunk", type=int, default=1024) r.add_argument("--no-ban", action="store_true", help="no decode-time bans (filter + resample only)") r.add_argument("--retries", type=int, default=3) r.add_argument("--focus", action="store_true", help="add the FOCUS sentence to the second caption's prompt") r.add_argument("--gpu-mem", type=float, default=0.85) r.add_argument("--workers", type=int, default=16) r.add_argument("--seed", type=int, default=0) x = sub.add_parser("fix", help="regenerate only the captions that violate the current rules") x.add_argument("--shards", nargs="+", required=True) x.add_argument("--out", required=True) x.add_argument("--model", default=MODEL) x.add_argument("--chunk", type=int, default=1024) x.add_argument("--retries", type=int, default=3) x.add_argument("--gpu-mem", type=float, default=0.85) x.add_argument("--workers", type=int, default=16) x.add_argument("--seed", type=int, default=0) x.add_argument("--no-ban", action="store_true") s = sub.add_parser("stats") s.add_argument("files", nargs="+") s.add_argument("--sim", type=int, default=500) e = sub.add_parser("export") e.add_argument("--src", required=True) e.add_argument("--out", required=True) e.add_argument("--manifest", required=True) a = ap.parse_args() {"run": run, "fix": fix, "stats": stats, "export": export}[a.cmd](a)