use serde::{Deserialize, Serialize};
use crate::fixed_point::FixedPoint;
#[cfg(feature = "std")]
use alloc::format;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;
#[cfg(not(feature = "std"))]
use alloc::vec;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TreeNode {
Split {
feature_index: usize,
threshold: FixedPoint,
left: usize,
right: usize,
},
Leaf {
value: FixedPoint,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DecisionTree {
pub nodes: Vec<TreeNode>,
pub num_features: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogisticRegression {
pub weights: Vec<FixedPoint>,
pub bias: FixedPoint,
pub decision_threshold: FixedPoint,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DenseLayer {
pub weights: Vec<FixedPoint>,
pub biases: Vec<FixedPoint>,
pub input_size: usize,
pub output_size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TinyMLP {
pub layers: Vec<DenseLayer>,
}
impl TinyMLP {
pub fn validate(&self) -> Result<(), crate::error::ZkmlError> {
if self.layers.is_empty() {
return Err(crate::error::ZkmlError::InvalidModel(
"TinyMLP must have at least one layer".into(),
));
}
for layer in self.layers.iter() {
let expected_weights = layer.input_size.saturating_mul(layer.output_size);
if layer.weights.len() != expected_weights {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"expected {expected_weights} weights, got {}",
layer.weights.len()
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"layer weight count mismatch".into(),
));
}
if layer.biases.len() != layer.output_size {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"expected {} biases, got {}",
layer.output_size,
layer.biases.len()
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"layer bias count mismatch".into(),
));
}
}
for i in 0..self.layers.len().saturating_sub(1) {
let out = self.layers[i].output_size;
let next_in = self.layers[i + 1].input_size;
if out != next_in {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"layer {i} output_size {out} does not match layer {} input_size {next_in}",
i + 1
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"layer size mismatch".into(),
));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Model {
DecisionTree(DecisionTree),
LogisticRegression(LogisticRegression),
TinyMLP(TinyMLP),
}
impl DecisionTree {
pub fn validate(&self) -> Result<(), crate::error::ZkmlError> {
for (i, node) in self.nodes.iter().enumerate() {
if let TreeNode::Split {
feature_index,
left,
right,
..
} = node
{
if *feature_index >= self.num_features {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"node {i}: feature index {} out of range",
feature_index
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"feature index out of range".into(),
));
}
if *left >= self.nodes.len() || *right >= self.nodes.len() {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"node {i}: child index out of range"
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"child index out of range".into(),
));
}
if *left == i || *right == i {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"node {i}: split points to itself"
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"self-referential split".into(),
));
}
}
}
if self.nodes.is_empty() {
return Err(crate::error::ZkmlError::InvalidModel(
"decision tree has no nodes".into(),
));
}
let mut visited = vec![false; self.nodes.len()];
let mut stack = vec![(0usize, 0usize)];
while let Some((node_idx, depth)) = stack.pop() {
const MAX_DEPTH: usize = 1000;
if depth > MAX_DEPTH {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"tree depth exceeds maximum of {MAX_DEPTH}"
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"tree depth exceeds maximum".into(),
));
}
if visited[node_idx] {
#[cfg(feature = "std")]
return Err(crate::error::ZkmlError::InvalidModel(format!(
"node {node_idx}: cycle detected (node visited twice)"
)));
#[cfg(not(feature = "std"))]
return Err(crate::error::ZkmlError::InvalidModel(
"cycle detected".into(),
));
}
visited[node_idx] = true;
match &self.nodes[node_idx] {
TreeNode::Split { left, right, .. } => {
stack.push((*left, depth + 1));
stack.push((*right, depth + 1));
}
TreeNode::Leaf { .. } => {
}
}
}
for was_visited in visited.iter() {
if !was_visited {
return Err(crate::error::ZkmlError::InvalidModel(
"orphan node detected".into(),
));
}
}
Ok(())
}
}
impl LogisticRegression {
pub fn num_features(&self) -> usize {
self.weights.len()
}
}
#[cfg(test)]
#[cfg(feature = "std")]
mod tests {
use super::*;
use crate::fixed_point::FixedPoint;
#[test]
fn valid_tree_passes() {
let tree = DecisionTree {
num_features: 1,
nodes: vec![
TreeNode::Split {
feature_index: 0,
threshold: FixedPoint::quantize(0.5),
left: 1,
right: 2,
},
TreeNode::Leaf {
value: FixedPoint::quantize(0.0),
},
TreeNode::Leaf {
value: FixedPoint::quantize(1.0),
},
],
};
assert!(tree.validate().is_ok());
}
#[test]
fn out_of_range_child_fails() {
let tree = DecisionTree {
num_features: 1,
nodes: vec![TreeNode::Split {
feature_index: 0,
threshold: FixedPoint::quantize(0.5),
left: 9,
right: 2,
}],
};
assert!(tree.validate().is_err());
}
}
impl Model {
pub fn num_features(&self) -> usize {
match self {
Model::DecisionTree(t) => t.num_features,
Model::LogisticRegression(lr) => lr.weights.len(),
Model::TinyMLP(m) => m.layers.first().map(|l| l.input_size).unwrap_or(0),
}
}
}
#[cfg(test)]
#[cfg(feature = "std")]
mod tests_features {
use super::*;
use crate::fixed_point::FixedPoint;
#[test]
fn logistic_feature_count() {
let model = Model::LogisticRegression(LogisticRegression {
weights: vec![FixedPoint::quantize(0.1); 5],
bias: FixedPoint::quantize(0.0),
decision_threshold: FixedPoint::quantize(0.0),
});
assert_eq!(model.num_features(), 5);
}
}