Struct HardwareAwareOptimizer 

pub struct HardwareAwareOptimizer<A: Float + 'static, D: Dimension + 'static> { /* private fields */ }

Hardware-aware optimizer that adapts to different platforms

Implementations

impl<A: Float + ScalarOperand + Debug + Sum + for<'a> Sum<&'a A> + Send + Sync + 'static, D: Dimension + 'static> HardwareAwareOptimizer<A, D>

pub fn new(platform: HardwarePlatform, initialparameters: Array<A, D>) -> Self

Create a new hardware-aware optimizer at the default learning rate (DEFAULT_BASE_LEARNING_RATE).

pub fn new_with_learning_rate( platform: HardwarePlatform, initialparameters: Array<A, D>, base_learning_rate: A, ) -> Self

Create a new hardware-aware optimizer with an explicit base learning rate.

The optimizer family is chosen by HardwareOptimizerKind::recommend_for from the platform’s default configuration, and the gradient accumulation window from that configuration’s MemoryStrategy, so the returned optimizer can take a real step immediately — before Self::optimize_for_hardware has refined anything.

pub fn optimize_for_hardware(&mut self) -> Result<()>

Optimize configuration for target hardware

pub fn recommended_optimizer_kind(&self) -> HardwareOptimizerKind

Optimizer family the current platform and configuration call for.

pub fn adopt_recommended_optimizer(&mut self) -> HardwareOptimizerKind

Adopt the current recommendation, discarding the existing optimizer’s accumulated state.

Returns the family now in use.

pub fn step(&mut self, gradients: &Array<A, D>) -> Result<HardwareStepReport<A>>

Apply one gradient through the configured optimizer.

This is the step path the module’s hardware analysis exists to configure: the optimizer family, the learning rate schedule and the gradient accumulation window all come from the platform configuration.

pub fn parameters(&self) -> &Array<A, D>

Current parameters.

pub fn optimization_state(&self) -> &OptimizationState<A, D>

The optimization state, for callers that need the step count, the learning rate or the optimizer family.

pub fn optimization_state_mut(&mut self) -> &mut OptimizationState<A, D>

Mutable access to the optimization state, for installing a learning rate schedule or a caller-supplied optimizer.

pub fn tuner(&self) -> &AdaptiveTuner<A>

The adaptive tuner, for inspecting the tuning history and the tuned parameters.

pub fn tuner_mut(&mut self) -> &mut AdaptiveTuner<A>

Mutable access to the adaptive tuner, for registering the parameters the search may move and selecting a TuningStrategy.

pub fn tune_parameters<F>(&mut self, evaluate: F) -> Result<TuningOutcome<A>>

where F: FnMut(&HashMap<String, A>) -> Result<TuningObservation<A>>,

Run the configured tuning search, then apply anything it found that this module knows how to apply.

A tuned parameter named batch_size is written back into the hardware configuration (rounded and clamped to at least 1); every other tuned parameter is left for the caller to read from AdaptiveTuner::current_params, because only the caller knows what it means.

pub fn profile_performance( &mut self, computation_time: A, memoryused: usize, energy: A, )

Profile current performance

pub fn update_resource_monitor( &mut self, memory: usize, cpuutil: A, power: A, temp: A, )

Update resource monitoring

pub fn adaptive_tune(&mut self, targetperformance: A) -> Result<()>

Adaptive tuning based on performance feedback

pub fn get_config(&self) -> &HardwareOptimizationConfig<A>

Get current configuration

pub fn get_performance_stats(&self) -> HardwarePerformanceStats<A>

Get performance statistics

Trait Implementations

impl<A: Debug + Float + 'static, D: Debug + Dimension + 'static> Debug for HardwareAwareOptimizer<A, D>

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

Formats the value using the given formatter.