use crate::data::MatrixView;
use crate::ensemble::{RandomForestClassifier, RandomForestClassifierParams};
use crate::linear_model::{LogisticRegression, LogisticRegressionParams};
use super::super::{Classifier, Estimator, ModelError};
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub enum AnyClassifierParams<'a> {
RandomForest(&'a RandomForestClassifierParams),
LogisticRegression(&'a LogisticRegressionParams),
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum AnyClassifier {
RandomForest(RandomForestClassifier),
LogisticRegression(LogisticRegression),
}
impl AnyClassifier {
pub fn n_features_in(&self) -> usize {
<Self as Estimator>::n_features_in(self)
}
pub fn classes(&self) -> &[u8] {
<Self as Classifier>::classes(self)
}
pub fn get_params(&self) -> AnyClassifierParams<'_> {
match self {
Self::RandomForest(model) => AnyClassifierParams::RandomForest(model.get_params()),
Self::LogisticRegression(model) => {
AnyClassifierParams::LogisticRegression(model.get_params())
}
}
}
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 Classifier>::predict_proba(self, data)
}
pub fn predict_proba_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
<Self as Classifier>::predict_proba_into(self, data, output)
}
pub fn predict_class_proba_into(
&self,
data: &MatrixView<'_>,
class: u8,
output: &mut [f32],
) -> Result<(), ModelError> {
<Self as Classifier>::predict_class_proba_into(self, data, class, output)
}
pub fn predict_class_proba(
&self,
data: &MatrixView<'_>,
class: u8,
) -> Result<Vec<f32>, ModelError> {
<Self as Classifier>::predict_class_proba(self, data, class)
}
}
impl From<RandomForestClassifier> for AnyClassifier {
fn from(model: RandomForestClassifier) -> Self {
Self::RandomForest(model)
}
}
impl From<LogisticRegression> for AnyClassifier {
fn from(model: LogisticRegression) -> Self {
Self::LogisticRegression(model)
}
}
impl Estimator for AnyClassifier {
fn n_features_in(&self) -> usize {
match self {
Self::RandomForest(model) => model.n_features_in(),
Self::LogisticRegression(model) => model.n_features_in(),
}
}
}
impl Classifier for AnyClassifier {
fn classes(&self) -> &[u8] {
match self {
Self::RandomForest(model) => model.classes(),
Self::LogisticRegression(model) => model.classes(),
}
}
fn predict_into(&self, data: &MatrixView<'_>, output: &mut [u8]) -> Result<(), ModelError> {
match self {
Self::RandomForest(model) => model.predict_into(data, output),
Self::LogisticRegression(model) => model.predict_into(data, output),
}
}
fn predict_proba_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
match self {
Self::RandomForest(model) => model.predict_proba_into(data, output),
Self::LogisticRegression(model) => model.predict_proba_into(data, output),
}
}
fn predict_class_proba_into(
&self,
data: &MatrixView<'_>,
class: u8,
output: &mut [f32],
) -> Result<(), ModelError> {
match self {
Self::RandomForest(model) => model.predict_class_proba_into(data, class, output),
Self::LogisticRegression(model) => model.predict_class_proba_into(data, class, output),
}
}
}