Struct BatAlgorithm 

pub struct BatAlgorithm<B: Backend> { /* private fields */ }

Bat Algorithm strategy.

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::metaheuristic::bat::{BatAlgorithm, BatConfig};

let strategy = BatAlgorithm::<Flex>::new();
let params = BatConfig::default_for(32, 10);
let _ = (strategy, params);

Implementations

impl<B: Backend> BatAlgorithm<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

impl<B: Clone + Backend> Clone for BatAlgorithm<B>

fn clone(&self) -> BatAlgorithm<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Copy + Backend> Copy for BatAlgorithm<B>

impl<B: Debug + Backend> Debug for BatAlgorithm<B>

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

Formats the value using the given formatter.

impl<B: Default + Backend> Default for BatAlgorithm<B>

fn default() -> BatAlgorithm<B>

Returns the “default value” for a type.

impl<B: Backend> Strategy<B> for BatAlgorithm<B>

where B::Device: Clone,

fn init( &self, params: &BatConfig, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> BatState<B>

Build the initial colony by host-sampling pop_size positions uniformly in [bounds.lo, bounds.hi].

Velocities are zeroed, loudness is set to params.a0, pulse rate to params.r0, and fitness left empty so that the first ask → tell pair initialises those fields before any acceptance logic runs. Positions are drawn from a deterministic seed_stream; the process-wide Flex RNG is never touched.

fn ask( &self, params: &BatConfig, state: &BatState<B>, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> (Tensor<B, 2>, BatState<B>)

Propose candidate positions for the current generation.

On the first call (state.fitness is empty) returns the initial positions unchanged so the caller can evaluate generation zero.

On subsequent calls the update proceeds in three host/device steps:

1. Frequency — sample f_i = f_min + (f_max − f_min)·β_i, β_i ∈ U[0,1].
2. Global move — v_i ← v_i + (x_i − x_best)·f_i, x'_i = x_i + v_i.
3. Local walk (when rand > r_i) — override with x'_i = x_best + ε·mean(A), ε ∈ U[−1,1].

All random draws are host-sampled through seed_stream for bit-stable reproduction across thread schedules. The per-bat acceptance decisions (pending_accept) are recorded in the returned state and consumed by tell.

Panics

Panics if called when state.best_genome is None after the first generation has been evaluated (i.e. if state.fitness is non-empty but state.best_genome was not set by a preceding tell call).

fn tell( &self, params: &BatConfig, candidates: Tensor<B, 2>, fitness: Tensor<B, 1>, state: BatState<B>, _rng: &mut dyn Rng, ) -> (BatState<B>, StrategyMetrics)

Ingest candidate fitness values, apply the acceptance gate, and advance the generation counter.

On the first call (generation zero bootstrap) all candidates are unconditionally accepted and loudness/pulse-rate updates are skipped.

On subsequent calls candidate i replaces position i iff pending_accept[i] (drawn in ask) and fitness[i] ≥ state.fitness[i]. On acceptance, loudness decays (A_i *= α) and pulse rate grows (r_i = r₀·(1 − exp(−γ·t))).

fn best(&self, state: &BatState<B>) -> Option<(Tensor<B, 2>, f32)>

Returns the best-so-far (genome, fitness) pair, or None before the first tell call.

type Params = BatConfig

Static parameters for a run.

type State = BatState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.