def __init__(
self,
theta,
weights=None,
candidates_per_iteration: int = 100, # aka lambda
num_survivors: int = 1,
noise_stdev: float = 13, #
# noise_stdev: float = 65.1, # Canonical ESRL Paper (.05 for 1.7M params) = .05*sqrt(1.7e6) = 65.1
# noise_stdev:float = 3.84e-5 #(Canonical ESRL Paper (.05 for 1.7M params))
# noise_stdev: float = 1.92e-4,
# noise_stdev: float = 2 * 1.92e-4,
# noise_stdev: float = 1.92e-4 * np.sqrt(10) / 1.5,
# noise_stdev: float = .05,
# step_scale:float = 1.0,
step_scale: float = 1.0,
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
**kwargs,
) -> None:
self._theta = np.array(theta, dtype=np.float32) # theta size: 67586
self._candidates_per_iteration: int = candidates_per_iteration
self.num_survivors: int = num_survivors
self.step_scale: float = step_scale
# self.noise_stdev: float = noise_stdev
self.noise_stdev: float = noise_stdev / np.sqrt(self._theta.size)
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
self._previous_theta = np.copy(self._theta)
def __init__(
self,
theta,
# sigma: float = .05, # mutation step-size
sigma: float = .435, # mutation step-size (8.7X single-point norm)
# noise_stdev: float = 1.92e-4,
candidates_per_iteration: int = 144, # aka lambda
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
**kwargs,
) -> None:
print('theta size:', theta.size)
self._theta = np.array(theta, dtype=np.float32) # theta size: 67586
self._sigma: float = sigma
self._candidates_per_iteration: int = candidates_per_iteration
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
self._weights = np.fromiter(
(math.log(candidates_per_iteration + 1.5) - math.log(i + 1)
for i in range(candidates_per_iteration)),
dtype=np.float32)
self._weights /= np.sum(self._weights)
self._previous_theta = np.copy(self._theta)
def __init__(
self,
mu,
sigma: float = .25,
selection_proportion: float = .10,
candidates_per_iteration: int = 144,
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
remember_best: bool = False,
**kwargs,
) -> None:
self._mu = np.array(mu, dtype=np.float32)
self._candidates_per_iteration: int = candidates_per_iteration
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
self._selection_proportion: float = selection_proportion
self._selection_size: int = math.ceil(self._selection_proportion *
candidates_per_iteration)
self._sigma = np.zeros(mu.size, dtype=np.float32) + sigma
self._best_candidate: Optional[Tuple[float, any]] = None
self._remember_best: bool = remember_best
self._weights = np.fromiter((1.0 for i in range(self._selection_size)),
dtype=np.float32)
def __init__(
self,
mu,
sigma: float = .25,
# selection_proportion: float = .10,
candidates_per_iteration: int = 144,
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
remember_best: bool = False,
**kwargs,
) -> None:
self._mu = np.array(mu, dtype=np.float32)
self._candidates_per_iteration: int = candidates_per_iteration
self.noise_table: NoiseTable = NoiseTable(noise_size, random_seed) if noise_table is None else noise_table
# self._selection_proportion: float = selection_proportion
self._sigma = np.zeros(mu.size, dtype=np.float32) + sigma
self._best_candidate: Optional[Tuple[float, any]] = None
self._remember_best: bool = remember_best
self._weights = np.fromiter(
(math.log(candidates_per_iteration + 1.5) - math.log(i + 1) for i in range(candidates_per_iteration)),
dtype=np.float32)
# self._weights = np.fromiter(
# (math.exp(-.2*i)for i in range(candidates_per_iteration)),
# dtype=np.float32)
self._weights /= np.sum(self._weights)
pprint(self._weights)
def __init__(
self,
theta,
mu: float = 0.0,
sigma: float = .5,
# selection_proportion: float = .10,
candidates_per_iteration: int = 100,
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
**kwargs,
) -> None:
self.population = {0: Candidate(0, None, theta, mu, sigma)}
self._candidates_per_iteration: int = candidates_per_iteration
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
def __init__(
self,
theta,
noise_stdev:
float = 1.92e-4, # 3.84e-5 (Canonical ESRL Paper (.05 for 1.7M params))
candidates_per_iteration: int = 100, # aka lambda
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
**kwargs,
) -> None:
self._theta = np.array(theta, dtype=np.float32)
self.noise_stdev: float = noise_stdev * np.sqrt(self._theta.size)
self._candidates_per_iteration: int = candidates_per_iteration
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
self._previous_theta = np.copy(self._theta)
def __init__(
self,
theta,
weights=None,
candidates_per_iteration: int = 100, # aka lambda
noise_stdev: float = .05,
noise_size: int = 67108864,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
**kwargs,
) -> None:
self._theta = np.array(theta, dtype=np.float32)
self._candidates_per_iteration: int = candidates_per_iteration
self.noise_stdev: float = noise_stdev
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
# self._weights = np.fromiter(
# (2 * (1 - x) - 1
# for x in ((i / (candidates_per_iteration - 1))
# for i in range(candidates_per_iteration))),
# dtype=np.float32)
# self._weights = np.fromiter(
# ((1 - x)
# for x in ((i / (candidates_per_iteration - 1))
# for i in range(candidates_per_iteration))),
# dtype=np.float32)
# self._weights = np.zeros(candidates_per_iteration, dtype=np.float32)
# self._weights[0] = 1.0
# self._weights = np.fromiter(
# (1.0 if x <= .02 else 0
# for x in ((i / (candidates_per_iteration - 1))
# for i in range(candidates_per_iteration))),
# dtype=np.float32)
self._weights = weights
# self._weights /= np.sum(np.abs(self._weights))
self._previous_theta = np.copy(self._theta)
def __init__(
self,
theta,
alpha: float = .2,
theta_decay: float = .001,
noise_stdev: float = .05,
# noise_stdev:float = 3.85e-3,
candidates_per_iteration: int = 144,
noise_size: int = 16777216,
random_seed: int = None,
noise_table: Optional[NoiseTable] = None,
**kwargs,
) -> None:
# print('ESRLCoordinatedOptimizer: ', candidates_per_iteration, alpha, theta_decay, noise_stdev, noise_size, random_seed)
self.theta = theta
self.alpha: float = alpha
self.theta_decay: float = theta_decay
self.noise_stdev: float = noise_stdev
self.candidates_per_iteration: int = candidates_per_iteration
self.noise_table: NoiseTable = NoiseTable(
noise_size, random_seed) if noise_table is None else noise_table
self.g = np.zeros(self.theta.size)