File size: 5,423 Bytes
ea8c728 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | # EVOLVE-BLOCK-START
import numpy as np
from dataclasses import dataclass
from scipy.special import hermite
@dataclass
class Hyperparameters:
learning_rate: float = 0.001
num_steps: int = 50000
num_restarts: int = 10
num_hermite_coeffs: int = 4 # uses H0, H4, H8, H12
class UncertaintyOptimizer:
"""
Finds coefficients for a generalized Hermite polynomial P(x) that minimize
the largest positive root, providing an upper bound for C4.
"""
def __init__(self, hypers: Hyperparameters):
self.hypers = hypers
self.degrees = [4 * k for k in range(hypers.num_hermite_coeffs)]
self.hermite_polys = [hermite(d) for d in self.degrees]
self.H_vals_at_zero = np.array([p(0) for p in self.hermite_polys])
self.x_grid = np.linspace(0.0, 10.0, 3000)
def build_polynomial(self, c_others, c_last):
"""Build the polynomial from Hermite coefficients with P(0)=0 constraint."""
# Enforce P(0) = 0 by solving for c0
c0 = (
-(np.sum(c_others * self.H_vals_at_zero[1:-1]) + c_last * self.H_vals_at_zero[-1])
/ self.H_vals_at_zero[0]
)
hermite_coeffs = np.concatenate([[c0], np.array(c_others), [c_last]])
return hermite_coeffs
def evaluate_polynomial(self, hermite_coeffs):
"""Evaluate the polynomial on the grid and compute loss (negative values)."""
max_degree = self.degrees[-1]
P_poly_coeffs = np.zeros(max_degree + 1)
for i, c in enumerate(hermite_coeffs):
poly = self.hermite_polys[i]
pad_amount = max_degree - poly.order
P_poly_coeffs[pad_amount:] += c * poly.coef
p_values = np.polyval(P_poly_coeffs, self.x_grid)
return P_poly_coeffs, p_values
def compute_c4(self, hermite_coeffs):
"""Compute r_max and C4 from Hermite coefficients."""
max_degree = self.degrees[-1]
P_poly_coeffs = np.zeros(max_degree + 1)
for i, c in enumerate(hermite_coeffs):
poly = self.hermite_polys[i]
pad_amount = max_degree - poly.order
P_poly_coeffs[pad_amount:] += c * poly.coef
# Ensure leading coefficient is positive
if P_poly_coeffs[0] < 0:
P_poly_coeffs = -P_poly_coeffs
hermite_coeffs = -hermite_coeffs
P = np.poly1d(P_poly_coeffs)
# Divide by x^2
Q, R = np.polydiv(P, np.poly1d([1.0, 0.0, 0.0]))
if np.max(np.abs(R.c)) > 1e-10:
return None, None, None
roots = Q.r
real_pos = roots[(np.isreal(roots)) & (roots.real > 0)].real
if real_pos.size == 0:
return None, None, None
# Find largest positive root with sign change
r_candidates = np.sort(real_pos)
r_max = None
for r in r_candidates:
eps = 1e-10 * max(1.0, abs(r))
left = np.polyval(Q, r - eps)
right = np.polyval(Q, r + eps)
if left * right < 0:
r_max = float(r)
if r_max is None:
r_max = float(r_candidates[-1])
c4 = (r_max ** 2) / (2 * np.pi)
return hermite_coeffs, c4, r_max
def run():
hypers = Hyperparameters()
optimizer = UncertaintyOptimizer(hypers)
best_c4_bound = float("inf")
best_coeffs = None
best_r_max = None
# Known good starting point
base_c1 = -0.01158510802599293
base_c2 = -8.921606035407065e-05
base_log_c_last = np.log(1e-6)
for trial in range(hypers.num_restarts):
np.random.seed(42 + trial)
# Perturb around known good point
c1 = base_c1 + np.random.normal() * 1e-3
c2 = base_c2 + np.random.normal() * 1e-5
log_c_last = base_log_c_last + np.random.normal() * 0.5
c_last = np.exp(log_c_last)
c_others = np.array([c1, c2])
hermite_coeffs = optimizer.build_polynomial(c_others, c_last)
# Simple gradient-free optimization via perturbation
current_result = optimizer.compute_c4(hermite_coeffs)
if current_result[1] is None:
continue
_, current_c4, current_r_max = current_result
for step in range(hypers.num_steps):
# Random perturbation
delta = np.random.normal(size=3) * np.array([1e-5, 1e-7, 0.1])
new_c1 = c1 + delta[0]
new_c2 = c2 + delta[1]
new_log_c_last = log_c_last + delta[2]
new_c_last = np.exp(new_log_c_last)
new_c_others = np.array([new_c1, new_c2])
new_coeffs = optimizer.build_polynomial(new_c_others, new_c_last)
new_result = optimizer.compute_c4(new_coeffs)
if new_result[1] is not None and new_result[1] < current_c4:
c1, c2, log_c_last = new_c1, new_c2, new_log_c_last
c_last = new_c_last
hermite_coeffs = new_coeffs
current_c4 = new_result[1]
current_r_max = new_result[2]
if current_c4 < best_c4_bound:
best_c4_bound = current_c4
best_coeffs = hermite_coeffs
best_r_max = current_r_max
if best_coeffs is None:
raise RuntimeError("Failed to find a valid solution in any restart.")
print(f"Best C4 upper bound: {best_c4_bound:.8f}")
print(f"Best r_max: {best_r_max:.8f}")
return best_coeffs, best_c4_bound, best_r_max
# EVOLVE-BLOCK-END
|