Struct SimulatedAnnealing 

pub struct SimulatedAnnealing;

Simulated-annealing local search.

A unit struct: all configuration lives in SimulatedAnnealingParams, so one instance can refine many genomes. See the module docs for the acceptance rule and the best-so-far tracking that upholds the LocalSearch contract.

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::{LocalSearch, SimulatedAnnealing, SimulatedAnnealingParams};

// 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>()
    }
}

let searcher = SimulatedAnnealing;
let params = SimulatedAnnealingParams::default_for(Bounds::new(-5.12, 5.12));
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

Trait Implementations

impl Clone for SimulatedAnnealing

fn clone(&self) -> SimulatedAnnealing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SimulatedAnnealing

impl Debug for SimulatedAnnealing

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

Formats the value using the given formatter.

impl Default for SimulatedAnnealing

fn default() -> SimulatedAnnealing

Returns the “default value” for a type.

impl<B: Backend> LocalSearch<B> for SimulatedAnnealing

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

Panics

Panics if params.max_iters == 0; see refine_impl.

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

Seeds the walker and best-so-far tracker with known_fitness (sanitizing NaN to -inf) instead of re-scoring the input, saving one eval.

Panics

Panics if params.max_iters == 0; see refine_impl.

type Params = SimulatedAnnealingParams

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