use super::DataError;
#[derive(Clone, Debug, PartialEq)]
pub struct SampleWeights {
values: Vec<f32>,
total: f64,
}
impl SampleWeights {
pub fn new(values: Vec<f32>) -> Result<Self, DataError> {
if values.is_empty() {
return Err(DataError::EmptySampleWeights);
}
let mut total = 0.0_f64;
for (index, &value) in values.iter().enumerate() {
if !value.is_finite() {
return Err(DataError::NonFiniteSampleWeight { index });
}
if value < 0.0 {
return Err(DataError::NegativeSampleWeight { index });
}
total += f64::from(value);
}
if total <= 0.0 {
return Err(DataError::ZeroTotalSampleWeight);
}
Ok(Self { values, total })
}
#[inline]
pub fn len(&self) -> usize {
self.values.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.values.is_empty()
}
#[inline]
pub fn as_slice(&self) -> &[f32] {
&self.values
}
#[inline]
pub fn get(&self, index: usize) -> Option<f32> {
self.values.get(index).copied()
}
#[inline]
pub const fn total(&self) -> f64 {
self.total
}
#[inline]
pub fn into_values(self) -> Vec<f32> {
self.values
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::ClassTargets;
fn balanced(targets: &ClassTargets) -> SampleWeights {
let classes = targets.classes().len();
let mut counts = vec![0_usize; classes];
for &label in targets.as_slice() {
counts[targets.class_index(label).expect("observed label")] += 1;
}
let rows = targets.as_slice().len() as f32;
SampleWeights::new(
targets
.as_slice()
.iter()
.map(|&label| {
let count = counts[targets.class_index(label).expect("observed label")];
rows / (classes as f32 * count as f32)
})
.collect(),
)
.expect("positive weights")
}
#[test]
fn balanced_class_weights_equalize_class_totals_without_a_class_weight_parameter() {
let targets = ClassTargets::new(vec![3, 3, 3, 3, 3, 3, 7, 7, 10]).unwrap();
let weights = balanced(&targets);
let mut per_class = vec![0.0_f64; targets.classes().len()];
for (&label, &weight) in targets.as_slice().iter().zip(weights.as_slice()) {
per_class[targets.class_index(label).unwrap()] += f64::from(weight);
}
let expected = per_class[0];
for total in &per_class {
assert!((total - expected).abs() < 1e-5, "{per_class:?}");
}
assert!((weights.total() - targets.as_slice().len() as f64).abs() < 1e-5);
}
#[test]
fn an_already_balanced_problem_gets_unit_weights() {
let targets = ClassTargets::new(vec![0, 0, 1, 1]).unwrap();
assert_eq!(balanced(&targets).as_slice(), [1.0, 1.0, 1.0, 1.0]);
}
}