|
|
"""
|
|
|
Persistent state tracking for incremental batch evaluation.
|
|
|
|
|
|
Tracks completed pairs to enable resume functionality.
|
|
|
"""
|
|
|
|
|
|
import json
|
|
|
import csv
|
|
|
from dataclasses import dataclass, field, asdict
|
|
|
from datetime import datetime
|
|
|
from pathlib import Path
|
|
|
from typing import Dict, List, Optional, Set
|
|
|
|
|
|
from .pair import Pair
|
|
|
|
|
|
|
|
|
@dataclass
|
|
|
class PairResult:
|
|
|
"""Result of evaluating a single pair."""
|
|
|
|
|
|
pair_id: str
|
|
|
score: Optional[float] = None
|
|
|
status: str = "pending"
|
|
|
message: Optional[str] = None
|
|
|
duration_seconds: Optional[float] = None
|
|
|
timestamp: Optional[str] = None
|
|
|
|
|
|
@property
|
|
|
def is_complete(self) -> bool:
|
|
|
"""Whether this pair has finished evaluation (success or failure)."""
|
|
|
return self.status in ("success", "error", "timeout", "skipped")
|
|
|
|
|
|
@property
|
|
|
def is_success(self) -> bool:
|
|
|
return self.status == "success"
|
|
|
|
|
|
|
|
|
@dataclass
|
|
|
class EvaluationState:
|
|
|
"""
|
|
|
Persistent state for batch evaluation.
|
|
|
|
|
|
Tracks which pairs have been evaluated, their results, and metadata.
|
|
|
"""
|
|
|
|
|
|
results: Dict[str, PairResult] = field(default_factory=dict)
|
|
|
started_at: Optional[str] = None
|
|
|
updated_at: Optional[str] = None
|
|
|
total_pairs: int = 0
|
|
|
backend: str = "docker"
|
|
|
config: Dict = field(default_factory=dict)
|
|
|
|
|
|
@classmethod
|
|
|
def load(cls, path: Path) -> "EvaluationState":
|
|
|
"""Load state from a JSON file."""
|
|
|
if not path.exists():
|
|
|
return cls()
|
|
|
|
|
|
try:
|
|
|
with path.open("r", encoding="utf-8") as f:
|
|
|
data = json.load(f)
|
|
|
except (json.JSONDecodeError, IOError):
|
|
|
return cls()
|
|
|
|
|
|
state = cls(
|
|
|
started_at=data.get("started_at"),
|
|
|
updated_at=data.get("updated_at"),
|
|
|
total_pairs=data.get("total_pairs", 0),
|
|
|
backend=data.get("backend", "docker"),
|
|
|
config=data.get("config", {}),
|
|
|
)
|
|
|
|
|
|
|
|
|
for pair_id, result_data in data.get("results", {}).items():
|
|
|
state.results[pair_id] = PairResult(
|
|
|
pair_id=pair_id,
|
|
|
score=result_data.get("score"),
|
|
|
status=result_data.get("status", "pending"),
|
|
|
message=result_data.get("message"),
|
|
|
duration_seconds=result_data.get("duration_seconds"),
|
|
|
timestamp=result_data.get("timestamp"),
|
|
|
)
|
|
|
|
|
|
return state
|
|
|
|
|
|
def save(self, path: Path) -> None:
|
|
|
"""Save state to a JSON file."""
|
|
|
self.updated_at = datetime.now().isoformat()
|
|
|
|
|
|
data = {
|
|
|
"started_at": self.started_at,
|
|
|
"updated_at": self.updated_at,
|
|
|
"total_pairs": self.total_pairs,
|
|
|
"backend": self.backend,
|
|
|
"config": self.config,
|
|
|
"results": {
|
|
|
pair_id: {
|
|
|
"score": r.score,
|
|
|
"status": r.status,
|
|
|
"message": r.message,
|
|
|
"duration_seconds": r.duration_seconds,
|
|
|
"timestamp": r.timestamp,
|
|
|
}
|
|
|
for pair_id, r in self.results.items()
|
|
|
},
|
|
|
}
|
|
|
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
with path.open("w", encoding="utf-8") as f:
|
|
|
json.dump(data, f, indent=2)
|
|
|
|
|
|
def get_pending_pairs(self, pairs: List[Pair]) -> List[Pair]:
|
|
|
"""Get pairs that haven't been successfully evaluated yet."""
|
|
|
return [p for p in pairs if not self.is_complete(p)]
|
|
|
|
|
|
def is_complete(self, pair: Pair) -> bool:
|
|
|
"""Check if a pair has been evaluated."""
|
|
|
result = self.results.get(pair.id)
|
|
|
return result is not None and result.is_complete
|
|
|
|
|
|
def mark_running(self, pair: Pair) -> None:
|
|
|
"""Mark a pair as currently running."""
|
|
|
self.results[pair.id] = PairResult(
|
|
|
pair_id=pair.id,
|
|
|
status="running",
|
|
|
timestamp=datetime.now().isoformat(),
|
|
|
)
|
|
|
|
|
|
def record_result(
|
|
|
self,
|
|
|
pair: Pair,
|
|
|
score: Optional[float],
|
|
|
status: str,
|
|
|
message: Optional[str] = None,
|
|
|
duration_seconds: Optional[float] = None,
|
|
|
) -> None:
|
|
|
"""Record the result of evaluating a pair."""
|
|
|
self.results[pair.id] = PairResult(
|
|
|
pair_id=pair.id,
|
|
|
score=score,
|
|
|
status=status,
|
|
|
message=message,
|
|
|
duration_seconds=duration_seconds,
|
|
|
timestamp=datetime.now().isoformat(),
|
|
|
)
|
|
|
|
|
|
@property
|
|
|
def completed_count(self) -> int:
|
|
|
"""Number of completed evaluations."""
|
|
|
return sum(1 for r in self.results.values() if r.is_complete)
|
|
|
|
|
|
@property
|
|
|
def success_count(self) -> int:
|
|
|
"""Number of successful evaluations."""
|
|
|
return sum(1 for r in self.results.values() if r.is_success)
|
|
|
|
|
|
@property
|
|
|
def error_count(self) -> int:
|
|
|
"""Number of failed evaluations."""
|
|
|
return sum(1 for r in self.results.values() if r.status in ("error", "timeout"))
|
|
|
|
|
|
def export_csv(self, path: Path) -> None:
|
|
|
"""Export results to a CSV file."""
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
|
with path.open("w", newline="", encoding="utf-8") as f:
|
|
|
writer = csv.writer(f)
|
|
|
writer.writerow(["solution", "problem", "score", "status", "message", "duration_seconds", "timestamp"])
|
|
|
|
|
|
for pair_id, result in sorted(self.results.items()):
|
|
|
solution, problem = pair_id.split(":", 1)
|
|
|
writer.writerow([
|
|
|
solution,
|
|
|
problem,
|
|
|
result.score if result.score is not None else "",
|
|
|
result.status,
|
|
|
result.message or "",
|
|
|
result.duration_seconds or "",
|
|
|
result.timestamp or "",
|
|
|
])
|
|
|
|
|
|
def export_summary(self, path: Path) -> None:
|
|
|
"""Export a human-readable summary."""
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
|
lines = [
|
|
|
f"Evaluation Summary - {datetime.now().isoformat()}",
|
|
|
"=" * 50,
|
|
|
f"Total pairs: {self.total_pairs}",
|
|
|
f"Completed: {self.completed_count}",
|
|
|
f"Successful: {self.success_count}",
|
|
|
f"Errors: {self.error_count}",
|
|
|
"",
|
|
|
"Results:",
|
|
|
"-" * 50,
|
|
|
]
|
|
|
|
|
|
for pair_id, result in sorted(self.results.items()):
|
|
|
solution, problem = pair_id.split(":", 1)
|
|
|
if result.is_success:
|
|
|
lines.append(f"{solution} -> {problem}: {result.score}")
|
|
|
else:
|
|
|
lines.append(f"{solution} -> {problem}: {result.status} - {result.message or 'N/A'}")
|
|
|
|
|
|
path.write_text("\n".join(lines), encoding="utf-8")
|
|
|
|
|
|
def export_failed(self, path: Path) -> int:
|
|
|
"""Export failed pairs to a file (solution:problem format). Returns count."""
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
failed = [
|
|
|
pair_id for pair_id, r in self.results.items()
|
|
|
if r.status in ("error", "timeout")
|
|
|
]
|
|
|
path.write_text("\n".join(sorted(failed)) + "\n" if failed else "", encoding="utf-8")
|
|
|
return len(failed)
|
|
|
|
|
|
def export_pending(self, path: Path, all_pairs: Optional[List[Pair]] = None) -> int:
|
|
|
"""Export pending/incomplete pairs. Returns count."""
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
if all_pairs:
|
|
|
|
|
|
pending = [p.id for p in all_pairs if not self.is_complete(p)]
|
|
|
else:
|
|
|
|
|
|
pending = [
|
|
|
pair_id for pair_id, r in self.results.items()
|
|
|
if not r.is_complete
|
|
|
]
|
|
|
path.write_text("\n".join(sorted(pending)) + "\n" if pending else "", encoding="utf-8")
|
|
|
return len(pending)
|
|
|
|
|
|
def export_skipped(self, path: Path) -> int:
|
|
|
"""Export skipped pairs. Returns count."""
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
skipped = [
|
|
|
pair_id for pair_id, r in self.results.items()
|
|
|
if r.status == "skipped"
|
|
|
]
|
|
|
path.write_text("\n".join(sorted(skipped)) + "\n" if skipped else "", encoding="utf-8")
|
|
|
return len(skipped)
|
|
|
|
|
|
def get_failed_pairs(self) -> List[Pair]:
|
|
|
"""Get list of failed pairs."""
|
|
|
return [
|
|
|
Pair(solution=pair_id.split(":")[0], problem=pair_id.split(":")[1])
|
|
|
for pair_id, r in self.results.items()
|
|
|
if r.status in ("error", "timeout")
|
|
|
]
|
|
|
|
|
|
def get_successful_pairs(self) -> List[Pair]:
|
|
|
"""Get list of successful pairs."""
|
|
|
return [
|
|
|
Pair(solution=pair_id.split(":")[0], problem=pair_id.split(":")[1])
|
|
|
for pair_id, r in self.results.items()
|
|
|
if r.is_success
|
|
|
]
|
|
|
|
|
|
def aggregate_by_model(self) -> Dict[str, Dict[str, any]]:
|
|
|
"""Aggregate results by model (solution prefix before first _)."""
|
|
|
by_model: Dict[str, List[PairResult]] = {}
|
|
|
for pair_id, result in self.results.items():
|
|
|
solution = pair_id.split(":")[0]
|
|
|
|
|
|
model = solution.split("_")[0] if "_" in solution else solution
|
|
|
if model not in by_model:
|
|
|
by_model[model] = []
|
|
|
by_model[model].append(result)
|
|
|
|
|
|
aggregated = {}
|
|
|
for model, results in by_model.items():
|
|
|
successful = [r for r in results if r.is_success]
|
|
|
scores = [r.score for r in successful if r.score is not None]
|
|
|
aggregated[model] = {
|
|
|
"total": len(results),
|
|
|
"successful": len(successful),
|
|
|
"failed": len(results) - len(successful),
|
|
|
"avg_score": sum(scores) / len(scores) if scores else None,
|
|
|
"min_score": min(scores) if scores else None,
|
|
|
"max_score": max(scores) if scores else None,
|
|
|
}
|
|
|
return aggregated
|
|
|
|
|
|
def aggregate_by_problem(self) -> Dict[str, Dict[str, any]]:
|
|
|
"""Aggregate results by problem."""
|
|
|
by_problem: Dict[str, List[PairResult]] = {}
|
|
|
for pair_id, result in self.results.items():
|
|
|
problem = pair_id.split(":")[1]
|
|
|
if problem not in by_problem:
|
|
|
by_problem[problem] = []
|
|
|
by_problem[problem].append(result)
|
|
|
|
|
|
aggregated = {}
|
|
|
for problem, results in by_problem.items():
|
|
|
successful = [r for r in results if r.is_success]
|
|
|
scores = [r.score for r in successful if r.score is not None]
|
|
|
aggregated[problem] = {
|
|
|
"total": len(results),
|
|
|
"successful": len(successful),
|
|
|
"failed": len(results) - len(successful),
|
|
|
"avg_score": sum(scores) / len(scores) if scores else None,
|
|
|
"min_score": min(scores) if scores else None,
|
|
|
"max_score": max(scores) if scores else None,
|
|
|
}
|
|
|
return aggregated
|
|
|
|
|
|
def export_aggregated_csv(self, path: Path, by: str = "model") -> None:
|
|
|
"""Export aggregated results to CSV (by 'model' or 'problem')."""
|
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
|
if by == "model":
|
|
|
data = self.aggregate_by_model()
|
|
|
key_name = "model"
|
|
|
else:
|
|
|
data = self.aggregate_by_problem()
|
|
|
key_name = "problem"
|
|
|
|
|
|
with path.open("w", newline="", encoding="utf-8") as f:
|
|
|
writer = csv.writer(f)
|
|
|
writer.writerow([key_name, "total", "successful", "failed", "avg_score", "min_score", "max_score"])
|
|
|
for key, stats in sorted(data.items()):
|
|
|
writer.writerow([
|
|
|
key,
|
|
|
stats["total"],
|
|
|
stats["successful"],
|
|
|
stats["failed"],
|
|
|
f"{stats['avg_score']:.4f}" if stats["avg_score"] is not None else "",
|
|
|
stats["min_score"] if stats["min_score"] is not None else "",
|
|
|
stats["max_score"] if stats["max_score"] is not None else "",
|
|
|
])
|
|
|
|
