use super::selection::validate_selection;
use super::{DataError, SelectionError};
fn validate_finite(values: &[f32]) -> Result<(), DataError> {
if let Some(index) = values.iter().position(|value| !value.is_finite()) {
return Err(DataError::NonFiniteValue { index });
}
Ok(())
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BinaryTargets {
values: Vec<u8>,
}
impl BinaryTargets {
pub fn new(values: Vec<u8>) -> Result<Self, DataError> {
if values.is_empty() {
return Err(DataError::EmptyTargets);
}
if let Some((index, &value)) = values.iter().enumerate().find(|(_, value)| **value > 1) {
return Err(DataError::InvalidBinaryTarget { index, value });
}
Ok(Self { values })
}
#[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) -> &[u8] {
&self.values
}
#[inline]
pub fn get(&self, index: usize) -> Option<u8> {
self.values.get(index).copied()
}
#[inline]
pub fn into_values(self) -> Vec<u8> {
self.values
}
pub fn select(&self, indices: &[usize]) -> Result<Self, SelectionError> {
validate_selection(indices, self.values.len())?;
Ok(Self {
values: indices.iter().map(|&index| self.values[index]).collect(),
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ClassTargets {
values: Vec<u8>,
classes: Vec<u8>,
}
impl ClassTargets {
pub fn new(values: Vec<u8>) -> Result<Self, DataError> {
if values.is_empty() {
return Err(DataError::EmptyTargets);
}
let classes = observed_classes(&values);
Ok(Self { values, classes })
}
#[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) -> &[u8] {
&self.values
}
#[inline]
pub fn get(&self, index: usize) -> Option<u8> {
self.values.get(index).copied()
}
#[inline]
pub fn classes(&self) -> &[u8] {
&self.classes
}
#[inline]
pub fn n_classes(&self) -> usize {
self.classes.len()
}
#[inline]
pub fn class_index(&self, label: u8) -> Option<usize> {
self.classes.binary_search(&label).ok()
}
#[inline]
pub fn into_values(self) -> Vec<u8> {
self.values
}
pub fn select(&self, indices: &[usize]) -> Result<Self, SelectionError> {
validate_selection(indices, self.values.len())?;
let values = indices
.iter()
.map(|&index| self.values[index])
.collect::<Vec<_>>();
let classes = observed_classes(&values);
Ok(Self { values, classes })
}
}
impl From<BinaryTargets> for ClassTargets {
fn from(targets: BinaryTargets) -> Self {
let values = targets.into_values();
let classes = observed_classes(&values);
Self { values, classes }
}
}
pub trait ClassificationTargets: sealed::Sealed + Sized {
fn as_slice(&self) -> &[u8];
fn select(&self, indices: &[usize]) -> Result<Self, SelectionError>;
}
impl ClassificationTargets for BinaryTargets {
fn as_slice(&self) -> &[u8] {
Self::as_slice(self)
}
fn select(&self, indices: &[usize]) -> Result<Self, SelectionError> {
Self::select(self, indices)
}
}
impl ClassificationTargets for ClassTargets {
fn as_slice(&self) -> &[u8] {
Self::as_slice(self)
}
fn select(&self, indices: &[usize]) -> Result<Self, SelectionError> {
Self::select(self, indices)
}
}
mod sealed {
pub trait Sealed {}
impl Sealed for super::BinaryTargets {}
impl Sealed for super::ClassTargets {}
}
fn observed_classes(values: &[u8]) -> Vec<u8> {
let mut observed = [false; 256];
for &value in values {
observed[value as usize] = true;
}
(0..=u8::MAX)
.filter(|&label| observed[label as usize])
.collect()
}
#[derive(Clone, Debug, PartialEq)]
pub struct RegressionTargets {
values: Vec<f32>,
}
impl RegressionTargets {
pub fn new(values: Vec<f32>) -> Result<Self, DataError> {
if values.is_empty() {
return Err(DataError::EmptyTargets);
}
validate_finite(&values)?;
Ok(Self { values })
}
#[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 fn into_values(self) -> Vec<f32> {
self.values
}
pub fn select(&self, indices: &[usize]) -> Result<Self, SelectionError> {
validate_selection(indices, self.values.len())?;
Ok(Self {
values: indices.iter().map(|&index| self.values[index]).collect(),
})
}
}