Spaces:
Sleeping
Sleeping
Download reward.py from LostDecimal/alien-physics-openenv: direct link, hf CLI and curl.
- Browser
- Download file 17.5 kB
-
https://huggingface.co/spaces/LostDecimal/alien-physics-openenv/resolve/main/reward.py
- Command line
-
hf download hf://spaces/LostDecimal/alien-physics-openenv/reward.py
-
curl -L -o reward.py https://huggingface.co/spaces/LostDecimal/alien-physics-openenv/resolve/main/reward.py
17.5 kB
| """Environment-owned scoring for submitted theories.""" | |
| from __future__ import annotations | |
| import ast | |
| from collections import Counter | |
| from dataclasses import dataclass | |
| import math | |
| from typing import Any | |
| try: | |
| from .config import RewardConfig | |
| from .sandbox import SandboxResult | |
| from .theory_dsl import TheoryDSLValidationError, dsl_complexity, dsl_signature, parse_theory_dsl | |
| from .universe import SensorRecord, window_has_anomaly, window_has_drift | |
| except ImportError: # pragma: no cover | |
| from config import RewardConfig | |
| from sandbox import SandboxResult | |
| from theory_dsl import TheoryDSLValidationError, dsl_complexity, dsl_signature, parse_theory_dsl | |
| from universe import SensorRecord, window_has_anomaly, window_has_drift | |
| class RewardBreakdown: | |
| reward: float | |
| log_likelihood: float | |
| mdl_penalty: float | |
| anomaly_bonus: float | |
| drift_bonus: float | |
| stability_bonus: float | |
| execution_ok: bool | |
| missed_anomaly: bool | |
| false_paradigm_shift: bool | |
| weak_paradigm_shift: bool | |
| details: dict[str, Any] | |
| class ComplexityBreakdown: | |
| mode: str | |
| score: float | |
| ast_nodes: int | |
| import_count: int | |
| class_count: int | |
| function_count: int | |
| parameter_count: int | |
| branch_count: int | |
| self_state_assignments: int | |
| parse_ok: bool | |
| fallback_chars: int = 0 | |
| def to_dict(self) -> dict[str, float | int | bool | str]: | |
| return { | |
| "mdl_complexity_mode": self.mode, | |
| "mdl_complexity": self.score, | |
| "ast_nodes": self.ast_nodes, | |
| "import_count": self.import_count, | |
| "class_count": self.class_count, | |
| "function_count": self.function_count, | |
| "parameter_count": self.parameter_count, | |
| "branch_count": self.branch_count, | |
| "self_state_assignments": self.self_state_assignments, | |
| "complexity_parse_ok": self.parse_ok, | |
| "fallback_chars": self.fallback_chars, | |
| } | |
| def score_theory( | |
| result: SandboxResult, | |
| future: list[SensorRecord], | |
| theory_module: str, | |
| config: RewardConfig, | |
| paradigm_shift_claim: bool = False, | |
| previous_theory_module: str | None = None, | |
| ) -> RewardBreakdown: | |
| complexity = theory_complexity(theory_module, config.mdl_complexity_mode) | |
| mdl_penalty = config.mdl_lambda * complexity.score | |
| if len(theory_module) > config.max_theory_chars: | |
| return RewardBreakdown( | |
| reward=config.execution_error_penalty, | |
| log_likelihood=float("-inf"), | |
| mdl_penalty=mdl_penalty, | |
| anomaly_bonus=0.0, | |
| drift_bonus=0.0, | |
| stability_bonus=0.0, | |
| execution_ok=False, | |
| missed_anomaly=window_has_anomaly(future), | |
| false_paradigm_shift=False, | |
| weak_paradigm_shift=False, | |
| details={ | |
| "error": "theory module exceeded max_theory_chars", | |
| "theory_chars": len(theory_module), | |
| **complexity.to_dict(), | |
| }, | |
| ) | |
| if not result.ok: | |
| return RewardBreakdown( | |
| reward=config.execution_error_penalty, | |
| log_likelihood=float("-inf"), | |
| mdl_penalty=mdl_penalty, | |
| anomaly_bonus=0.0, | |
| drift_bonus=0.0, | |
| stability_bonus=0.0, | |
| execution_ok=False, | |
| missed_anomaly=window_has_anomaly(future), | |
| false_paradigm_shift=False, | |
| weak_paradigm_shift=False, | |
| details={ | |
| "error": result.error, | |
| "theory_chars": len(theory_module), | |
| **complexity.to_dict(), | |
| }, | |
| ) | |
| log_likelihood = gaussian_log_likelihood(result.predictions, future, config.prediction_sigma) | |
| anomaly_bonus, missed_anomaly = anomaly_score(result.predictions, future, config.anomaly_bonus) | |
| structural_delta = theory_structural_distance(theory_module, previous_theory_module) | |
| drift_bonus, false_paradigm_shift, weak_paradigm_shift = drift_score( | |
| result, | |
| future, | |
| paradigm_shift_claim, | |
| config.drift_bonus, | |
| config.false_paradigm_shift_penalty, | |
| structural_delta, | |
| config.paradigm_shift_min_structural_delta, | |
| ) | |
| # Stability bonus: reward incremental refinement, penalize wild swings | |
| # unless a paradigm shift is genuinely needed (drift in future window) | |
| stability_bonus = 0.0 | |
| if previous_theory_module is not None: | |
| if structural_delta < config.stability_threshold: | |
| stability_bonus = config.stability_weight # small but stable | |
| elif not window_has_drift(future): | |
| # Large change without drift = unnecessary volatility | |
| stability_bonus = -config.stability_weight * structural_delta | |
| reward = log_likelihood - mdl_penalty + anomaly_bonus + drift_bonus + stability_bonus | |
| return RewardBreakdown( | |
| reward=float(reward), | |
| log_likelihood=float(log_likelihood), | |
| mdl_penalty=float(mdl_penalty), | |
| anomaly_bonus=float(anomaly_bonus), | |
| drift_bonus=float(drift_bonus), | |
| stability_bonus=float(stability_bonus), | |
| execution_ok=True, | |
| missed_anomaly=missed_anomaly, | |
| false_paradigm_shift=false_paradigm_shift, | |
| weak_paradigm_shift=weak_paradigm_shift, | |
| details={ | |
| "future_records": len(future), | |
| "prediction_records": len(result.predictions) if isinstance(result.predictions, list) else 0, | |
| "reported_log_prob": result.reported_log_prob, | |
| "theory_chars": len(theory_module), | |
| "runtime_ms": result.runtime_ms, | |
| "structural_delta": structural_delta, | |
| **complexity.to_dict(), | |
| }, | |
| ) | |
| def gaussian_log_likelihood(predictions: Any, future: list[SensorRecord], sigma: float) -> float: | |
| prediction_rows = _as_prediction_rows(predictions) | |
| if not prediction_rows: | |
| return -1e6 | |
| sigma = max(1e-6, sigma) | |
| constant = -math.log(sigma * math.sqrt(2.0 * math.pi)) | |
| log_likelihood = 0.0 | |
| count = 0 | |
| for index, record in enumerate(future): | |
| row = prediction_rows[min(index, len(prediction_rows) - 1)] | |
| sensors = row["sensors"] | |
| for name, observed in record.sensors.items(): | |
| predicted = float(sensors.get(name, 0.0)) | |
| error = observed - predicted | |
| log_likelihood += constant - 0.5 * (error / sigma) ** 2 | |
| count += 1 | |
| if count == 0: | |
| return -1e6 | |
| return max(-1e6, log_likelihood / count) | |
| def anomaly_score(predictions: Any, future: list[SensorRecord], bonus: float) -> tuple[float, bool]: | |
| if not window_has_anomaly(future): | |
| return 0.0, False | |
| prediction_rows = _as_prediction_rows(predictions) | |
| detected = False | |
| for index, record in enumerate(future): | |
| if not record.anomaly: | |
| continue | |
| if not prediction_rows: | |
| break | |
| row = prediction_rows[min(index, len(prediction_rows) - 1)] | |
| detected = detected or float(row.get("anomaly_prob", 0.0)) >= 0.5 | |
| return (bonus if detected else 0.0), not detected | |
| def drift_score( | |
| result: SandboxResult, | |
| future: list[SensorRecord], | |
| paradigm_shift_claim: bool, | |
| bonus: float, | |
| false_claim_penalty: float, | |
| structural_delta: float = 1.0, | |
| min_structural_delta: float = 0.0, | |
| ) -> tuple[float, bool, bool]: | |
| drifted = window_has_drift(future) | |
| claimed = bool(paradigm_shift_claim or result.drift_detected) | |
| if drifted and claimed: | |
| if min_structural_delta <= 0.0: | |
| return bonus, False, False | |
| change_scale = min(1.0, max(0.0, structural_delta) / min_structural_delta) | |
| return bonus * change_scale, False, change_scale < 1.0 | |
| if not drifted and claimed: | |
| return -false_claim_penalty, True, False | |
| return 0.0, False, False | |
| def theory_complexity(theory_module: str, mode: str = "ast") -> ComplexityBreakdown: | |
| if mode == "chars": | |
| return ComplexityBreakdown( | |
| mode=mode, | |
| score=float(len(theory_module)), | |
| ast_nodes=0, | |
| import_count=0, | |
| class_count=0, | |
| function_count=0, | |
| parameter_count=0, | |
| branch_count=0, | |
| self_state_assignments=0, | |
| parse_ok=True, | |
| fallback_chars=len(theory_module), | |
| ) | |
| if parse_theory_dsl(theory_module) is not None: | |
| try: | |
| score = dsl_complexity(theory_module) | |
| except TheoryDSLValidationError: | |
| score = max(1.0, len(theory_module) / 80.0) | |
| parse_ok = False | |
| else: | |
| parse_ok = True | |
| return ComplexityBreakdown( | |
| mode="dsl", | |
| score=float(score or 1.0), | |
| ast_nodes=0, | |
| import_count=0, | |
| class_count=0, | |
| function_count=0, | |
| parameter_count=0, | |
| branch_count=0, | |
| self_state_assignments=0, | |
| parse_ok=parse_ok, | |
| fallback_chars=0 if parse_ok else len(theory_module), | |
| ) | |
| try: | |
| tree = ast.parse(theory_module) | |
| except SyntaxError: | |
| fallback_score = max(1.0, len(theory_module) / 80.0) | |
| return ComplexityBreakdown( | |
| mode=mode, | |
| score=float(fallback_score), | |
| ast_nodes=0, | |
| import_count=0, | |
| class_count=0, | |
| function_count=0, | |
| parameter_count=0, | |
| branch_count=0, | |
| self_state_assignments=0, | |
| parse_ok=False, | |
| fallback_chars=len(theory_module), | |
| ) | |
| nodes = list(ast.walk(tree)) | |
| import_count = sum(isinstance(node, ast.Import | ast.ImportFrom) for node in nodes) | |
| class_count = sum(isinstance(node, ast.ClassDef) for node in nodes) | |
| function_count = sum(isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) for node in nodes) | |
| branch_count = sum(isinstance(node, ast.If | ast.For | ast.While | ast.Try | ast.With | ast.BoolOp) for node in nodes) | |
| arg_count = sum(len(node.args.args) + len(node.args.kwonlyargs) for node in nodes if isinstance(node, ast.FunctionDef)) | |
| numeric_constants = sum( | |
| isinstance(node, ast.Constant) and isinstance(node.value, int | float) | |
| for node in nodes | |
| ) | |
| self_state_assignments = sum(_self_assignment_count(node) for node in nodes) | |
| parameter_count = int(arg_count + numeric_constants + self_state_assignments) | |
| score = ( | |
| len(nodes) | |
| + 2.0 * import_count | |
| + 3.0 * class_count | |
| + 2.0 * function_count | |
| + 1.5 * parameter_count | |
| + 2.0 * branch_count | |
| ) | |
| return ComplexityBreakdown( | |
| mode=mode, | |
| score=float(score), | |
| ast_nodes=len(nodes), | |
| import_count=int(import_count), | |
| class_count=int(class_count), | |
| function_count=int(function_count), | |
| parameter_count=parameter_count, | |
| branch_count=int(branch_count), | |
| self_state_assignments=int(self_state_assignments), | |
| parse_ok=True, | |
| ) | |
| def theory_structural_distance(theory_module: str, previous_theory_module: str | None) -> float: | |
| if not previous_theory_module: | |
| return 1.0 | |
| try: | |
| current_dsl = dsl_signature(theory_module) | |
| previous_dsl = dsl_signature(previous_theory_module) | |
| except TheoryDSLValidationError: | |
| current_dsl = None | |
| previous_dsl = None | |
| if current_dsl is not None or previous_dsl is not None: | |
| if current_dsl is None or previous_dsl is None: | |
| return 1.0 | |
| return _counter_distance(Counter(current_dsl), Counter(previous_dsl)) | |
| current = _ast_feature_counts(theory_module) | |
| previous = _ast_feature_counts(previous_theory_module) | |
| if not current and not previous: | |
| return 0.0 if theory_module == previous_theory_module else 1.0 | |
| return _counter_distance(current, previous) | |
| def _counter_distance(current: Counter[str], previous: Counter[str]) -> float: | |
| keys = set(current) | set(previous) | |
| numerator = sum(abs(current.get(key, 0) - previous.get(key, 0)) for key in keys) | |
| denominator = sum(max(current.get(key, 0), previous.get(key, 0)) for key in keys) | |
| if denominator <= 0: | |
| return 0.0 | |
| return float(max(0.0, min(1.0, numerator / denominator))) | |
| def prediction_diagnostics( | |
| predictions: Any, | |
| future: list[SensorRecord], | |
| sigma: float, | |
| divergence_sigma: float = 2.0, | |
| ) -> dict[str, Any]: | |
| prediction_rows = _as_prediction_rows(predictions) | |
| threshold = max(1e-9, abs(float(sigma)) * float(divergence_sigma)) | |
| per_sensor_errors: dict[str, list[dict[str, float]]] = {} | |
| first_divergence: dict[str, Any] | None = None | |
| for index, record in enumerate(future): | |
| row = prediction_rows[min(index, len(prediction_rows) - 1)] if prediction_rows else {"sensors": {}} | |
| sensors = row["sensors"] | |
| for name, observed in record.sensors.items(): | |
| predicted = float(sensors.get(name, 0.0)) | |
| error = float(observed - predicted) | |
| entry = { | |
| "t": float(record.t), | |
| "observed": float(observed), | |
| "predicted": predicted, | |
| "error": error, | |
| "abs_error": abs(error), | |
| } | |
| per_sensor_errors.setdefault(str(name), []).append(entry) | |
| if first_divergence is None and abs(error) > threshold: | |
| first_divergence = { | |
| "t": float(record.t), | |
| "sensor": str(name), | |
| "abs_error": abs(error), | |
| "threshold": threshold, | |
| } | |
| per_sensor = {} | |
| worst_sensor = None | |
| worst_mae = -1.0 | |
| for name, errors in per_sensor_errors.items(): | |
| if not errors: | |
| continue | |
| abs_errors = [item["abs_error"] for item in errors] | |
| signed_errors = [item["error"] for item in errors] | |
| mae = sum(abs_errors) / len(abs_errors) | |
| rmse = math.sqrt(sum(value * value for value in signed_errors) / len(signed_errors)) | |
| divergences = [item for item in errors if item["abs_error"] > threshold] | |
| per_sensor[name] = { | |
| "mae": mae, | |
| "rmse": rmse, | |
| "bias": sum(signed_errors) / len(signed_errors), | |
| "max_abs_error": max(abs_errors), | |
| "first_divergence_t": divergences[0]["t"] if divergences else None, | |
| } | |
| if mae > worst_mae: | |
| worst_sensor = name | |
| worst_mae = mae | |
| return { | |
| "divergence_threshold": threshold, | |
| "divergence_sigma": divergence_sigma, | |
| "per_sensor": per_sensor, | |
| "worst_sensor": worst_sensor, | |
| "first_divergence": first_divergence, | |
| "prediction_records": len(prediction_rows), | |
| "future_records": len(future), | |
| "missing_prediction_rows": max(0, len(future) - len(prediction_rows)), | |
| } | |
| def _self_assignment_count(node: ast.AST) -> int: | |
| targets: list[ast.AST] | |
| if isinstance(node, ast.Assign): | |
| targets = list(node.targets) | |
| elif isinstance(node, ast.AnnAssign): | |
| targets = [node.target] | |
| elif isinstance(node, ast.AugAssign): | |
| targets = [node.target] | |
| else: | |
| return 0 | |
| return sum( | |
| isinstance(target, ast.Attribute) | |
| and isinstance(target.value, ast.Name) | |
| and target.value.id == "self" | |
| for target in targets | |
| ) | |
| def _ast_feature_counts(theory_module: str) -> Counter[str]: | |
| try: | |
| tree = ast.parse(theory_module) | |
| except SyntaxError: | |
| return Counter() | |
| counts: Counter[str] = Counter() | |
| for node in ast.walk(tree): | |
| counts[f"node:{type(node).__name__}"] += 1 | |
| if isinstance(node, ast.ClassDef): | |
| counts[f"class:{node.name}"] += 1 | |
| elif isinstance(node, ast.FunctionDef): | |
| counts[f"function:{node.name}"] += 1 | |
| elif isinstance(node, ast.Call): | |
| counts[f"call:{_call_name(node.func)}"] += 1 | |
| elif isinstance(node, ast.Attribute): | |
| counts[f"attribute:{node.attr}"] += 1 | |
| elif isinstance(node, ast.BinOp): | |
| counts[f"binop:{type(node.op).__name__}"] += 1 | |
| elif isinstance(node, ast.Compare): | |
| for op in node.ops: | |
| counts[f"compare:{type(op).__name__}"] += 1 | |
| return counts | |
| def _call_name(node: ast.AST) -> str: | |
| if isinstance(node, ast.Name): | |
| return node.id | |
| if isinstance(node, ast.Attribute): | |
| return node.attr | |
| return type(node).__name__ | |
| def _as_prediction_rows(predictions: Any) -> list[dict[str, Any]]: | |
| if not isinstance(predictions, list): | |
| return [] | |
| rows = [] | |
| for item in predictions: | |
| if not isinstance(item, dict): | |
| rows.append({"sensors": {}, "anomaly_prob": 0.0}) | |
| continue | |
| sensors = item.get("sensors") | |
| if isinstance(sensors, dict): | |
| numeric_sensors = { | |
| str(name): float(value) | |
| for name, value in sensors.items() | |
| if isinstance(value, int | float) | |
| } | |
| else: | |
| numeric_sensors = { | |
| str(name): float(value) | |
| for name, value in item.items() | |
| if name not in {"anomaly_prob", "anomaly_probability"} and isinstance(value, int | float) | |
| } | |
| rows.append( | |
| { | |
| "sensors": numeric_sensors, | |
| "anomaly_prob": float(item.get("anomaly_prob", item.get("anomaly_probability", 0.0))), | |
| } | |
| ) | |
| return rows | |