use burn::Tensor;
use serde::Deserialize;
#[derive(Clone, Debug, Deserialize, PartialEq)]
pub struct TensorRecord {
pub shape: Vec<usize>,
pub sum: f64,
pub abs_sum: f64,
pub stride: usize,
pub samples: Vec<f64>,
}
impl TensorRecord {
pub fn numel(&self) -> usize {
self.shape.iter().product()
}
pub fn expected_samples(&self) -> usize {
self.numel().div_ceil(self.stride)
}
pub fn max_abs_error<const D: usize>(
&self,
actual: Tensor<D>,
) -> SampleError {
assert_eq!(actual.dims().to_vec(), self.shape, "shape");
self.worst(&self.values(actual))
}
pub fn assert_matches<const D: usize>(
&self,
what: &str,
actual: Tensor<D>,
rtol: f64,
atol: f64,
) -> SampleError {
assert_eq!(actual.dims().to_vec(), self.shape, "{what}: shape");
let values = self.values(actual);
let mut worst = (0.0f64, 0usize);
for (k, expected) in self.samples.iter().enumerate() {
let got = values[k * self.stride] as f64;
let excess = (got - expected).abs() - (atol + rtol * expected.abs());
if excess > worst.0 {
worst = (excess, k);
}
}
let (excess, k) = worst;
assert!(
excess <= 0.0,
"{what}: sample {k} (element {}) is {} where the reference has {}",
k * self.stride,
values[k * self.stride],
self.samples[k],
);
let sum: f64 = values.iter().map(|&v| v as f64).sum();
let abs_sum: f64 = values.iter().map(|&v| (v as f64).abs()).sum();
for (name, got, expected) in [("sum", sum, self.sum), ("abs_sum", abs_sum, self.abs_sum)] {
assert!(
(got - expected).abs() <= rtol * self.abs_sum + atol,
"{what}: {name} is {got} where the reference has {expected}",
);
}
self.worst(&values)
}
fn values<const D: usize>(
&self,
actual: Tensor<D>,
) -> Vec<f32> {
actual
.into_data()
.try_into_vec_as::<f32>()
.expect("read back f32 values")
}
fn worst(
&self,
values: &[f32],
) -> SampleError {
let mut worst = SampleError {
abs: 0.0,
element: 0,
};
for (k, expected) in self.samples.iter().enumerate() {
let abs = (values[k * self.stride] as f64 - expected).abs();
if abs > worst.abs {
worst = SampleError {
abs,
element: k * self.stride,
};
}
}
worst
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SampleError {
pub abs: f64,
pub element: usize,
}
impl std::fmt::Display for SampleError {
fn fmt(
&self,
f: &mut std::fmt::Formatter<'_>,
) -> std::fmt::Result {
write!(f, "{:.1e} at element {}", self.abs, self.element)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::support::testing::cpu_device;
#[test]
fn test_matches_and_refuses() {
let record = TensorRecord {
shape: vec![2, 3],
sum: 15.0,
abs_sum: 15.0,
stride: 2,
samples: vec![0.0, 2.0, 4.0],
};
assert_eq!(record.expected_samples(), 3);
let tensor = || Tensor::<2>::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]], &cpu_device());
let exact = record.assert_matches("t", tensor(), 1e-6, 1e-6);
assert_eq!(exact.abs, 0.0);
let off =
std::panic::catch_unwind(|| record.assert_matches("t", tensor() * 1.01, 1e-6, 1e-6));
assert!(off.is_err());
}
#[test]
fn test_max_abs_error() {
let record = TensorRecord {
shape: vec![2, 3],
sum: 15.0,
abs_sum: 15.0,
stride: 2,
samples: vec![0.0, 2.0, 4.0],
};
let device = cpu_device();
let near = Tensor::<2>::from_data([[0.0, 9.0, 2.25], [3.0, 3.5, 5.0]], &device);
let error = record.max_abs_error(near);
assert_eq!(error.abs, 0.5);
assert_eq!(error.element, 4);
assert_eq!(error.to_string(), "5.0e-1 at element 4");
let tensor = Tensor::<2>::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]], &device);
assert_eq!(
record.max_abs_error(tensor),
SampleError {
abs: 0.0,
element: 0
}
);
}
}