Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

2.1 KB
Raw Blame
use half::bf16;
use num_traits::Float;
use uzu_engine_macros::kernel;

use crate::data_type::DataTypeRepr;

#[kernel(SeparableCausalConv)]
#[variants(T, bf16)]
pub fn separable_causal_conv<T: DataTypeRepr + Float>(
    input: *const T,
    coefficient_deltas: *const T,
    weights: *const T,
    #[optional(has_bias)] bias: Option<*const T>,
    output: *mut T,
    sequence_length: u32,
    coefficient_row_stride: u32,
    #[specialize] model_dim: u32,
    #[specialize] kernel_size: u32,
    #[specialize] group_size: u32,
    #[specialize] has_bias: bool,
) {
    let sequence_length = sequence_length as usize;
    let coefficient_row_stride = coefficient_row_stride as usize;
    let model_dim = model_dim as usize;
    let kernel_size = kernel_size as usize;
    let group_size = group_size as usize;

    let num_groups = model_dim / group_size;

    for token in 0..sequence_length {
        for channel in 0..model_dim {
            let group = channel / group_size;
            let mut output_value = if has_bias {
                unsafe { (*bias.unwrap().add(channel)).to_f32().unwrap() }
            } else {
                0.0
            };

            for tokens_back in 0..kernel_size.min(token + 1) {
                let input_token = token - tokens_back;
                let input_index = input_token * model_dim + channel;
                let weight_index = channel * kernel_size + (kernel_size - 1 - tokens_back);
                let coefficient_index = token * coefficient_row_stride + tokens_back * num_groups + group;

                let input_value = unsafe { (*input.add(input_index)).to_f32().unwrap() };
                let base_weight = unsafe { (*weights.add(weight_index)).to_f32().unwrap() };
                let coefficient_delta = unsafe { (*coefficient_deltas.add(coefficient_index)).to_f32().unwrap() };

                output_value += input_value * (base_weight + coefficient_delta);
            }

            let output_index = token * model_dim + channel;
            unsafe {
                *output.add(output_index) = T::from(output_value).unwrap();
            }
        }
    }
}