use crate::api::{
Capabilities, Estimator, HasCapabilities, HasParams, ModelError, Regressor, validate_scalar_row,
};
use crate::data::{MatrixView, RegressionTargets};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct DummyRegressorParams;
#[derive(Clone, Debug, PartialEq)]
pub struct DummyRegressor {
n_features_in: usize,
params: DummyRegressorParams,
mean: f32,
}
impl DummyRegressor {
pub fn fit(
data: &MatrixView<'_>,
targets: &RegressionTargets,
params: DummyRegressorParams,
) -> 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 total: f64 = targets
.as_slice()
.iter()
.map(|&value| f64::from(value))
.sum();
let mean = (total / targets.len() as f64) as f32;
if !mean.is_finite() {
return Err(ModelError::NumericalOverflow);
}
Ok(Self {
n_features_in: data.columns(),
params,
mean,
})
}
pub const fn n_features_in(&self) -> usize {
self.n_features_in
}
pub const fn get_params(&self) -> &DummyRegressorParams {
&self.params
}
pub const fn mean(&self) -> f32 {
self.mean
}
pub fn predict_one(&self, row: &[f32]) -> Result<f32, ModelError> {
validate_scalar_row(row, self.n_features_in)?;
Ok(self.mean)
}
pub fn predict(&self, data: &MatrixView<'_>) -> Result<Vec<f32>, ModelError> {
<Self as Regressor>::predict(self, data)
}
pub fn predict_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
<Self as Regressor>::predict_into(self, data, output)
}
}
impl Estimator for DummyRegressor {
fn n_features_in(&self) -> usize {
self.n_features_in
}
}
impl HasParams for DummyRegressor {
type Params = DummyRegressorParams;
fn get_params(&self) -> &Self::Params {
&self.params
}
}
impl HasCapabilities for DummyRegressor {
const CAPABILITIES: Capabilities = Capabilities::NONE;
}
impl Regressor for DummyRegressor {
fn predict_into(&self, data: &MatrixView<'_>, output: &mut [f32]) -> Result<(), ModelError> {
if data.columns() != self.n_features_in {
return Err(ModelError::FeatureDimension {
expected: self.n_features_in,
actual: data.columns(),
});
}
if output.len() != data.rows() {
return Err(ModelError::OutputLength {
expected: data.rows(),
actual: output.len(),
});
}
output.fill(self.mean);
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_training_mean_for_every_row() {
let model = DummyRegressor::fit(
&data().as_view(),
&RegressionTargets::new(vec![1.0, 2.0, 6.0]).unwrap(),
DummyRegressorParams,
)
.unwrap();
assert_eq!(model.mean(), 3.0);
assert_eq!(model.predict(&data().as_view()).unwrap(), vec![3.0; 3]);
assert_eq!(model.predict_one(&[9.0, 9.0]).unwrap(), 3.0);
}
#[test]
fn extreme_targets_average_without_overflowing() {
let model = DummyRegressor::fit(
&data().as_view(),
&RegressionTargets::new(vec![f32::MAX; 3]).unwrap(),
DummyRegressorParams,
)
.unwrap();
assert_eq!(model.mean(), f32::MAX);
}
#[test]
fn fitting_rejects_mismatched_targets_before_any_work() {
assert_eq!(
DummyRegressor::fit(
&data().as_view(),
&RegressionTargets::new(vec![1.0, 2.0]).unwrap(),
DummyRegressorParams,
)
.unwrap_err(),
ModelError::TargetLength {
rows: 3,
targets: 2
}
);
}
}