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 AdamParams {
pub num_params: u32,
pub learning_rate: f32,
pub beta1: f32,
pub beta2: f32,
pub epsilon: f32,
pub weight_decay: f32,
pub step: u32,
}
pub struct Adam {
gradients: Tensor,
params: Tensor,
m: Option<Tensor>,
v: Option<Tensor>,
learning_rate: f32,
beta1: f32,
beta2: f32,
step: usize,
}
impl Adam {
pub fn new(
params: Tensor,
gradients: Tensor,
learning_rate: f32,
beta1: f32,
beta2: f32,
step: usize,
m: Option<Tensor>,
v: Option<Tensor>,
) -> Result<Self> {
if params.shape() != gradients.shape() {
return Err(BarracudaError::shape_mismatch(
params.shape().to_vec(),
gradients.shape().to_vec(),
));
}
if learning_rate <= 0.0 {
return Err(BarracudaError::invalid_op(
"adam",
"learning_rate must be positive",
));
}
if !(0.0..1.0).contains(&beta1) {
return Err(BarracudaError::invalid_op(
"adam",
"beta1 must be in range [0.0, 1.0)",
));
}
if !(0.0..1.0).contains(&beta2) {
return Err(BarracudaError::invalid_op(
"adam",
"beta2 must be in range [0.0, 1.0)",
));
}
if step == 0 {
return Err(BarracudaError::invalid_op(
"adam",
"step must be >= 1 (starts at 1, not 0)",
));
}
if let Some(ref m_tensor) = m
&& m_tensor.shape() != params.shape()
{
return Err(BarracudaError::shape_mismatch(
m_tensor.shape().to_vec(),
params.shape().to_vec(),
));
}
if let Some(ref v_tensor) = v
&& v_tensor.shape() != params.shape()
{
return Err(BarracudaError::shape_mismatch(
v_tensor.shape().to_vec(),
params.shape().to_vec(),
));
}
Ok(Self {
gradients,
params,
m,
v,
learning_rate,
beta1,
beta2,
step,
})
}
pub(super) fn shader() -> &'static str {
{
static SHADER: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
include_str!("../../shaders/optimizer/adam_f64.wgsl").to_string()
});
std::sync::LazyLock::force(&SHADER).as_str()
}
}
pub(super) fn params(&self) -> &Tensor {
&self.params
}
pub(super) fn gradients(&self) -> &Tensor {
&self.gradients
}
pub(super) fn m(&self) -> Option<&Tensor> {
self.m.as_ref()
}
pub(super) fn v(&self) -> Option<&Tensor> {
self.v.as_ref()
}
pub(super) fn learning_rate(&self) -> f32 {
self.learning_rate
}
pub(super) fn beta1(&self) -> f32 {
self.beta1
}
pub(super) fn beta2(&self) -> f32 {
self.beta2
}
pub(super) fn step(&self) -> usize {
self.step
}
}
impl Tensor {
pub fn adam_step(
self,
gradients: &Self,
learning_rate: f32,
beta1: f32,
beta2: f32,
step: usize,
m: Option<&Self>,
v: Option<&Self>,
) -> Result<(Self, Self, Self)> {
Adam::new(
self,
gradients.clone(),
learning_rate,
beta1,
beta2,
step,
m.cloned(),
v.cloned(),
)?
.execute()
}
}