|
| 1 | +""" |
| 2 | +Integration helpers between Eval Protocol evaluations and OpenAI RFT graders. |
| 3 | +
|
| 4 | +Currently provides: |
| 5 | +- build_python_grader_from_evaluation_test: turn an evaluation-style function into |
| 6 | + an OpenAI Python grader spec ({"type": "python", "source": ...}). |
| 7 | +""" |
| 8 | + |
| 9 | +import ast |
| 10 | +import inspect |
| 11 | +import textwrap |
| 12 | + |
| 13 | + |
| 14 | +def build_python_grader_from_evaluation_test(test_fn) -> dict: |
| 15 | + """ |
| 16 | + Return an OpenAI Python grader spec from an Eval Protocol-style evaluation function. |
| 17 | +
|
| 18 | + Assumptions: |
| 19 | + - `test_fn` is the *core* evaluation function (not the @evaluation_test wrapper), |
| 20 | + or an @evaluation_test-decorated function that carries _origin_func. |
| 21 | + It should have a signature like: |
| 22 | +
|
| 23 | + def my_eval(row, **kwargs) -> EvaluateResult | float | EvaluationRow |
| 24 | +
|
| 25 | + - The function only relies on attributes that we provide on `EvaluationRowLike` |
| 26 | + (you can extend that class as needed). |
| 27 | +
|
| 28 | + - We map OpenAI's (sample, item) to a duck‑typed `row`: |
| 29 | + - item["reference_answer"] -> row.ground_truth |
| 30 | + - sample["output_text"] -> appended as an assistant message |
| 31 | + - raw dicts available as row.item / row.sample |
| 32 | +
|
| 33 | + - The function returns either: |
| 34 | + - a numeric score, or |
| 35 | + - an object/dict with a `score` field, or |
| 36 | + - an EvaluationRow/EvaluateResult-like object with `.evaluation_result.score`. |
| 37 | + """ |
| 38 | + |
| 39 | + # If the user passed an @evaluation_test wrapper, try to recover the original function |
| 40 | + origin = getattr(test_fn, "_origin_func", test_fn) |
| 41 | + |
| 42 | + # Get the source of the original function |
| 43 | + src = inspect.getsource(origin) |
| 44 | + src = textwrap.dedent(src) |
| 45 | + |
| 46 | + # Parse into AST so we can safely strip decorators and type annotations |
| 47 | + tree = ast.parse(src) |
| 48 | + |
| 49 | + class _StripAnnotationsAndDecorators(ast.NodeTransformer): |
| 50 | + def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST: |
| 51 | + # Drop all decorators (e.g., @evaluation_test) |
| 52 | + node.decorator_list = [] |
| 53 | + # Remove return type annotation |
| 54 | + node.returns = None |
| 55 | + self.generic_visit(node) |
| 56 | + return node |
| 57 | + |
| 58 | + def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST: |
| 59 | + node.decorator_list = [] |
| 60 | + node.returns = None |
| 61 | + self.generic_visit(node) |
| 62 | + return node |
| 63 | + |
| 64 | + def visit_arg(self, node: ast.arg) -> ast.AST: |
| 65 | + # Remove all parameter annotations (e.g., row: EvaluationRow) |
| 66 | + node.annotation = None |
| 67 | + return node |
| 68 | + |
| 69 | + transformer = _StripAnnotationsAndDecorators() |
| 70 | + tree = transformer.visit(tree) |
| 71 | + ast.fix_missing_locations(tree) |
| 72 | + |
| 73 | + # Find the first function definition and rename it to _ep_eval |
| 74 | + func_node: ast.AST | None = None |
| 75 | + for node in tree.body: |
| 76 | + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): |
| 77 | + func_node = node |
| 78 | + break |
| 79 | + |
| 80 | + if func_node is None: |
| 81 | + raise ValueError("Expected a function definition in test_fn source.") |
| 82 | + |
| 83 | + func_node.name = "_ep_eval" |
| 84 | + |
| 85 | + # Turn the modified AST back into source |
| 86 | + src = ast.unparse(tree) |
| 87 | + |
| 88 | + # Helper code that will live *inside* the grader source |
| 89 | + helper = """ |
| 90 | +from typing import Any, Dict |
| 91 | +from types import SimpleNamespace |
| 92 | +
|
| 93 | +
|
| 94 | +class EvaluationRow(SimpleNamespace): |
| 95 | + \"\"\"Minimal duck-typed stand-in for an evaluation row. |
| 96 | +
|
| 97 | + Extend this with whatever attributes your eval logic uses. |
| 98 | + \"\"\" |
| 99 | + pass |
| 100 | +
|
| 101 | +
|
| 102 | +class EvaluateResult(SimpleNamespace): |
| 103 | + \"\"\"Simple stand-in for Eval Protocol's EvaluateResult. |
| 104 | +
|
| 105 | + This lets evaluation-style functions that construct EvaluateResult(score=...) |
| 106 | + run inside the Python grader sandbox without importing eval_protocol. |
| 107 | + \"\"\" |
| 108 | +
|
| 109 | + def __init__(self, score: float, **kwargs: Any) -> None: |
| 110 | + super().__init__(score=score, **kwargs) |
| 111 | +
|
| 112 | +
|
| 113 | +class Message(SimpleNamespace): |
| 114 | + \"\"\"Duck-typed stand-in for eval_protocol.models.Message (role/content).\"\"\" |
| 115 | + pass |
| 116 | +
|
| 117 | +
|
| 118 | +def _build_row(sample: Dict[str, Any], item: Dict[str, Any]) -> EvaluationRow: |
| 119 | + # Start from any item-provided messages (EP-style), defaulting to []. |
| 120 | + raw_messages = item.get("messages") or [] |
| 121 | + normalized_messages = [] |
| 122 | + for m in raw_messages: |
| 123 | + if isinstance(m, dict): |
| 124 | + normalized_messages.append( |
| 125 | + Message( |
| 126 | + role=m.get("role"), |
| 127 | + content=m.get("content"), |
| 128 | + ) |
| 129 | + ) |
| 130 | + else: |
| 131 | + # Already Message-like; rely on duck typing (must have role/content) |
| 132 | + normalized_messages.append(m) |
| 133 | +
|
| 134 | + reference = item.get("reference_answer") |
| 135 | + prediction = sample.get("output_text") |
| 136 | +
|
| 137 | + # EP-style: ensure the model prediction is present as the last assistant message |
| 138 | + if prediction is not None: |
| 139 | + normalized_messages = list(normalized_messages) # shallow copy |
| 140 | + normalized_messages.append(Message(role="assistant", content=prediction)) |
| 141 | +
|
| 142 | + return EvaluationRow( |
| 143 | + ground_truth=reference, |
| 144 | + messages=normalized_messages, |
| 145 | + item=item, |
| 146 | + sample=sample, |
| 147 | + ) |
| 148 | +
|
| 149 | +
|
| 150 | +def grade(sample: Dict[str, Any], item: Dict[str, Any]) -> float: |
| 151 | + row = _build_row(sample, item) |
| 152 | + result = _ep_eval(row=row) |
| 153 | +
|
| 154 | + # Try to normalize different result shapes into a float score |
| 155 | + try: |
| 156 | + from collections.abc import Mapping |
| 157 | +
|
| 158 | + if isinstance(result, (int, float)): |
| 159 | + return float(result) |
| 160 | +
|
| 161 | + # EvaluateResult-like object with .score |
| 162 | + if hasattr(result, "score"): |
| 163 | + return float(result.score) |
| 164 | +
|
| 165 | + # EvaluationRow-like object with .evaluation_result.score |
| 166 | + eval_res = getattr(result, "evaluation_result", None) |
| 167 | + if eval_res is not None: |
| 168 | + if isinstance(eval_res, Mapping): |
| 169 | + if "score" in eval_res: |
| 170 | + return float(eval_res["score"]) |
| 171 | + elif hasattr(eval_res, "score"): |
| 172 | + return float(eval_res.score) |
| 173 | +
|
| 174 | + # Dict-like with score |
| 175 | + if isinstance(result, Mapping) and "score" in result: |
| 176 | + return float(result["score"]) |
| 177 | + except Exception: |
| 178 | + pass |
| 179 | +
|
| 180 | + return 0.0 |
| 181 | +""" |
| 182 | + |
| 183 | + full_source = src + "\n\n" + textwrap.dedent(helper) |
| 184 | + return {"type": "python", "source": full_source} |
0 commit comments