mod compute;
#[cfg(test)]
mod tests;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub(crate) struct RMSpropParams {
pub learning_rate: f32,
pub alpha: f32,
pub epsilon: f32,
pub weight_decay: f32,
}
pub struct RMSprop {
weights: Tensor,
gradients: Tensor,
sq_avg: Option<Tensor>,
learning_rate: f32,
alpha: f32,
}
impl RMSprop {
pub fn new(
weights: Tensor,
gradients: Tensor,
learning_rate: f32,
alpha: f32,
sq_avg: Option<Tensor>,
) -> Result<Self> {
if weights.shape() != gradients.shape() {
return Err(BarracudaError::shape_mismatch(
weights.shape().to_vec(),
gradients.shape().to_vec(),
));
}
if learning_rate <= 0.0 {
return Err(BarracudaError::invalid_op(
"rmsprop",
"learning_rate must be positive",
));
}
if !(0.0..=1.0).contains(&alpha) {
return Err(BarracudaError::invalid_op(
"rmsprop",
"alpha must be in range [0.0, 1.0]",
));
}
if let Some(ref sq) = sq_avg
&& sq.shape() != weights.shape()
{
return Err(BarracudaError::shape_mismatch(
sq.shape().to_vec(),
weights.shape().to_vec(),
));
}
Ok(Self {
weights,
gradients,
sq_avg,
learning_rate,
alpha,
})
}
pub(super) fn shader() -> &'static str {
{
static SHADER: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
include_str!("../../shaders/optimizer/rmsprop_f64.wgsl").to_string()
});
std::sync::LazyLock::force(&SHADER).as_str()
}
}
pub(super) fn weights(&self) -> &Tensor {
&self.weights
}
pub(super) fn gradients(&self) -> &Tensor {
&self.gradients
}
pub(super) fn sq_avg(&self) -> Option<&Tensor> {
self.sq_avg.as_ref()
}
pub(super) fn learning_rate(&self) -> f32 {
self.learning_rate
}
pub(super) fn alpha(&self) -> f32 {
self.alpha
}
}
impl Tensor {
pub fn rmsprop_step(
self,
gradients: &Self,
learning_rate: f32,
alpha: f32,
sq_avg: Option<&Self>,
) -> Result<(Self, Self)> {
RMSprop::new(
self,
gradients.clone(),
learning_rate,
alpha,
sq_avg.cloned(),
)?
.execute()
}
}