code/ifeval.py

"""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)}