"""IFEval (Zhou et al. 2023) verifiable-instruction following, re-implemented for the subset of instruction types we can check exactly. `lm-evaluation-harness` is not installed here, so the verifiers below follow the reference implementation's semantics (github.com/google-research/google-research/tree/master/instruction_following_eval). We keep only prompts whose EVERY instruction is in the supported set, and report strict prompt-level accuracy (all instructions satisfied) plus instruction-level accuracy. Chance is ~0: these are generation-time constraints, not multiple choice, so a model that has not acquired instruction-following scores near the floor set by accidental satisfaction. """ from __future__ import annotations import re, json, os from datasets import load_dataset CACHE = os.environ.get("MA_DATA_CACHE", "/root/hf_cache_mergeacc/datasets") _CMP = {"less than": lambda a, b: a < b, "at least": lambda a, b: a >= b, "at most": lambda a, b: a <= b, "exactly": lambda a, b: a == b, None: lambda a, b: a >= b} def _words(t): return re.findall(r"\b\w+\b", t) def _sentences(t): s = re.split(r"(?<=[.!?])\s+", t.strip()) return [x for x in s if x.strip()] def _paras(t): return [p for p in re.split(r"\n\n+", t.strip()) if p.strip()] def _v(iid, kw, r, prompt): k = lambda n: kw.get(n) if iid == "punctuation:no_comma": return "," not in r if iid == "change_case:english_lowercase": return r == r.lower() if iid == "change_case:english_capital": return r == r.upper() if iid == "change_case:capital_word_frequency": n = sum(1 for w in _words(r) if w.isupper() and len(w) > 1) return _CMP[k("capital_relation")](n, k("capital_frequency")) if iid == "keywords:existence": return all(re.search(re.escape(w), r, re.I) for w in (k("keywords") or [])) if iid == "keywords:frequency": n = len(re.findall(re.escape(k("keyword")), r, re.I)) return _CMP[k("relation")](n, k("frequency")) if iid == "keywords:forbidden_words": return not any(re.search(r"\b" + re.escape(w) + r"\b", r, re.I) for w in (k("forbidden_words") or [])) if iid == "keywords:letter_frequency": n = r.lower().count((k("letter") or "").lower()) return _CMP[k("let_relation")](n, k("let_frequency")) if iid == "length_constraints:number_sentences": return _CMP[k("relation")](len(_sentences(r)), k("num_sentences")) if iid == "length_constraints:number_words": return _CMP[k("relation")](len(_words(r)), k("num_words")) if iid == "length_constraints:number_paragraphs": return len(_paras(r)) == k("num_paragraphs") if iid == "length_constraints:nth_paragraph_first_word": ps = _paras(r); n = k("nth_paragraph") if not n or len(ps) < n: return False w = _words(ps[n - 1]) return bool(w) and w[0].lower() == str(k("first_word")).lower() if iid == "detectable_format:number_highlighted_sections": n = len(re.findall(r"\*[^\*\n]+\*", r)) return n >= (k("num_highlights") or 0) if iid == "detectable_format:title": return bool(re.search(r"<<[^\n]+>>", r)) if iid == "detectable_format:number_bullet_lists": return len(re.findall(r"^\s*\*\s+", r, re.M)) == k("num_bullets") if iid == "detectable_format:json_format": t = re.sub(r"^```(json)?|```$", "", r.strip(), flags=re.M).strip() try: json.loads(t); return True except Exception: return False if iid == "detectable_format:multiple_sections": sp = k("section_spliter") or "" return len(re.findall(re.escape(sp) + r"\s*\d+", r)) >= (k("num_sections") or 0) if iid == "detectable_format:constrained_response": return any(o in r for o in ("My answer is yes.", "My answer is no.", "My answer is maybe.")) if iid == "detectable_content:number_placeholders": return len(re.findall(r"\[[^\]\n]*\]", r)) >= (k("num_placeholders") or 0) if iid == "detectable_content:postscript": m = (k("postscript_marker") or "P.S.") return m.lower() in r.lower() if iid == "startend:end_checker": return r.strip().lower().endswith(str(k("end_phrase") or "").strip().lower()) if iid == "startend:quotation": t = r.strip() return len(t) >= 2 and t.startswith('"') and t.endswith('"') if iid == "combination:repeat_prompt": p = (k("prompt_to_repeat") or "").strip() return bool(p) and r.strip().lower().startswith(p.lower()[:min(len(p), 120)]) if iid == "combination:two_responses": return len(re.split(r"\*\*\*+", r)) >= 2 return None # unsupported SUPPORTED = {"punctuation:no_comma", "change_case:english_lowercase", "change_case:english_capital", "change_case:capital_word_frequency", "keywords:existence", "keywords:frequency", "keywords:forbidden_words", "keywords:letter_frequency", "length_constraints:number_sentences", "length_constraints:number_words", "length_constraints:number_paragraphs", "length_constraints:nth_paragraph_first_word", "detectable_format:number_highlighted_sections", "detectable_format:title", "detectable_format:number_bullet_lists", "detectable_format:json_format", "detectable_format:multiple_sections", "detectable_format:constrained_response", "detectable_content:number_placeholders", "detectable_content:postscript", "startend:end_checker", "startend:quotation", "combination:repeat_prompt", "combination:two_responses"} _D = None def docs(n=None, seed=1234): global _D if _D is None: ds = load_dataset("google/IFEval", split="train", cache_dir=CACHE) out = [] for r in ds: ids = list(r["instruction_id_list"]) if not ids or any(i not in SUPPORTED for i in ids): continue kws = [{k: v for k, v in kw.items() if v is not None} for kw in r["kwargs"]] out.append({"prompt": r["prompt"], "ids": ids, "kwargs": kws}) _D = out rows = list(_D) if n and len(rows) > n: import random; random.Random(seed).shuffle(rows); rows = rows[:n] return rows def score(rows, responses): """strict prompt-level and instruction-level accuracy.""" ok_p, ok_i, tot_i = 0, 0, 0 for d, r in zip(rows, responses): good = True for iid, kw in zip(d["ids"], d["kwargs"]): v = _v(iid, kw, r, d["prompt"]) if v is None: continue tot_i += 1; ok_i += int(v); good &= bool(v) ok_p += int(good) return {"ifeval_prompt": ok_p / max(len(rows), 1), "ifeval_inst": ok_i / max(tot_i, 1), "n": len(rows)}