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
// multi_margin_loss_f64.wgsl - Multi-class Margin Loss (f64 canonical)
//
// Hinge loss for multi-class classification
// Loss = sum_{j≠y} max(0, margin - (x[y] - x[j]))^p / num_classes
//
// Used in SVM-style multi-class classification

struct Params {
    batch_size: u32,
    num_classes: u32,
    p: u32,          // 1 or 2 (power for the margin)
    margin: f64,     // Margin (typically 1.0)
}

@group(0) @binding(0) var<storage, read> input: array<f64>;        // [batch, num_classes] - scores
@group(0) @binding(1) var<storage, read> target_data: array<u32>;       // [batch] - true class
@group(0) @binding(2) var<storage, read> weight: array<f64>;       // [num_classes] - class weights
@group(0) @binding(3) var<storage, read_write> output: array<f64>; // [batch] - per-sample loss
@group(0) @binding(4) var<uniform> params: Params;

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let b = global_id.x;

    if (b >= params.batch_size) {
        return;
    }

    let true_class = target_data[b];

    if (true_class >= params.num_classes) {
        output[b] = 0.0;
        return;
    }

    let true_score = input[b * params.num_classes + true_class];

    var loss_sum: f64 = 0.0;

    // Sum over all classes except true class
    for (var c: u32 = 0u; c < params.num_classes; c = c + 1u) {
        if (c != true_class) {
            let class_score = input[b * params.num_classes + c];
            let margin_violation = params.margin - (true_score - class_score);
            let hinge = max(0.0, margin_violation);

            // Apply power
            let powered = select(hinge, hinge * hinge, params.p == 2u);

            // Apply class weight
            loss_sum = loss_sum + weight[c] * powered;
        }
    }

    // Average over classes
    output[b] = loss_sum / f64(params.num_classes);
}