use crate::error::{finite, invalid};
use crate::{Binomial, Datafit, FitError, Gaussian, NullModelDatafit, SmoothDatafit};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ValidationMetric {
MeanSquaredError,
MeanAbsoluteError,
LogLoss,
BinomialDeviance,
}
impl ValidationMetric {
pub fn score(self, response: &[f64], predictor: &[f64]) -> Result<f64, FitError> {
let score = match self {
Self::MeanSquaredError => 2.0 * Gaussian::new(response).value(predictor)?,
Self::MeanAbsoluteError => {
if response.is_empty()
|| response.len() != predictor.len()
|| response.iter().chain(predictor).any(|v| !v.is_finite())
{
return Err(invalid(
"scores require nonempty, matching finite responses and predictors",
));
}
response
.iter()
.zip(predictor)
.map(|(y, eta)| (y - eta).abs() / response.len() as f64)
.sum()
}
Self::LogLoss => Binomial::new(response).value(predictor)?,
Self::BinomialDeviance => Binomial::new(response).deviance(predictor)?.unwrap(),
};
Ok(finite(score, "computing a validation score", 0)?)
}
}
pub trait CrossValidationDatafit: SmoothDatafit {
type WithResponse<'a>: CrossValidationDatafit;
fn response(&self) -> &[f64];
fn with_response<'a>(&self, response: &'a [f64]) -> Self::WithResponse<'a>;
fn validation_metric(&self) -> ValidationMetric;
fn supports_metric(&self, metric: ValidationMetric) -> bool;
fn validate_training(&self) -> Result<(), FitError>;
}
impl CrossValidationDatafit for Gaussian<'_> {
type WithResponse<'a> = Gaussian<'a>;
fn response(&self) -> &[f64] {
self.response()
}
fn with_response<'a>(&self, response: &'a [f64]) -> Gaussian<'a> {
Gaussian::new(response).fit_intercept(self.fits_intercept())
}
fn validation_metric(&self) -> ValidationMetric {
ValidationMetric::MeanSquaredError
}
fn supports_metric(&self, metric: ValidationMetric) -> bool {
matches!(
metric,
ValidationMetric::MeanSquaredError | ValidationMetric::MeanAbsoluteError
)
}
fn validate_training(&self) -> Result<(), FitError> {
self.validate(self.response().len())
}
}
impl CrossValidationDatafit for Binomial<'_> {
type WithResponse<'a> = Binomial<'a>;
fn response(&self) -> &[f64] {
self.response()
}
fn with_response<'a>(&self, response: &'a [f64]) -> Binomial<'a> {
Binomial::new(response).fit_intercept(self.fits_intercept())
}
fn validation_metric(&self) -> ValidationMetric {
ValidationMetric::LogLoss
}
fn supports_metric(&self, metric: ValidationMetric) -> bool {
matches!(
metric,
ValidationMetric::LogLoss | ValidationMetric::BinomialDeviance
)
}
fn validate_training(&self) -> Result<(), FitError> {
self.value(&vec![0.0; self.response().len()])?;
if self.fits_intercept()
&& (!self.response().iter().any(|&y| y > 0.0)
|| !self.response().iter().any(|&y| y < 1.0))
{
return Err(invalid(
"binomial training folds with a free intercept require positive success and failure totals; revise the folds or disable the intercept",
));
}
Ok(())
}
}