primal-barracuda 0.4.0

barraCuda — BARrier-free Rust Abstracted Cross-platform Unified Dimensional Algebra. Vendor-agnostic GPU compute via WGSL.
Documentation
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::device::WgpuDevice;
use crate::error::Result;
use crate::ops::multi_head_attention::MultiHeadAttention;
use crate::tensor::Tensor;
use std::sync::Arc;

async fn create_test_tensor(
    device: Arc<WgpuDevice>,
    shape: Vec<usize>,
    value: f32,
) -> Result<Tensor> {
    let size: usize = shape.iter().product();
    let data: Vec<f32> = vec![value; size];
    Tensor::from_vec_on(data, shape, device).await
}

#[tokio::test]
async fn test_multi_head_attention_basic() {
    let dev = crate::device::test_pool::get_test_device().await;

    let batch = 1;
    let seq_len = 4;
    let d_model = 8;
    let num_heads = 2;

    let query = create_test_tensor(dev.clone(), vec![batch, seq_len, d_model], 0.5)
        .await
        .unwrap();
    let key = create_test_tensor(dev.clone(), vec![batch, seq_len, d_model], 0.5)
        .await
        .unwrap();
    let value = create_test_tensor(dev.clone(), vec![batch, seq_len, d_model], 0.5)
        .await
        .unwrap();

    let w_q = create_test_tensor(dev.clone(), vec![d_model, d_model], 0.01)
        .await
        .unwrap();
    let w_k = create_test_tensor(dev.clone(), vec![d_model, d_model], 0.01)
        .await
        .unwrap();
    let w_v = create_test_tensor(dev.clone(), vec![d_model, d_model], 0.01)
        .await
        .unwrap();
    let w_o = create_test_tensor(dev.clone(), vec![d_model, d_model], 0.01)
        .await
        .unwrap();

    let output = MultiHeadAttention::new(query, key, value, w_q, w_k, w_v, w_o, num_heads)
        .unwrap()
        .execute()
        .unwrap();

    assert_eq!(output.shape(), &[batch, seq_len, d_model]);
}