use crate::api::{
Capabilities, Classifier, Estimator, HasCapabilities, HasParams, ModelError,
ProbabilisticClassifier, validate_scalar_row,
};
use crate::data::{BinaryTargets, MatrixView};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct DummyClassifierParams;
#[derive(Clone, Debug, PartialEq)]
pub struct DummyClassifier {
n_features_in: usize,
params: DummyClassifierParams,
classes: Vec<u8>,
priors: Vec<f32>,
majority: u8,
}
impl DummyClassifier {
pub fn fit(
data: &MatrixView<'_>,
targets: &BinaryTargets,
params: DummyClassifierParams,
) -> Result<Self, ModelError> {
if data.rows() == 0 || data.columns() == 0 {
return Err(ModelError::EmptyData);
}
if targets.len() != data.rows() {
return Err(ModelError::TargetLength {
rows: data.rows(),
targets: targets.len(),
});
}
let mut counts = [0_usize; 2];
for &value in targets.as_slice() {
counts[usize::from(value)] += 1;
}
let classes: Vec<u8> = (0..2_u8)
.filter(|&label| counts[usize::from(label)] > 0)
.collect();
let total = targets.len() as f64;
let priors: Vec<f32> = classes
.iter()
.map(|&label| (counts[usize::from(label)] as f64 / total) as f32)
.collect();
let majority = Self::majority_label(&classes, &counts);
Ok(Self {
n_features_in: data.columns(),
params,
classes,
priors,
majority,
})
}
fn majority_label(classes: &[u8], counts: &[usize; 2]) -> u8 {
let mut best = 0;
for index in 1..classes.len() {
if counts[usize::from(classes[index])] > counts[usize::from(classes[best])] {
best = index;
}
}
classes[best]
}
pub const fn n_features_in(&self) -> usize {
self.n_features_in
}
pub fn classes(&self) -> &[u8] {
&self.classes
}
pub const fn get_params(&self) -> &DummyClassifierParams {
&self.params
}
pub fn class_priors(&self) -> &[f32] {
&self.priors
}
pub fn predict_one(&self, row: &[f32]) -> Result<u8, ModelError> {
validate_scalar_row(row, self.n_features_in)?;
Ok(self.majority)
}
pub fn predict(&self, data: &MatrixView<'_>) -> Result<Vec<u8>, ModelError> {
<Self as Classifier>::predict(self, data)
}
pub fn predict_into(&self, data: &MatrixView<'_>, output: &mut [u8]) -> Result<(), ModelError> {
<Self as Classifier>::predict_into(self, data, output)
}
pub fn predict_proba(&self, data: &MatrixView<'_>) -> Result<Vec<f32>, ModelError> {
<Self as ProbabilisticClassifier>::predict_proba(self, data)
}
pub fn predict_proba_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
<Self as ProbabilisticClassifier>::predict_proba_into(self, data, output)
}
pub fn predict_class_proba(
&self,
data: &MatrixView<'_>,
class: u8,
) -> Result<Vec<f32>, ModelError> {
<Self as ProbabilisticClassifier>::predict_class_proba(self, data, class)
}
pub fn predict_class_proba_into(
&self,
data: &MatrixView<'_>,
class: u8,
output: &mut [f32],
) -> Result<(), ModelError> {
<Self as ProbabilisticClassifier>::predict_class_proba_into(self, data, class, output)
}
fn validate_batch(&self, data: &MatrixView<'_>) -> Result<(), ModelError> {
if data.columns() != self.n_features_in {
return Err(ModelError::FeatureDimension {
expected: self.n_features_in,
actual: data.columns(),
});
}
Ok(())
}
fn validate_output(expected: usize, actual: usize) -> Result<(), ModelError> {
if expected != actual {
return Err(ModelError::OutputLength { expected, actual });
}
Ok(())
}
}
impl Estimator for DummyClassifier {
fn n_features_in(&self) -> usize {
self.n_features_in
}
}
impl HasParams for DummyClassifier {
type Params = DummyClassifierParams;
fn get_params(&self) -> &Self::Params {
&self.params
}
}
impl HasCapabilities for DummyClassifier {
const CAPABILITIES: Capabilities = Capabilities::NONE.with_probability(true);
}
impl Classifier for DummyClassifier {
fn classes(&self) -> &[u8] {
&self.classes
}
fn predict_into(&self, data: &MatrixView<'_>, output: &mut [u8]) -> Result<(), ModelError> {
self.validate_batch(data)?;
Self::validate_output(data.rows(), output.len())?;
output.fill(self.majority);
Ok(())
}
}
impl ProbabilisticClassifier for DummyClassifier {
fn predict_proba_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
self.validate_batch(data)?;
let expected =
data.rows()
.checked_mul(self.classes.len())
.ok_or(ModelError::OutputShapeOverflow {
rows: data.rows(),
columns: self.classes.len(),
})?;
Self::validate_output(expected, output.len())?;
for row in output.chunks_exact_mut(self.classes.len()) {
row.copy_from_slice(&self.priors);
}
Ok(())
}
fn predict_class_proba_into(
&self,
data: &MatrixView<'_>,
class: u8,
output: &mut [f32],
) -> Result<(), ModelError> {
self.validate_batch(data)?;
let column = self
.classes
.iter()
.position(|&label| label == class)
.ok_or(ModelError::UnknownClass { class })?;
Self::validate_output(data.rows(), output.len())?;
output.fill(self.priors[column]);
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::DenseMatrix;
fn data() -> DenseMatrix {
DenseMatrix::new(vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0], 3, 2).unwrap()
}
#[test]
fn predicts_the_majority_class_and_its_observed_frequencies() {
let model = DummyClassifier::fit(
&data().as_view(),
&BinaryTargets::new(vec![0, 1, 1]).unwrap(),
DummyClassifierParams,
)
.unwrap();
assert_eq!(model.classes(), &[0, 1]);
assert_eq!(model.class_priors(), &[1.0 / 3.0, 2.0 / 3.0]);
assert_eq!(model.predict(&data().as_view()).unwrap(), vec![1; 3]);
assert_eq!(
model.predict_proba(&data().as_view()).unwrap(),
vec![
1.0 / 3.0,
2.0 / 3.0,
1.0 / 3.0,
2.0 / 3.0,
1.0 / 3.0,
2.0 / 3.0
]
);
assert_eq!(model.predict_one(&[9.0, 9.0]).unwrap(), 1);
}
#[test]
fn an_exact_tie_selects_the_smaller_class() {
let data = DenseMatrix::new(vec![0.0, 1.0, 2.0, 3.0], 2, 2).unwrap();
let model = DummyClassifier::fit(
&data.as_view(),
&BinaryTargets::new(vec![0, 1]).unwrap(),
DummyClassifierParams,
)
.unwrap();
assert_eq!(model.class_priors(), &[0.5, 0.5]);
assert_eq!(model.predict(&data.as_view()).unwrap(), vec![0; 2]);
}
#[test]
fn the_majority_is_predicted_where_the_two_frequencies_round_to_one_f32() {
let minority = 16_777_216_usize;
let majority = minority + 1;
let rows = minority + majority;
let features = vec![0.0_f32; rows];
let view = MatrixView::new(&features, rows, 1).unwrap();
let mut labels = vec![0_u8; rows];
labels[minority..].fill(1);
let model = DummyClassifier::fit(
&view,
&BinaryTargets::new(labels).unwrap(),
DummyClassifierParams,
)
.unwrap();
assert_eq!(model.class_priors(), &[0.5, 0.5]);
assert_eq!(
model.class_priors()[0].to_bits(),
model.class_priors()[1].to_bits()
);
assert_eq!(model.predict_one(&[0.0]).unwrap(), 1);
assert_eq!(
model
.predict(&MatrixView::new(&features[..3], 3, 1).unwrap())
.unwrap(),
vec![1; 3]
);
}
#[test]
fn a_single_observed_class_uses_one_probability_column() {
let model = DummyClassifier::fit(
&data().as_view(),
&BinaryTargets::new(vec![1, 1, 1]).unwrap(),
DummyClassifierParams,
)
.unwrap();
assert_eq!(model.classes(), &[1]);
assert_eq!(
model.predict_proba(&data().as_view()).unwrap(),
vec![1.0; 3]
);
assert_eq!(
model.predict_class_proba(&data().as_view(), 0).unwrap_err(),
ModelError::UnknownClass { class: 0 }
);
}
#[test]
fn fitting_rejects_mismatched_targets_before_any_work() {
assert_eq!(
DummyClassifier::fit(
&data().as_view(),
&BinaryTargets::new(vec![0, 1]).unwrap(),
DummyClassifierParams,
)
.unwrap_err(),
ModelError::TargetLength {
rows: 3,
targets: 2
}
);
}
}