| |
| """Initial search baseline for the AlphaEvolve AC2 task.""" |
|
|
| import time |
| import numpy as np |
|
|
|
|
| def evaluate_sequence(sequence: list[float]) -> float: |
| """Evaluator objective. Higher is better.""" |
| if not isinstance(sequence, list): |
| return float(np.inf) |
| if not sequence: |
| return float(np.inf) |
|
|
| for x in sequence: |
| if isinstance(x, bool) or not isinstance(x, (int, float)): |
| return float(np.inf) |
| if np.isnan(x) or np.isinf(x): |
| return float(np.inf) |
|
|
| seq = [float(x) for x in sequence] |
| seq = [max(0.0, min(1000.0, x)) for x in seq] |
| if np.sum(seq) < 0.01: |
| return float(np.inf) |
|
|
| conv = np.convolve(seq, seq) |
| n = len(conv) |
|
|
| x_points = np.linspace(-0.5, 0.5, n + 2) |
| dx = np.diff(x_points) |
| y = np.concatenate(([0.0], conv, [0.0])) |
|
|
| l2_sq = 0.0 |
| for i in range(n + 1): |
| y1 = y[i] |
| y2 = y[i + 1] |
| h = dx[i] |
| l2_sq += (h / 3.0) * (y1 * y1 + y1 * y2 + y2 * y2) |
|
|
| norm_1 = float(np.sum(np.abs(conv)) / (len(conv) + 1)) |
| norm_inf = float(np.max(np.abs(conv))) |
| if norm_1 <= 0.0 or norm_inf <= 0.0: |
| return float(np.inf) |
| return float(l2_sq / (norm_1 * norm_inf)) |
|
|
|
|
| def _make_sparse_seed(rng: np.random.Generator, n: int) -> np.ndarray: |
| h = np.zeros(n, dtype=np.float64) |
| k = int(rng.integers(4, max(8, n // 32))) |
| idx = rng.choice(n, size=k, replace=False) |
| h[idx] = rng.uniform(0.3, 8.0, size=k) |
| return h |
|
|
|
|
| def run(seed: int = 42, budget_s: float = 10.0, **kwargs) -> list[float]: |
| """ |
| Return a coefficient sequence maximizing evaluate_sequence. |
| """ |
| del kwargs |
| rng = np.random.default_rng(seed) |
| deadline = time.time() + max(0.1, 0.98 * budget_s) |
|
|
| n = 2048 |
| best = _make_sparse_seed(rng, n) |
| best_score = evaluate_sequence(best.tolist()) |
|
|
| |
| for _ in range(24): |
| cand = _make_sparse_seed(rng, n) |
| score = evaluate_sequence(cand.tolist()) |
| if score > best_score: |
| best, best_score = cand, score |
|
|
| while time.time() < deadline: |
| cand = best.copy() |
|
|
| if rng.random() < 0.6: |
| |
| active = np.where(cand > 1e-12)[0] |
| if active.size > 0: |
| k = int(rng.integers(1, min(12, active.size + 1))) |
| edit_idx = rng.choice(active, size=k, replace=False) |
| cand[edit_idx] *= rng.uniform(0.95, 1.08, size=k) |
|
|
| if rng.random() < 0.35: |
| |
| i = int(rng.integers(0, n)) |
| j = int(np.clip(i + rng.integers(-32, 33), 0, n - 1)) |
| amount = 0.05 * max(0.0, cand[i]) |
| cand[i] = max(0.0, cand[i] - amount) |
| cand[j] += amount |
|
|
| if rng.random() < 0.20: |
| |
| k = int(rng.integers(1, 6)) |
| idx = rng.choice(n, size=k, replace=False) |
| cand[idx] += rng.uniform(0.01, 0.4, size=k) |
|
|
| cand = np.clip(cand, 0.0, 1000.0) |
| score = evaluate_sequence(cand.tolist()) |
| if np.isfinite(score) and score > best_score: |
| best, best_score = cand, score |
|
|
| return [float(x) for x in best.tolist()] |
|
|
|
|
| |
|
|
