| |
| """EgoLongQA-style synthetic MCQ annotation, v2. |
| |
| Rebuilt after measuring WHY v1 output was unusable (see reports/annotation-quality-v1.md): |
| * v1 questions restated their own answer -> 9/12 solvable with no video at all |
| * v1 options averaged 22 chars vs 67 real -> distractors collapsed into near-synonyms |
| * v1 had 0% compound and 0% quoted-literal questions vs 32% / 20% in the real benchmark |
| * v1 ran on randomly-drawn Ego4D (57% household manipulation) vs a benchmark that is |
| 59% travel / sightseeing / shopping |
| |
| The three structural fixes here: |
| 1. DESCRIBE FROM THE STUDENT'S OWN FRAMES. The description is built from exactly the frames |
| the student will see, and is pushed hard to transcribe visible TEXT verbatim. A question |
| grounded in detail the student cannot see trains hallucination. |
| 2. SPEC-DRIVEN GENERATION. The measured shape of real questions is stated numerically |
| (compound rate, option length, quoted-literal rate), not left to taste. |
| 3. ADVERSARIAL REJECTION IN THE LOOP. Every question is attacked by a text-only model with a |
| REAL token budget. Anything it solves is thrown out and regenerated -- not merely counted. |
| |
| Usage: |
| python scripts/annotate_v2.py --frames good_frames --out annot_v2.jsonl --n-questions 4 |
| """ |
| import argparse, asyncio, collections, json, os, re, sys, time |
| from pathlib import Path |
|
|
| import aiohttp |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) |
|
|
| |
| |
| |
| os.environ["AWS_DEFAULT_REGION"] = "auto" |
|
|
| OPENROUTER = "https://openrouter.ai/api/v1" |
|
|
| |
|
|
| DESC_SYS = """You are analysing frames sampled uniformly across an ENTIRE egocentric (first-person) |
| video, in temporal order. These are the ONLY frames anyone downstream will ever see. |
| |
| Write a DETAILED, TIMESTAMPED description grouped by time ranges (e.g. "0-45s: ...", "45-120s: ..."). |
| |
| Priorities, in order: |
| 1. TRANSCRIBE VISIBLE TEXT VERBATIM, in quotes. Street signs, shop names, product labels, prices, |
| book titles, screens, posters, notices, number plates, menus, packaging. This is the single most |
| valuable thing you can record. Write "the sign read 'PARKING FOR LIBRARY USE ONLY'", not |
| "a sign". If text is partially legible, transcribe what you can and mark the rest [unclear]. |
| If you cannot read it at all, say so -- NEVER invent text. |
| 2. Name concrete objects with distinguishing attributes: colour, brand, size, material, condition. |
| 3. Record PLACES and TRANSITIONS: entering/leaving shops, streets, rooms, vehicles. |
| 4. Record the ORDER of events explicitly, and anything the camera-wearer picked up, put down, |
| paid for, read, or interacted with. |
| |
| Do not speculate about what is off-frame. Output ONLY: |
| <video_description> |
| {description} |
| </video_description>""" |
|
|
| |
|
|
| QGEN_SYS = """You write multiple-choice questions about long egocentric (first-person) videos, matching |
| the EgoLongQA benchmark. Real examples: |
| |
| - "What did the historical marker I read at the entrance say about the 'wooden' railings I later saw |
| on the stone bridge?" |
| - "I first interacted with a product that had a 'Scratch for Scent' sticker and later with a product |
| that had a '$2.50 back' sticker. What were these products?" |
| - "What was the name on the first sign I saw after stepping onto the sidewalk, and what speed limit |
| was indicated on the last sign I saw before stepping off the sidewalk?" |
| |
| MEASURED SHAPE OF REAL QUESTIONS -- match these rates: |
| - 89% use a temporal anchor (After I .../Earlier I .../before .../the first .../the last ...) |
| - 32% are COMPOUND: they ask for TWO linked facts in one question ("what X, and what Y?") |
| - 20% quote LITERAL TEXT read from the world ('Scratch for Scent', '$2.50 back') |
| - question length ~146 characters |
| - OPTION LENGTH ~67 CHARACTERS -- full descriptive phrases, never one or two words |
| |
| HARD REQUIREMENTS |
| 1. First person ("I", "my"). |
| 2. TWO-HOP: the anchor moment and the asked-about moment must be in DIFFERENT, well-separated time |
| ranges. Answering must require connecting them. |
| 3. THE QUESTION MUST NOT CONTAIN, PARAPHRASE, OR HINT AT THE CORRECT OPTION'S CONTENT. |
| Fatal failure: "Later I carried a piece of wood to the oven. What was I carrying?" -> "The wood". |
| The anchor clause may reference a DIFFERENT moment than the one being asked about; it may never |
| name the answer. |
| 4. Exactly 4 options, each a full descriptive phrase of ~67 characters. All four must be the SAME |
| KIND of thing and similar length. Distractors must be OTHER REAL details from the SAME video -- |
| never invented, never near-synonyms of the answer ("the wood"/"the plank" is a fatal pair). |
| 5. Use ONLY facts explicitly present in the material. Never invent. |
| 6. Make roughly one in three questions compound (two linked facts). |
| 7. Where the material contains quoted literal text, prefer building questions on it. |
| 8. Vary which letter is correct. |
| |
| 9. NEVER reuse the same component across options. In a COMPOUND question each slot must take at |
| least THREE distinct values across the four options. This is fatal and common: |
| A. sign read FORTY and second sign read EIGHT |
| B. sign read EIGHT and second sign read FORTY |
| C. sign read FORTY and second sign read FORTY |
| D. sign read EIGHT and second sign read EIGHT |
| -- only two values exist, so it is a coin flip, not a 4-way choice. Equally fatal is a pair |
| differing by a synonym ("a minivan was waiting" vs "a van was waiting"). Every option must be |
| distinguishable by someone who watched, and no two may describe the same thing. |
| |
| COMMON WAYS QUESTIONS LEAK THEIR ANSWER -- check for all of these before emitting: |
| - the answer's distinctive noun appears in the question itself |
| - only one option is the right TYPE of thing (the others are a different category) |
| - one option is conspicuously longer, more specific, or more plausible than the rest |
| - three options are obviously absurd, leaving the answer by elimination |
| - two options are near-synonyms, so neither can be correct and the field narrows to two |
| |
| BEFORE YOU EMIT, apply this test to every question: could someone who never saw the video pick the |
| right option using ONLY the question and the four options? If yes, the question is worthless -- |
| rewrite it so the answer is recoverable only from having watched. |
| |
| Return ONLY JSON: |
| {"questions":[{"question":"...","options":["A. ...","B. ...","C. ...","D. ..."], |
| "answer":"A","evidence":"supporting text from the material","timestamps":"e.g. 120-150s and 400-430s"}]}""" |
|
|
| REGEN_SYS = QGEN_SYS + """ |
| |
| You are being called again because the questions below were SOLVED BY A TEXT-ONLY MODEL that never |
| saw the video. They leak their answers. Diagnose the leak in each and write REPLACEMENTS that do not. |
| Common leaks: the answer's noun appears in the question; only one option is the right TYPE of thing; |
| one option is conspicuously more detailed or more plausible than the rest.""" |
|
|
| ANSWER_SYS = "Answer the multiple-choice question. Reply with ONLY the single letter A, B, C or D." |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| DESC_SYS_ACTIVITY = """You are analysing frames sampled uniformly across an ENTIRE egocentric |
| (first-person) video, in temporal order. These are the ONLY frames anyone downstream will ever see. |
| |
| Write a DETAILED, TIMESTAMPED description grouped by time ranges (e.g. "0-45s: ...", "45-120s: ..."). |
| |
| This is a hands-on activity video. Priorities, in order: |
| 1. THE ORDER OF OPERATIONS. What was done, in what sequence, and what had to happen first. Be |
| explicit about before/after: "the onions were already chopped when the pan was heated". |
| 2. OBJECT STATE CHANGES. Track individual objects across the video: raw -> chopped -> cooked, |
| empty -> filled, dirty -> clean, unassembled -> assembled, closed -> open. Say WHEN each |
| change happened and what caused it. |
| 3. TOOLS, INGREDIENTS AND CONTAINERS, named with distinguishing attributes (colour, size, material), |
| and where each came from and went: fridge, drawer, shelf, sink, bin. |
| 4. CAUSE AND PURPOSE. Why an action was taken, when the frames make it evident (fetched a cloth |
| because something spilled; re-opened the fridge because an ingredient was missed). |
| 5. Any visible text (labels, packaging, screens) transcribed verbatim in quotes -- useful when |
| present, but do NOT force it; this footage often has none. |
| |
| Do not speculate about what is off-frame. Output ONLY: |
| <video_description> |
| {description} |
| </video_description>""" |
|
|
| QGEN_SYS_ACTIVITY = """You write multiple-choice questions about long egocentric (first-person) |
| videos, matching the "Daily Activities" category of the EgoLongQA benchmark. Real examples: |
| |
| - "Which ingredient that I retrieved from the refrigerator did I chop and add to the pan with ground |
| meat before using the last of the tomatoes?" |
| - "Why did I open the refrigerator near the end of the video, and what earlier activity prompted this?" |
| - "Which did I paint first, the house's exterior siding or the adjacent wooden fence, and what visual |
| evidence indicates the order?" |
| |
| This footage is INDOOR HANDS-ON ACTIVITY. It usually has no signs or prices, so do NOT build |
| questions on text. Build them on ORDER, CAUSE and OBJECT STATE. |
| |
| GOOD QUESTION TYPES for this material: |
| - ORDERING: which of two things was done first, and what shows it |
| - CAUSAL: why an action was taken, linked to an earlier event that prompted it |
| - OBJECT TRACKING: an object is used early and again much later -- what happened to it in between, |
| or what state it was in the second time |
| - OMISSION / COMPLETION: what remained undone, or what was fetched only after being forgotten |
| |
| MEASURED SHAPE -- match these rates: |
| - 89% use a temporal anchor (After I .../Earlier I .../before .../the first .../the last ...) |
| - 32% are COMPOUND: two linked facts in one question ("what X, and what Y?") |
| - question length ~146 characters |
| - OPTION LENGTH ~67 CHARACTERS -- full descriptive phrases, never one or two words |
| |
| HARD REQUIREMENTS |
| 1. First person ("I", "my"). |
| 2. TWO-HOP: the anchor moment and the asked-about moment must be in DIFFERENT, well-separated time |
| ranges. Answering must require connecting them. |
| 3. THE QUESTION MUST NOT CONTAIN, PARAPHRASE, OR HINT AT THE CORRECT OPTION'S CONTENT. |
| Fatal failure: "Later I carried a piece of wood to the oven. What was I carrying?" -> "The wood". |
| 4. Exactly 4 options, each a full descriptive phrase of ~67 characters, all the SAME KIND of thing |
| and similar length. Distractors must be OTHER REAL details from the SAME video -- never invented, |
| never near-synonyms of the answer ("the wood"/"the plank" is a fatal pair). |
| 5. Use ONLY facts explicitly present in the material. Never invent. |
| 6. Make roughly one in three questions compound. |
| 7. Vary which letter is correct. |
| |
| 9. NEVER reuse the same component across options. In a COMPOUND question each slot must take at |
| least THREE distinct values across the four options. This is fatal and common: |
| A. sign read FORTY and second sign read EIGHT |
| B. sign read EIGHT and second sign read FORTY |
| C. sign read FORTY and second sign read FORTY |
| D. sign read EIGHT and second sign read EIGHT |
| -- only two values exist, so it is a coin flip, not a 4-way choice. Equally fatal is a pair |
| differing by a synonym ("a minivan was waiting" vs "a van was waiting"). Every option must be |
| distinguishable by someone who watched, and no two may describe the same thing. |
| |
| COMMON WAYS QUESTIONS LEAK THEIR ANSWER -- check for all of these before emitting: |
| - the answer's distinctive noun appears in the question itself |
| - only one option is the right TYPE of thing |
| - one option is conspicuously longer, more specific, or more plausible than the rest |
| - three options are obviously absurd, leaving the answer by elimination |
| - two options are near-synonyms, narrowing the field to two |
| |
| BEFORE YOU EMIT, apply this test to every question: could someone who never saw the video pick the |
| right option using ONLY the question and the four options? If yes, rewrite it. |
| |
| Return ONLY JSON: |
| {"questions":[{"question":"...","options":["A. ...","B. ...","C. ...","D. ..."], |
| "answer":"A","evidence":"supporting text from the material","timestamps":"e.g. 120-150s and 400-430s"}]}""" |
|
|
| REGEN_TAIL = """ |
| |
| You are being called again because the questions below were SOLVED BY A TEXT-ONLY MODEL that never |
| saw the video. They leak their answers. Diagnose the leak in each and write REPLACEMENTS that do not.""" |
|
|
| DURATION_NOTE = """DURATION (critical): the frames you are given span the ENTIRE video, which is {duration_sec:.0f} |
| SECONDS long -- roughly one frame every {frame_gap:.1f} seconds. Your time ranges MUST cover the full |
| 0 to {duration_sec:.0f}s span. Do NOT compress the video into the first minute: a measured median of |
| 0.28x showed exactly that failure, which makes every citation point at the wrong moment.""" |
|
|
| DURATIONS = {} |
|
|
| STYLES = { |
| "signage": (DESC_SYS, QGEN_SYS), |
| "activity": (DESC_SYS_ACTIVITY, QGEN_SYS_ACTIVITY), |
| } |
|
|
|
|
| async def call(session, model, messages, key, max_tokens, temperature=0.7, resp_format=None, |
| retries=3): |
| body = {"model": model, "messages": messages, "max_tokens": max_tokens, |
| "temperature": temperature} |
| if resp_format: |
| body["response_format"] = resp_format |
| for attempt in range(retries): |
| try: |
| async with session.post(f"{OPENROUTER}/chat/completions", |
| headers={"Authorization": f"Bearer {key}", |
| "Content-Type": "application/json"}, |
| json=body) as r: |
| if r.status in (429, 500, 502, 503): |
| await asyncio.sleep(4 * (attempt + 1)) |
| continue |
| r.raise_for_status() |
| d = await r.json() |
| |
| |
| |
| ch = d.get("choices") or [] |
| if not ch: |
| if attempt == retries - 1: |
| return "", d.get("usage", {}) |
| await asyncio.sleep(4 * (attempt + 1)) |
| continue |
| return ((ch[0].get("message") or {}).get("content") or ""), d.get("usage", {}) |
| except (aiohttp.ClientError, asyncio.TimeoutError): |
| if attempt == retries - 1: |
| raise |
| await asyncio.sleep(4 * (attempt + 1)) |
| return "", {} |
|
|
|
|
| def parse_questions(txt): |
| """Reasoning models often wrap the JSON in prose or a ```json fence despite response_format, |
| and sometimes run out of budget mid-object. Recover what we can instead of dropping the round.""" |
| if not txt: |
| return [] |
| qs = None |
| for cand in (txt, |
| (re.search(r"```(?:json)?\s*(.*?)```", txt, re.S) or [None, None])[1], |
| (re.search(r"\{.*\}", txt, re.S) or [None])[0]): |
| if not cand: |
| continue |
| try: |
| obj = json.loads(cand) |
| if isinstance(obj, dict): |
| qs = obj.get("questions") |
| elif isinstance(obj, list): |
| qs = obj |
| if qs: |
| break |
| except Exception: |
| continue |
| if not qs: |
| |
| qs = [] |
| for m in re.finditer(r'\{[^{}]*"question"\s*:.*?\}(?=\s*[,\]])', txt, re.S): |
| try: |
| qs.append(json.loads(m.group(0))) |
| except Exception: |
| pass |
| if not qs: |
| return [] |
| out = [] |
| for q in qs: |
| if not isinstance(q, dict) or not q.get("question"): |
| continue |
| opts = q.get("options") or [] |
| if len(opts) != 4 or str(q.get("answer", "")).upper()[:1] not in "ABCD": |
| continue |
| out.append(q) |
| return out |
|
|
|
|
| BATCH_SYS = ("Answer each numbered multiple-choice question independently. " |
| 'Reply with ONLY JSON mapping question number to letter, e.g. {"1":"A","2":"C"}. ' |
| "Answer every question; if unsure, still give your best single letter.") |
|
|
|
|
| def _numbered(questions): |
| return "\n\n".join(f"{i+1}. {q['question']}\n" + "\n".join(q["options"]) |
| for i, q in enumerate(questions)) |
|
|
|
|
| def _parse_letters(txt, n): |
| """Return list of picks (or None) for n questions from a JSON map, tolerating fences/prose.""" |
| picks = [None] * n |
| if not txt: |
| return picks |
| obj = None |
| for cand in (txt, |
| (re.search(r"```(?:json)?\s*(.*?)```", txt, re.S) or [None, None])[1], |
| (re.search(r"\{.*\}", txt, re.S) or [None])[0]): |
| if not cand: |
| continue |
| try: |
| obj = json.loads(cand) |
| break |
| except Exception: |
| continue |
| if isinstance(obj, dict): |
| for k, v in obj.items(): |
| m_i = re.search(r"\d+", str(k)); m_v = re.search(r"[A-D]", str(v).upper()) |
| if m_i and m_v: |
| i = int(m_i.group(0)) - 1 |
| if 0 <= i < n: |
| picks[i] = m_v.group(0) |
| if all(p is None for p in picks): |
| found = re.findall(r"\b([A-D])\b", (txt or "").upper()) |
| for i, f in enumerate(found[:n]): |
| picks[i] = f |
| return picks |
|
|
|
|
| _WORD = re.compile(r"[a-z0-9']{4,}") |
| _STOP = set("""that this with from into over under after before then than which what were was |
| been being have has had will would could should there here they them their your mine ours |
| first second third fourth i my me the and or of to in on at for a an it its is are be""".split()) |
|
|
|
|
| def _content(s): |
| return {w for w in _WORD.findall(re.sub(r"^\s*[A-D][\.\)]\s*", "", s or "").lower()) |
| if w not in _STOP} |
|
|
|
|
| def structural_issues(q, desc): |
| """Shape defects a blind-attack filter does not reliably catch. |
| |
| Measured on the first 362 questions: 12% had two near-duplicate options and 5% had a gold |
| option whose content never appeared in the description. Compound questions are the main |
| offender -- built as a factorial grid over only TWO values per slot, they collapse into a |
| 2-way guess ("'Luyben Av' + minivan" vs "'Luyben Av' + van").""" |
| issues = [] |
| opts = q.get("options") or [] |
| gold = str(q.get("answer", "")).upper()[:1] |
| if len(opts) != 4 or gold not in "ABCD": |
| return ["malformed"] |
| bodies = [re.sub(r"^\s*[A-D][\.\)]\s*", "", o).strip() for o in opts] |
| sets = [_content(b) for b in bodies] |
|
|
| for i in range(4): |
| for j in range(i + 1, 4): |
| if sets[i] and sets[j]: |
| jac = len(sets[i] & sets[j]) / len(sets[i] | sets[j]) |
| if jac > 0.8: |
| issues.append("dup_options") |
| break |
| if issues: |
| break |
|
|
| |
| if len(bodies) == 4: |
| counts = collections.Counter() |
| for b in bodies: |
| for part in re.split(r"\s+and\s+|,\s+", b): |
| p = " ".join(sorted(_content(part))) |
| if p: |
| counts[p] += 1 |
| if counts and max(counts.values()) >= 3: |
| issues.append("repeated_component") |
|
|
| gi = "ABCD".index(gold) |
| others = [len(b) for k, b in enumerate(bodies) if k != gi] |
| if abs(len(bodies[gi]) - (sum(others) / 3)) > 30: |
| issues.append("gold_len_outlier") |
|
|
| dw = _content(desc) |
| gw = sets[gi] |
| if gw and len(gw - dw) / len(gw) > 0.7: |
| issues.append("gold_unsupported_by_desc") |
| return issues |
|
|
|
|
| async def blind_attack_batch(session, questions, key, model, max_tokens): |
| """Can a text-only model solve these with no video? ONE call for all of them. |
| |
| Needs a REAL token budget: these are reasoning models, and a small budget returns empty |
| content that silently scores as 'not solved' -- the bug that made v1's filter useless. |
| Batching means the model sees the whole set at once, which if anything makes it a STRONGER |
| adversary (cross-question cues are available to it), so the filter does not get weaker.""" |
| txt, _ = await call(session, model, |
| [{"role": "system", "content": BATCH_SYS}, |
| {"role": "user", "content": _numbered(questions)}], |
| key, max_tokens, 0.0, resp_format={"type": "json_object"}) |
| picks = _parse_letters(txt, len(questions)) |
| return [p is not None and p == str(q["answer"]).upper()[:1] |
| for p, q in zip(picks, questions)] |
|
|
|
|
| async def frame_verify_batch(session, questions, urls, key, model, max_tokens=8000): |
| """Are these answerable from the STUDENT's own frames? ONE call carrying the frames once. |
| |
| Sending the 100-frame payload per question was ~60% of the pipeline's vision cost for no |
| benefit. Caveat: the model now sees all questions together, so verification is marginally |
| less independent per question -- acceptable for a gate whose job is to catch questions |
| grounded in detail the student cannot see at all.""" |
| content = [{"type": "image_url", "image_url": {"url": u}} for u in urls] |
| content.append({"type": "text", "text": _numbered(questions)}) |
| txt, _ = await call(session, model, |
| [{"role": "system", "content": BATCH_SYS}, |
| {"role": "user", "content": content}], |
| key, max_tokens, 0.0, resp_format={"type": "json_object"}) |
| picks = _parse_letters(txt, len(questions)) |
| return [p is not None and p == str(q["answer"]).upper()[:1] |
| for p, q in zip(picks, questions)] |
|
|
|
|
| async def annotate_one(session, vid, a, key, sem, out_f, lock, stats): |
| from ambient.utils.s3 import get_s3_client |
| async with sem: |
| man = Path(a.frames) / vid / "frames.json" |
| if not man.exists(): |
| stats["no_frames"] += 1 |
| return |
| paths = json.load(open(man)) |
| |
| step = max(1, len(paths) // a.num_frames) |
| student_paths = paths[::step][:a.num_frames] |
| s3 = get_s3_client(); ts = int(time.time() * 1000) |
|
|
| def up(i_p): |
| i, p = i_p |
| k = f"videos/_annot2/{vid}_{ts}_{i:03d}.jpg" |
| s3.upload_file(p, k, extra_args={"ContentType": "image/jpeg"}) |
| return s3.get_presigned_url(k, expires_in=10800), k |
| res = await asyncio.gather(*[asyncio.to_thread(up, x) for x in enumerate(student_paths)]) |
| urls = [u for u, _ in res]; keys = [k for _, k in res] |
|
|
| try: |
| |
| content = [{"type": "image_url", "image_url": {"url": u}} for u in urls] |
| content.append({"type": "text", "text": "Write the timestamped description now."}) |
| desc_sys, qgen_sys_base = STYLES[a.style] |
| vdur = DURATIONS.get(vid) |
| if vdur: |
| desc_sys = desc_sys + DURATION_NOTE.format( |
| duration_sec=vdur, frame_gap=vdur / max(1, len(urls))) |
| desc, _ = await call(session, a.desc_model, |
| [{"role": "system", "content": desc_sys}, |
| {"role": "user", "content": content}], |
| key, a.desc_max_tokens, 0.4) |
| m = re.search(r"<video_description>\s*(.*?)\s*</video_description>", desc, re.S | re.I) |
| desc = (m.group(1) if m else desc).strip() |
| if len(desc) < 300: |
| stats["bad_desc"] += 1 |
| return |
|
|
| |
| kept, rejected = [], [] |
| material = f"Video description (from the {len(urls)} frames the student sees):\n{desc}" |
| sys_p, ask = qgen_sys_base, a.n_questions |
| for rnd in range(a.max_rounds): |
| if ask <= 0: |
| break |
| user = f"{material}\n\nWrite {ask} questions as JSON." |
| if rnd and rejected: |
| leaked = "\n\n".join( |
| q["question"] + "\n" + "\n".join(q["options"]) for q in rejected[-ask:]) |
| user = f"{material}\n\nThese leaked their answers:\n{leaked}\n\n" \ |
| f"Write {ask} REPLACEMENT questions as JSON." |
| sys_p = qgen_sys_base + REGEN_TAIL |
| txt, _ = await call(session, a.qgen_model, |
| [{"role": "system", "content": sys_p}, |
| {"role": "user", "content": user}], |
| key, a.qgen_max_tokens, 0.85, |
| resp_format={"type": "json_object"}) |
| qs = parse_questions(txt) |
| if not qs: |
| stats["qparse_fail"] += 1 |
| continue |
| |
| clean = [] |
| for q in qs: |
| iss = structural_issues(q, desc) |
| if iss: |
| rejected.append(q) |
| for i in iss: |
| stats["struct_" + i] = stats.get("struct_" + i, 0) + 1 |
| else: |
| clean.append(q) |
| if not clean: |
| ask = a.n_questions - len(kept) |
| continue |
| qs = clean |
| solved = await blind_attack_batch(session, qs, key, a.blind_model, |
| a.blind_max_tokens) |
| for q, bad in zip(qs, solved): |
| (rejected if bad else kept).append(q) |
| stats["blind_rejected"] += sum(1 for x in solved if x) |
| ask = a.n_questions - len(kept) |
|
|
| if not kept: |
| stats["all_leaked"] += 1 |
| return |
|
|
| |
| vis = await frame_verify_batch(session, kept, urls, key, a.verify_model) |
| final = [q for q, ok in zip(kept, vis) if ok] |
| stats["not_visible"] += sum(1 for ok in vis if not ok) |
| if not final: |
| stats["none_visible"] += 1 |
| return |
|
|
| rec = {"video_id": vid, "description": desc, "questions": final, |
| "n_frames_described": len(urls), |
| "rejected_blind": len(rejected), |
| "models": {"desc": a.desc_model, "qgen": a.qgen_model, |
| "blind": a.blind_model, "verify": a.verify_model}} |
| async with lock: |
| out_f.write(json.dumps(rec) + "\n"); out_f.flush() |
| stats["videos"] += 1; stats["questions"] += len(final) |
| except Exception as e: |
| stats["err"] += 1 |
| stats["last_err"] = f"{type(e).__name__}: {str(e)[:120]}" |
| finally: |
| for k in keys: |
| try: |
| s3.s3.delete_object(Bucket=s3.bucket, Key=k) |
| except Exception: |
| pass |
| stats["done"] += 1 |
| print(f" [{stats['done']}] {vid[:12]} kept={stats['questions']} " |
| f"blind_rej={stats['blind_rejected']} not_vis={stats['not_visible']} " |
| f"err={stats['err']}", flush=True) |
|
|
|
|
| async def main_async(a): |
| key = os.getenv("LLM_API_KEY") |
| if not key: |
| for line in open(Path(__file__).resolve().parents[1] / ".env"): |
| if line.startswith("LLM_API_KEY"): |
| key = line.split("=", 1)[1].strip() |
| if a.durations: |
| DURATIONS.update({k: float(v) for k, v in json.load(open(a.durations)).items()}) |
| print(f"durations loaded for {len(DURATIONS)} videos") |
| vids = a.videos or sorted(p.name for p in Path(a.frames).iterdir() if p.is_dir()) |
| if a.limit: |
| vids = vids[:a.limit] |
| done = set() |
| if Path(a.out).exists(): |
| done = {json.loads(l)["video_id"] for l in open(a.out) if l.strip()} |
| vids = [v for v in vids if v not in done] |
| print(f"annotating {len(vids)} videos | desc={a.desc_model} qgen={a.qgen_model}") |
| stats = dict(done=0, videos=0, questions=0, err=0, no_frames=0, bad_desc=0, qparse_fail=0, |
| blind_rejected=0, not_visible=0, all_leaked=0, none_visible=0) |
| sem = asyncio.Semaphore(a.concurrency); lock = asyncio.Lock() |
| with open(a.out, "a") as f: |
| async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=a.timeout)) as s: |
| await asyncio.gather(*[annotate_one(s, v, a, key, sem, f, lock, stats) for v in vids]) |
| print(f"DONE {stats}") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--frames", required=True) |
| ap.add_argument("--videos", nargs="*", default=None) |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--desc-model", default="qwen/qwen3.5-122b-a10b") |
| ap.add_argument("--qgen-model", default="deepseek/deepseek-v4-flash-0731") |
| ap.add_argument("--blind-model", default="deepseek/deepseek-v4-flash-0731") |
| ap.add_argument("--verify-model", default="qwen/qwen3.5-27b", |
| help="MUST differ from --desc-model: the describer will happily confirm\n a question built on its own misreading. qwen3.6-27b was the\n first pick but REASONS: it burned 3000 completion tokens,\n hit finish=length, returned nothing, and every question was\n silently scored not-visible. qwen3.5-27b answers in ~14\n tokens and is 4x cheaper per call.") |
| ap.add_argument("--durations", default=None, |
| help="JSON map video_id -> seconds. Without it the VLM guesses the " |
| "timeline and compresses it ~4x, making every citation wrong.") |
| ap.add_argument("--style", choices=list(STYLES), default="signage", |
| help="signage = travel/shopping footage (text-rich); " |
| "activity = indoor hands-on footage (order/cause/state). " |
| "EgoLongQA needs BOTH: ~31%% of it is low-signage Daily Activities.") |
| ap.add_argument("--n-questions", type=int, default=4) |
| ap.add_argument("--num-frames", type=int, default=100) |
| ap.add_argument("--max-rounds", type=int, default=3, |
| help="generate -> blind-attack -> regenerate cycles") |
| ap.add_argument("--desc-max-tokens", type=int, default=6000) |
| ap.add_argument("--qgen-max-tokens", type=int, default=24000, |
| help="reasoning model: too small a budget returns EMPTY content") |
| ap.add_argument("--blind-max-tokens", type=int, default=10000, |
| help="MUST be large: at 8 tokens a reasoning model returns None and every " |
| "question silently passes the leak filter (the v1 bug)") |
| ap.add_argument("--concurrency", type=int, default=12) |
| ap.add_argument("--timeout", type=int, default=3600) |
| ap.add_argument("--limit", type=int, default=0) |
| asyncio.run(main_async(ap.parse_args())) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
