oxidelm 0.2.0

Bare-metal pure-Rust Transformer engine with reverse-mode autograd, BPE tokenization, and wgpu acceleration
Documentation
//! Global gradient-tracking mode for inference and evaluation.
//!
//! When disabled, tensor operations do not record parent history or mark
//! outputs as requiring gradients. Leaf tensors created with
//! `requires_grad = true` keep that flag so parameters stay trainable.

use std::cell::Cell;

thread_local! {
    static GRAD_ENABLED: Cell<bool> = const { Cell::new(true) };
}

/// Returns whether new operations currently record autograd history.
pub fn is_grad_enabled() -> bool {
    GRAD_ENABLED.with(|flag| flag.get())
}

/// Enables or disables gradient tracking for the current thread.
pub fn set_grad_enabled(enabled: bool) {
    GRAD_ENABLED.with(|flag| flag.set(enabled));
}

/// RAII guard that restores the previous gradient mode when dropped.
pub struct GradModeGuard {
    previous: bool,
}

impl GradModeGuard {
    fn enter(enabled: bool) -> Self {
        let previous = is_grad_enabled();
        set_grad_enabled(enabled);
        Self { previous }
    }
}

impl Drop for GradModeGuard {
    fn drop(&mut self) {
        set_grad_enabled(self.previous);
    }
}

/// Disables gradient tracking until the returned guard is dropped.
pub fn no_grad() -> GradModeGuard {
    GradModeGuard::enter(false)
}

/// Enables gradient tracking until the returned guard is dropped.
pub fn enable_grad() -> GradModeGuard {
    GradModeGuard::enter(true)
}

/// Runs `f` with gradient tracking disabled.
pub fn with_no_grad<T>(f: impl FnOnce() -> T) -> T {
    let _guard = no_grad();
    f()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{IndexTensor, Tensor};

    #[test]
    fn no_grad_skips_history_but_preserves_leaf_requires_grad() {
        let x = Tensor::new(vec![1.0, 2.0, 3.0], vec![3], true);
        assert!(x.requires_grad());
        assert!(x.is_leaf());

        let y = with_no_grad(|| {
            let y = (&x * &x).sum();
            assert!(!y.requires_grad());
            assert!(y.is_leaf());
            assert!(y.try_backward().is_err());
            y
        });

        assert!(is_grad_enabled());
        assert!(x.requires_grad());
        assert!(x.grad().is_none());
        assert!(!y.requires_grad());
    }

    #[test]
    fn nested_guards_restore_previous_mode() {
        assert!(is_grad_enabled());
        {
            let _outer = no_grad();
            assert!(!is_grad_enabled());
            {
                let _inner = enable_grad();
                assert!(is_grad_enabled());
                let x = Tensor::new(vec![1.0, 2.0], vec![2], true);
                let y = x.sum();
                assert!(y.requires_grad());
                assert!(!y.is_leaf());
            }
            assert!(!is_grad_enabled());
        }
        assert!(is_grad_enabled());
    }

    #[test]
    fn no_grad_leaf_constructor_keeps_requires_grad() {
        let leaf = with_no_grad(|| Tensor::new(vec![1.0], vec![1], true));
        assert!(leaf.requires_grad());
        assert!(leaf.is_leaf());
    }

    #[test]
    fn embedding_under_no_grad_is_detached() {
        let weight = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], vec![2, 2], true);
        let indices = IndexTensor::new(vec![1, 0], vec![2]);
        let output = with_no_grad(|| weight.embedding(&indices));
        assert!(!output.requires_grad());
        assert!(output.is_leaf());
        assert_eq!(output.data(), vec![3.0, 4.0, 1.0, 2.0]);
    }
}