Struct RandomRestart 

pub struct RandomRestart<L> { /* private fields */ }

Random-restart wrapper around an inner LocalSearch.

Runs the wrapped searcher restarts + 1 times — once from the unperturbed input and restarts times from Gaussian-perturbed, bounds-clamped starting points — and returns the argmax over all runs (ties broken toward the earliest run). The total evaluation budget is the product (restarts + 1) * inner.max_iters; this wrapper adds no cap of its own.

Type parameters

• L: the wrapped inner searcher.

Example

use burn::backend::Flex;
use rand::{rngs::StdRng, SeedableRng};
use rlevo_evolution::fitness::FitnessFn;
use rlevo_core::bounds::Bounds;
use rlevo_evolution::local_search::{
    HillClimbing, HillClimbingParams, LocalSearch, RandomRestart, RandomRestartParams,
};

// Maximize the negated 2-D sphere; the optimum is the origin with fitness 0.
struct NegSphere;
impl FitnessFn<Vec<f32>> for NegSphere {
    fn evaluate_one(&mut self, x: &Vec<f32>) -> f32 {
        -x.iter().map(|v| v * v).sum::<f32>()
    }
}

// Wrap hill climbing in random restart: 3 perturbed restarts + run 0.
let searcher = RandomRestart::new(HillClimbing);
let inner = HillClimbingParams::default_for(Bounds::new(-5.12, 5.12));
let mut params = RandomRestartParams::default_for(inner, Bounds::new(-5.12, 5.12));
params.restarts = 3;
let mut fitness = NegSphere;
let mut rng = StdRng::seed_from_u64(7);

let start = vec![2.5_f32, -1.5];
let start_fit: f32 = -start.iter().map(|v| v * v).sum::<f32>();
let (refined, refined_fit) =
    LocalSearch::<Flex>::refine(&searcher, &params, start, &mut fitness, &mut rng);

assert_eq!(refined.len(), 2); // dimensionality preserved
assert!(refined_fit >= start_fit); // monotone non-worsening

Implementations

impl<L> RandomRestart<L>

pub fn new(inner: L) -> Self

Wraps inner for multi-start refinement.

Trait Implementations

impl<L: Clone> Clone for RandomRestart<L>

fn clone(&self) -> RandomRestart<L>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L: Copy> Copy for RandomRestart<L>

impl<L: Debug> Debug for RandomRestart<L>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Backend, L: LocalSearch<B>> LocalSearch<B> for RandomRestart<L>

fn refine( &self, params: &RandomRestartParams<L::Params>, genome: Vec<f32>, fitness_fn: &mut dyn FitnessFn<Vec<f32>>, rng: &mut dyn Rng, ) -> (Vec<f32>, f32)

Panics

Panics if params.restarts > 0 and params.perturbation is not strictly positive; see refine_impl.

fn refine_with_known_fitness( &self, params: &RandomRestartParams<L::Params>, genome: Vec<f32>, known_fitness: f32, fitness_fn: &mut dyn FitnessFn<Vec<f32>>, rng: &mut dyn Rng, ) -> (Vec<f32>, f32)

Forwards known_fitness to run 0 (the unperturbed input) so its inner searcher skips its seeding eval; perturbed runs are unaffected. See refine_impl.

Panics

Panics if params.restarts > 0 and params.perturbation is not strictly positive; see refine_impl.

type Params = RandomRestartParams<<L as LocalSearch<B>>::Params>

Static configuration for a refinement run (bounds, budget, step sizes, …). Cloned by a memetic wrapper once per generation.