oxidelm 0.2.0

Bare-metal pure-Rust Transformer engine with reverse-mode autograd, BPE tokenization, and wgpu acceleration
Documentation
#[path = "common/mod.rs"]
mod common;

use common::gpu_or_skip;
use oxidelm::{Device, Tensor};

fn assert_close(actual: &[f32], expected: &[f32]) {
    assert_eq!(actual.len(), expected.len());
    for (actual, expected) in actual.iter().zip(expected.iter()) {
        assert!((actual - expected).abs() < 1e-4, "{actual} != {expected}");
    }
}

#[test]
fn gpu_matmul_matches_cpu_matmul() {
    let Some(gpu) = gpu_or_skip() else {
        return;
    };
    let left = Tensor::new(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], vec![2, 3], false);
    let right = Tensor::new(vec![7.0, 8.0, 9.0, 10.0, 11.0, 12.0], vec![3, 2], false);

    let cpu = left.matmul(&right);
    let gpu_result = left
        .to_gpu(&gpu)
        .unwrap()
        .gpu_matmul(&right.to_gpu(&gpu).unwrap(), &gpu)
        .unwrap();

    assert_eq!(gpu_result.device(), Device::Gpu);
    assert_close(&gpu_result.to_cpu().unwrap().data(), &cpu.data());
}

#[test]
fn gpu_batched_gemm_matches_cpu_for_attention_shapes() {
    let Some(gpu) = gpu_or_skip() else {
        return;
    };
    let left = Tensor::new(
        (0..2 * 3 * 4 * 5)
            .map(|index| (index as f32 - 20.0) / 31.0)
            .collect(),
        vec![2, 3, 4, 5],
        false,
    );
    let right = Tensor::new(
        (0..2 * 3 * 5 * 6)
            .map(|index| (17.0 - index as f32) / 29.0)
            .collect(),
        vec![2, 3, 5, 6],
        false,
    );
    let expected = left.matmul(&right).data();
    let actual = left
        .to_gpu(&gpu)
        .unwrap()
        .gpu_batched_gemm(&right.to_gpu(&gpu).unwrap(), &gpu)
        .unwrap();

    assert_eq!(actual.shape(), vec![2, 3, 4, 6]);
    assert_close(&actual.to_cpu().unwrap().data(), &expected);
}

#[test]
fn gpu_forward_operation_keeps_autograd_graph() {
    let Some(gpu) = gpu_or_skip() else {
        return;
    };
    let left = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], vec![2, 2], true);
    let right = Tensor::new(vec![5.0, 6.0, 7.0, 8.0], vec![2, 2], true);

    left.to_gpu(&gpu)
        .unwrap()
        .gpu_matmul(&right.to_gpu(&gpu).unwrap(), &gpu)
        .unwrap()
        .to_cpu()
        .unwrap()
        .sum()
        .backward();

    assert_close(&left.grad().unwrap(), &[11.0, 15.0, 11.0, 15.0]);
    assert_close(&right.grad().unwrap(), &[4.0, 4.0, 6.0, 6.0]);
}