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 AdaDeltaParams {
pub rho: f32,
pub epsilon: f32,
pub weight_decay: f32,
pub _padding: u32,
}
pub struct AdaDelta {
weights: Tensor,
gradients: Tensor,
acc_grad: Option<Tensor>,
acc_delta: Option<Tensor>,
rho: f32,
}
impl AdaDelta {
pub fn new(
weights: Tensor,
gradients: Tensor,
rho: f32,
acc_grad: Option<Tensor>,
acc_delta: Option<Tensor>,
) -> Result<Self> {
if weights.shape() != gradients.shape() {
return Err(BarracudaError::shape_mismatch(
weights.shape().to_vec(),
gradients.shape().to_vec(),
));
}
if !(0.0..=1.0).contains(&rho) {
return Err(BarracudaError::invalid_op(
"adadelta",
"rho must be in range [0.0, 1.0]",
));
}
if let Some(ref ag) = acc_grad
&& ag.shape() != weights.shape()
{
return Err(BarracudaError::shape_mismatch(
ag.shape().to_vec(),
weights.shape().to_vec(),
));
}
if let Some(ref ad) = acc_delta
&& ad.shape() != weights.shape()
{
return Err(BarracudaError::shape_mismatch(
ad.shape().to_vec(),
weights.shape().to_vec(),
));
}
Ok(Self {
weights,
gradients,
acc_grad,
acc_delta,
rho,
})
}
pub(super) fn shader() -> &'static str {
{
static SHADER: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
include_str!("../../shaders/optimizer/adadelta_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 acc_grad(&self) -> Option<&Tensor> {
self.acc_grad.as_ref()
}
pub(super) fn acc_delta(&self) -> Option<&Tensor> {
self.acc_delta.as_ref()
}
pub(super) fn rho(&self) -> f32 {
self.rho
}
}
impl Tensor {
pub fn adadelta_step(
self,
gradients: &Self,
rho: f32,
acc_grad: Option<&Self>,
acc_delta: Option<&Self>,
) -> Result<(Self, Self, Self)> {
AdaDelta::new(
self,
gradients.clone(),
rho,
acc_grad.cloned(),
acc_delta.cloned(),
)?
.execute()
}
}