use super::training::ForestConfig;
use crate::api::{ModelError, validate_prediction};
use crate::data::{MatrixView, SampleWeights};
use crate::tree::{ClassTree, FEATURE_MASK, MaxFeatures, PackedTree};
pub(crate) const MAX_CLASSES: usize = 256;
#[derive(Clone, Debug, PartialEq)]
pub(crate) enum Forest {
Binary(Vec<PackedTree>),
Multiclass(Vec<ClassTree>),
}
impl Forest {
#[cfg(test)]
pub(crate) fn binary_trees(&self) -> &[PackedTree] {
match self {
Self::Binary(trees) => trees,
Self::Multiclass(_) => unreachable!("binary fixture"),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct ClassifierCore {
pub(crate) n_features_in: usize,
pub(crate) classes: Vec<u8>,
pub(crate) forest: Forest,
}
impl ClassifierCore {
pub(crate) fn predict_one(&self, row: &[f32]) -> Result<u8, ModelError> {
check_row(row, self.n_features_in)?;
match &self.forest {
Forest::Binary(trees) => {
if self.classes.len() == 1 {
return Ok(self.classes[0]);
}
let positive = mean_tree_prediction(trees, row).clamp(0.0, 1.0);
Ok(u8::from(positive > 0.5))
}
Forest::Multiclass(trees) => {
let mut storage = [0.0_f32; MAX_CLASSES];
let probabilities = &mut storage[..self.classes.len()];
average_class_probabilities(trees, row, probabilities);
Ok(self.classes[argmax(probabilities)])
}
}
}
pub(crate) fn predict(&self, data: &MatrixView<'_>) -> Result<Vec<u8>, ModelError> {
check_prediction_data(data, data.rows(), data.rows(), self.n_features_in)?;
match &self.forest {
Forest::Binary(_) => {
if self.classes.len() == 1 {
return Ok(vec![self.classes[0]; data.rows()]);
}
let mut scores = vec![0.0; data.rows()];
self.accumulate_positive_into(data, &mut scores)?;
Ok(scores
.into_iter()
.map(|positive| u8::from(positive > 0.5))
.collect())
}
Forest::Multiclass(_) => {
let mut output = vec![0; data.rows()];
self.predict_into(data, &mut output)?;
Ok(output)
}
}
}
pub(crate) fn predict_into(
&self,
data: &MatrixView<'_>,
output: &mut [u8],
) -> Result<(), ModelError> {
check_prediction_data(data, output.len(), data.rows(), self.n_features_in)?;
match &self.forest {
Forest::Binary(trees) => {
if self.classes.len() == 1 {
output.fill(self.classes[0]);
return Ok(());
}
for (row, slot) in data.iter_rows().zip(output) {
let positive = mean_tree_prediction(trees, row).clamp(0.0, 1.0);
*slot = u8::from(positive > 0.5);
}
}
Forest::Multiclass(trees) => {
let mut storage = [0.0_f32; MAX_CLASSES];
let probabilities = &mut storage[..self.classes.len()];
for (row, slot) in data.iter_rows().zip(output) {
average_class_probabilities(trees, row, probabilities);
*slot = self.classes[argmax(probabilities)];
}
}
}
Ok(())
}
pub(crate) fn predict_proba_one(&self, row: &[f32]) -> Result<Vec<f32>, ModelError> {
let mut output = vec![0.0; self.classes.len()];
self.predict_proba_one_into(row, &mut output)?;
Ok(output)
}
pub(crate) fn predict_proba_one_into(
&self,
row: &[f32],
output: &mut [f32],
) -> Result<(), ModelError> {
check_row(row, self.n_features_in)?;
check_output_len(output.len(), self.classes.len())?;
match &self.forest {
Forest::Binary(trees) => {
if self.classes.len() == 1 {
output[0] = 1.0;
} else {
let positive = mean_tree_prediction(trees, row).clamp(0.0, 1.0);
output[0] = 1.0 - positive;
output[1] = positive;
}
}
Forest::Multiclass(trees) => average_class_probabilities(trees, row, output),
}
Ok(())
}
pub(crate) fn predict_proba_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
let columns = self.classes.len();
let expected = probability_output_len(data.rows(), columns)?;
check_prediction_data(data, output.len(), expected, self.n_features_in)?;
match &self.forest {
Forest::Binary(trees) => {
if columns == 1 {
output.fill(1.0);
return Ok(());
}
output.fill(0.0);
for tree in trees {
for (row, probabilities) in data.iter_rows().zip(output.chunks_exact_mut(2)) {
probabilities[1] += tree.predict(row);
}
}
for probabilities in output.chunks_exact_mut(2) {
let positive = (probabilities[1] / trees.len() as f32).clamp(0.0, 1.0);
probabilities[0] = 1.0 - positive;
probabilities[1] = positive;
}
}
Forest::Multiclass(trees) => {
output.fill(0.0);
for tree in trees {
for (row, probabilities) in
data.iter_rows().zip(output.chunks_exact_mut(columns))
{
for (slot, &value) in probabilities.iter_mut().zip(tree.probabilities(row))
{
*slot += value;
}
}
}
let divisor = trees.len() as f32;
for slot in output {
*slot = (*slot / divisor).clamp(0.0, 1.0);
}
}
}
Ok(())
}
pub(crate) fn predict_class_proba_one(
&self,
row: &[f32],
class: u8,
) -> Result<f32, ModelError> {
check_row(row, self.n_features_in)?;
let class_index = self.class_index(class)?;
match &self.forest {
Forest::Binary(trees) => {
if self.classes.len() == 1 {
return Ok(1.0);
}
let positive = mean_tree_prediction(trees, row).clamp(0.0, 1.0);
Ok(if class_index == 0 {
1.0 - positive
} else {
positive
})
}
Forest::Multiclass(trees) => {
let mut storage = [0.0_f32; MAX_CLASSES];
let probabilities = &mut storage[..self.classes.len()];
average_class_probabilities(trees, row, probabilities);
Ok(probabilities[class_index])
}
}
}
pub(crate) fn predict_class_proba_into(
&self,
data: &MatrixView<'_>,
class: u8,
output: &mut [f32],
) -> Result<(), ModelError> {
check_feature_width(data, self.n_features_in)?;
let class_index = self.class_index(class)?;
check_output_len(output.len(), data.rows())?;
match &self.forest {
Forest::Binary(_) => {
if self.classes.len() == 1 {
output.fill(1.0);
return Ok(());
}
self.accumulate_positive_into(data, output)?;
if class_index == 0 {
for slot in output {
*slot = 1.0 - *slot;
}
}
}
Forest::Multiclass(trees) => {
let mut storage = [0.0_f32; MAX_CLASSES];
let probabilities = &mut storage[..self.classes.len()];
for (row, slot) in data.iter_rows().zip(output) {
average_class_probabilities(trees, row, probabilities);
*slot = probabilities[class_index];
}
}
}
Ok(())
}
fn accumulate_positive_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
let Forest::Binary(trees) = &self.forest else {
unreachable!("the scalar accumulation serves the binary fit only");
};
check_prediction_data(data, output.len(), data.rows(), self.n_features_in)?;
output.fill(0.0);
for tree in trees {
for (row, slot) in data.iter_rows().zip(output.iter_mut()) {
*slot += tree.predict(row);
}
}
for slot in output {
*slot = (*slot / trees.len() as f32).clamp(0.0, 1.0);
}
Ok(())
}
#[inline]
fn class_index(&self, class: u8) -> Result<usize, ModelError> {
self.classes
.binary_search(&class)
.map_err(|_| ModelError::UnknownClass { class })
}
pub(crate) fn predict_positive_proba_one(&self, row: &[f32]) -> Result<f32, ModelError> {
let trees = self.require_binary_forest()?;
check_row(row, self.n_features_in)?;
if self.classes.len() == 1 {
return Ok(f32::from(self.classes[0]));
}
Ok(mean_tree_prediction(trees, row).clamp(0.0, 1.0))
}
pub(crate) fn predict_positive_proba(
&self,
data: &MatrixView<'_>,
) -> Result<Vec<f32>, ModelError> {
self.require_binary_forest()?;
check_prediction_data(data, data.rows(), data.rows(), self.n_features_in)?;
let mut output = vec![0.0; data.rows()];
self.predict_positive_proba_into(data, &mut output)?;
Ok(output)
}
pub(crate) fn predict_positive_proba_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
let trees = self.require_binary_forest()?;
check_prediction_data(data, output.len(), data.rows(), self.n_features_in)?;
if self.classes.len() == 1 {
output.fill(f32::from(self.classes[0]));
return Ok(());
}
for (index, slot) in output.iter_mut().enumerate() {
*slot = mean_tree_prediction(trees, data.row(index).expect("validated row index"))
.clamp(0.0, 1.0);
}
Ok(())
}
fn require_binary_forest(&self) -> Result<&[PackedTree], ModelError> {
match &self.forest {
Forest::Binary(trees) => Ok(trees),
Forest::Multiclass(_) => Err(ModelError::MulticlassOutput {
columns: self.classes.len(),
}),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct RegressorCore {
pub(crate) n_features_in: usize,
pub(crate) trees: Vec<PackedTree>,
}
impl RegressorCore {
pub(crate) fn predict_one(&self, row: &[f32]) -> Result<f32, ModelError> {
check_row(row, self.n_features_in)?;
validate_prediction(mean_tree_prediction(&self.trees, row), 0)
}
pub(crate) fn predict_into(
&self,
data: &MatrixView<'_>,
output: &mut [f32],
) -> Result<(), ModelError> {
check_prediction_data(data, output.len(), data.rows(), self.n_features_in)?;
for (index, slot) in output.iter_mut().enumerate() {
*slot = validate_prediction(
mean_tree_prediction(&self.trees, data.row(index).expect("validated row index")),
index,
)?;
}
Ok(())
}
}
pub(crate) fn mean_tree_prediction(trees: &[PackedTree], row: &[f32]) -> f32 {
let sum: f32 = trees.iter().map(|tree| tree.predict(row)).sum();
sum / trees.len() as f32
}
pub(crate) fn average_class_probabilities(trees: &[ClassTree], row: &[f32], output: &mut [f32]) {
debug_assert!(
trees
.first()
.is_none_or(|tree| tree.classes() == output.len())
);
output.fill(0.0);
for tree in trees {
for (slot, &value) in output.iter_mut().zip(tree.probabilities(row)) {
*slot += value;
}
}
let divisor = trees.len() as f32;
for slot in output {
*slot = (*slot / divisor).clamp(0.0, 1.0);
}
}
pub(crate) fn argmax(values: &[f32]) -> usize {
let mut best = 0;
for index in 1..values.len() {
if values[index] > values[best] {
best = index;
}
}
best
}
pub(crate) fn prediction_bound_is_finite(trees: &[PackedTree]) -> bool {
let mut bound = 0.0_f64;
for tree in trees {
bound += f64::from(tree.max_abs_leaf());
if !bound.is_finite() || bound > f64::from(f32::MAX) {
return false;
}
}
true
}
pub(crate) fn check_row(row: &[f32], expected: usize) -> Result<(), ModelError> {
if row.len() != expected {
return Err(ModelError::FeatureDimension {
expected,
actual: row.len(),
});
}
if let Some(column) = row.iter().position(|value| !value.is_finite()) {
return Err(ModelError::NonFiniteFeature { row: 0, column });
}
Ok(())
}
pub(crate) fn check_feature_width(
data: &MatrixView<'_>,
expected_features: usize,
) -> Result<(), ModelError> {
if data.columns() != expected_features {
return Err(ModelError::FeatureDimension {
expected: expected_features,
actual: data.columns(),
});
}
Ok(())
}
pub(crate) fn check_prediction_data(
data: &MatrixView<'_>,
output_len: usize,
expected_output_len: usize,
expected_features: usize,
) -> Result<(), ModelError> {
check_feature_width(data, expected_features)?;
check_output_len(output_len, expected_output_len)
}
pub(crate) fn check_output_len(actual: usize, expected: usize) -> Result<(), ModelError> {
if actual != expected {
return Err(ModelError::OutputLength { expected, actual });
}
Ok(())
}
pub(crate) fn probability_output_len(rows: usize, classes: usize) -> Result<usize, ModelError> {
rows.checked_mul(classes)
.ok_or(ModelError::OutputShapeOverflow {
rows,
columns: classes,
})
}
pub(crate) fn validate_common(
data: &MatrixView<'_>,
target_len: usize,
sample_weights: Option<&SampleWeights>,
config: &ForestConfig,
) -> Result<(), ModelError> {
if data.rows() == 0 || data.columns() == 0 {
return Err(ModelError::EmptyData);
}
if target_len != data.rows() {
return Err(ModelError::TargetLength {
rows: data.rows(),
targets: target_len,
});
}
if let Some(sample_weights) = sample_weights
&& data.rows() != sample_weights.len()
{
return Err(ModelError::SampleWeightLength {
rows: data.rows(),
weights: sample_weights.len(),
});
}
if config.n_estimators == 0 {
return Err(ModelError::InvalidEstimatorCount);
}
if config.grower.max_depth == Some(0) {
return Err(ModelError::InvalidMaxDepth);
}
if config.grower.min_samples_split < 2 {
return Err(ModelError::InvalidMinSamplesSplit);
}
if config.grower.min_samples_leaf == 0 {
return Err(ModelError::InvalidMinSamplesLeaf);
}
if config.n_jobs == 0 {
return Err(ModelError::InvalidJobCount);
}
if data.rows() > u32::MAX as usize {
return Err(ModelError::TooManyRows);
}
if data.columns() > FEATURE_MASK as usize {
return Err(ModelError::TooManyFeatures);
}
if let MaxFeatures::Count(requested) = config.grower.max_features
&& (requested == 0 || requested > data.columns())
{
return Err(ModelError::InvalidMaxFeatures {
requested,
available: data.columns(),
});
}
Ok(())
}