use crate::device::DeviceCapabilities;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
pub struct IoULoss {
predictions: Tensor,
targets: Tensor,
smooth: f32,
}
impl IoULoss {
pub fn new(predictions: Tensor, targets: Tensor, smooth: f32) -> Result<Self> {
if predictions.shape() != targets.shape() {
return Err(BarracudaError::shape_mismatch(
predictions.shape().to_vec(),
targets.shape().to_vec(),
));
}
Ok(Self {
predictions,
targets,
smooth,
})
}
fn wgsl_shader() -> &'static str {
static SHADER: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
include_str!("../shaders/loss/iou_loss_f64.wgsl").to_string()
});
&SHADER
}
pub fn execute(self) -> Result<Tensor> {
let device = self.predictions.device();
let size = self.predictions.len();
let num_workgroups = (size as u32).div_ceil(crate::device::capabilities::WORKGROUP_SIZE_1D);
let intersection_buffer = device.create_buffer_f32(num_workgroups as usize)?;
let union_buffer = device.create_buffer_f32(num_workgroups as usize)?;
let output_buffer = device.create_buffer_f32(1)?;
device.write_buffer_f32(&intersection_buffer, &vec![0.0; num_workgroups as usize])?;
device.write_buffer_f32(&union_buffer, &vec![0.0; num_workgroups as usize])?;
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct Params {
size: u32,
smooth_val: f32,
num_partials: u32,
_pad1: u32,
}
let params = Params {
size: size as u32,
smooth_val: self.smooth,
num_partials: num_workgroups,
_pad1: 0,
};
let params_buffer = device.create_uniform_buffer("IoU Loss Params", ¶ms);
let caps = DeviceCapabilities::from_device(device);
let workgroups = caps.dispatch_1d(size as u32);
ComputeDispatch::new(device, "iou_loss_pass1")
.shader(Self::wgsl_shader(), "main")
.storage_read(0, self.predictions.buffer())
.storage_read(1, self.targets.buffer())
.storage_rw(2, &intersection_buffer)
.storage_rw(3, &union_buffer)
.storage_rw(4, &output_buffer)
.uniform(5, ¶ms_buffer)
.dispatch(workgroups, 1, 1)
.submit()?;
ComputeDispatch::new(device, "iou_loss_pass2")
.shader(Self::wgsl_shader(), "compute_loss")
.storage_read(0, self.predictions.buffer())
.storage_read(1, self.targets.buffer())
.storage_rw(2, &intersection_buffer)
.storage_rw(3, &union_buffer)
.storage_rw(4, &output_buffer)
.uniform(5, ¶ms_buffer)
.dispatch(1, 1, 1)
.submit()?;
let output_data = crate::utils::read_buffer(device, &output_buffer, 1)?;
Ok(Tensor::new(output_data, vec![1], device.clone()))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_iou_loss() {
let Some(device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let predictions = Tensor::from_vec_on(vec![0.8; 500], vec![500], device.clone())
.await
.unwrap();
let targets = Tensor::from_vec_on(vec![1.0; 500], vec![500], device.clone())
.await
.unwrap();
let loss = IoULoss::new(predictions, targets, 1e-6)
.unwrap()
.execute()
.unwrap();
let result = loss.to_vec().unwrap();
assert_eq!(result.len(), 1);
assert!(result[0] > 0.0 && result[0] < 1.0);
}
}