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
// Instance Normalization (f64 canonical)
// Normalizes each instance (sample) independently across spatial dimensions
//
// For input shape [batch, channels, height, width]:
// Computes mean and variance over (height, width) for each (batch, channel) pair
//
// InstanceNorm(x) = gamma * (x - mean) / sqrt(variance + epsilon) + beta
//
// Used in: Style transfer, GANs, real-time image generation
// Benefits: No dependency on batch, works well for style/texture tasks

@group(0) @binding(0) var<storage, read> input: array<f64>;
@group(0) @binding(1) var<storage, read> gamma: array<f64>;  // Scale per channel
@group(0) @binding(2) var<storage, read> beta: array<f64>;   // Shift per channel
@group(0) @binding(3) var<storage, read_write> output: array<f64>;
@group(0) @binding(4) var<uniform> params: Params;

struct Params {
    batch: u32,
    channels: u32,
    spatial_size: u32,  // height * width
    epsilon: f64,
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let idx = global_id.x;
    let total_instances = params.batch * params.channels;
    
    if idx >= total_instances {
        return;
    }
    
    let b = idx / params.channels;
    let c = idx % params.channels;
    
    // Compute mean over spatial dimensions
    var sum: f64 = 0.0;
    let base_idx = b * (params.channels * params.spatial_size) + c * params.spatial_size;
    
    for (var i: u32 = 0u; i < params.spatial_size; i = i + 1u) {
        sum = sum + input[base_idx + i];
    }
    
    let mean = sum / f64(params.spatial_size);
    
    // Compute variance
    var var_sum: f64 = 0.0;
    for (var i: u32 = 0u; i < params.spatial_size; i = i + 1u) {
        let diff = input[base_idx + i] - mean;
        var_sum = var_sum + diff * diff;
    }
    
    let variance = var_sum / f64(params.spatial_size);
    let std_dev = sqrt_f64(variance + params.epsilon);
    
    // Normalize and apply affine transform
    let g = gamma[c];
    let bt = beta[c];
    
    for (var i: u32 = 0u; i < params.spatial_size; i = i + 1u) {
        let normalized = (input[base_idx + i] - mean) / std_dev;
        output[base_idx + i] = g * normalized + bt;
    }
}