Merge branch 'develop' into feat/thresholded_relu

docgen/src/main.rs

@@ -42,6 +42,22 @@ fn main() {
     let trait_name: &str = "TreeRegressorTrait";
     doc_trait(trait_path, doc_path, label);
     doc_functions(trait_path, doc_path, trait_name, label);
+
+    // TREE ClASSIFIER DOC
+    let trait_path = "src/operators/ml/tree_classifier/core.cairo";
+    let doc_path = "docs/framework/operators/machine-learning/tree-classifier";
+    let label = "tree";
+    let trait_name: &str = "TreeClassifierTrait";
+    doc_trait(trait_path, doc_path, label);
+    doc_functions(trait_path, doc_path, trait_name, label);
+
+    // XGBOOST REGRESSOR DOC
+    let trait_path = "src/operators/ml/xgboost_regressor/core.cairo";
+    let doc_path = "docs/framework/operators/machine-learning/xgboost-regressor";
+    let label = "xgboost";
+    let trait_name: &str = "XGBoostRegressorTrait";
+    doc_trait(trait_path, doc_path, label);
+    doc_functions(trait_path, doc_path, trait_name, label);
 }
 
 fn doc_trait(trait_path: &str, doc_path: &str, label: &str) {

docs/SUMMARY.md

@@ -97,8 +97,12 @@
     * [nn.linear](framework/operators/neural-network/nn.linear.md)
   * [Machine Learning](framework/operators/machine-learning/README.md)
     * [Tree Regressor](framework/operators/machine-learning/tree-regressor/README.md)
-      * [tree.fit](framework/operators/machine-learning/tree-regressor/tree.fit.md)
       * [tree.predict](framework/operators/machine-learning/tree-regressor/tree.predict.md)
+    * [Tree Classifier](framework/operators/machine-learning/tree-classifier/README.md)
+      * [tree.predict](framework/operators/machine-learning/tree-classifier/tree.predict.md)
+      * [tree.predict_proba](framework/operators/machine-learning/tree-classifier/tree.predict_proba.md)
+    * [XGBoost Regressor](framework/operators/machine-learning/xgboost-regressor/README.md)
+      * [xgboost.predict](framework/operators/machine-learning/xgboost-regressor/xgboost.predict.md)
 
 ## 🏛 Hub
 

docs/framework/operators/machine-learning/tree-classifier/README.md

@@ -0,0 +1,23 @@
+# Tree Classifier
+
+`TreeClassifierTrait` provides a trait definition for decision tree classifier. This trait offers functionalities to build a decision tree and predict target values based on input features.
+
+```rust
+use orion::operators::ml::TreeClassifierTrait;
+```
+
+### Data types
+
+Orion supports currently only fixed point data types for `TreeClassifierTrait`.
+
+| Data type            | dtype                                                         |
+| -------------------- | ------------------------------------------------------------- |
+| Fixed point (signed) | `TreeClassifierTrait<FP8x23 \| FP16x16 \| FP64x64 \| FP32x32>` |
+
+***
+
+| function | description |
+| --- | --- |
+| [`tree.predict`](tree.predict.md) | Given a set of features, predicts the target value using the constructed decision tree. |
+| [`tree.predict_proba`](tree.predict\_proba.md) | Predicts class probabilities based on feature data. |
+

docs/framework/operators/machine-learning/tree-classifier/tree.predict.md

@@ -0,0 +1,35 @@
+# TreeClassifierTrait::predict
+
+```rust 
+   fn predict(ref self: TreeClassifier<T>, features: Span<T>) -> T;
+```
+
+Predicts the target value for a set of features using the provided decision tree.
+
+## Args
+
+* `self`: A reference to the decision tree used for making the prediction.
+* `features`: A span representing the features for which the prediction is to be made.
+
+## Returns
+
+The predicted target value.
+
+## Type Constraints
+
+Constrain input and output types to fixed point.
+
+## Examples
+
+```rust
+use orion::operators::ml::{FP16x16TreeClassifier, TreeClassifierTrait, TreeClassifier};
+use orion::numbers::{FP16x16, FixedTrait};
+
+fn tree_classifier_example(tree: TreeClassifier<FP16x16>) {
+
+ tree.predict(
+       array![FixedTrait::new_unscaled(1, false), FixedTrait::new_unscaled(2, false),].span()
+   );
+
+}
+```

docs/framework/operators/machine-learning/tree-classifier/tree.predict_proba.md

@@ -0,0 +1,38 @@
+# TreeClassifierTrait::predict_proba
+
+```rust 
+   fn predict_proba(ref self: TreeClassifier<T>, features: Span<T>) -> Span<T>;
+```
+
+Given a set of features, this method traverses the decision tree
+represented by `self` and returns the class distribution (probabilities)
+found in the leaf node that matches the provided features. The traversal
+stops once a leaf node is reached in the decision tree.
+
+## Args
+
+* `self`: A reference to the decision tree used for making the prediction.
+* `features`: A span representing the features for which the prediction is to be made.
+
+## Returns
+
+Returns a `Span<T>` representing the class distribution at the leaf node.
+
+## Type Constraints
+
+Constrain input and output types to fixed points.
+
+## Examples
+
+```rust
+use orion::operators::ml::{FP16x16TreeClassifier, TreeClassifierTrait, TreeClassifier};
+use orion::numbers::{FP16x16, FixedTrait};
+
+fn tree_classifier_example(tree: TreeClassifier<FP16x16>) {
+
+ tree.predict_proba(
+       array![FixedTrait::new_unscaled(1, false), FixedTrait::new_unscaled(2, false),].span()
+   );
+
+}
+```

docs/framework/operators/machine-learning/tree-regressor/README.md

@@ -18,6 +18,5 @@ Orion supports currently only fixed point data types for `TreeRegressorTrait`.
 
 | function | description |
 | --- | --- |
-| [`tree.fit`](tree.fit.md) | Constructs a decision tree regressor based on the provided data and target values. |
 | [`tree.predict`](tree.predict.md) | Given a set of features, predicts the target value using the constructed decision tree. |
 

docs/framework/operators/machine-learning/tree-regressor/tree.predict.md

@@ -1,7 +1,7 @@
 # TreeRegressorTrait::predict
 
 ```rust 
-   fn predict(ref self: TreeNode<T>, features: Span<T>) -> T;
+   fn predict(ref self: TreeRegressor<T>, features: Span<T>) -> T;
 ```
 
 Predicts the target value for a set of features using the provided decision tree.
@@ -17,37 +17,19 @@ The predicted target value.
 
 ## Type Constraints
 
-Constrain input and output types to fixed point tensors.
+Constrain input and output types to fixed point.
 
 ## Examples
 
 ```rust
-use orion::operators::ml::{FP16x16TreeRegressor, TreeRegressorTrait};
+use orion::operators::ml::{FP16x16TreeRegressor, TreeRegressorTrait, TreeRegressor};
 use orion::numbers::{FP16x16, FixedTrait};
 
-fn tree_regressor_example() {
+fn tree_regressor_example(tree: TreeRegressor<FP16x16>) {
 
- let data = array![
-     array![FixedTrait::new_unscaled(1, false), FixedTrait::new_unscaled(2, false)].span(),
-     array![FixedTrait::new_unscaled(3, false), FixedTrait::new_unscaled(4, false)].span(),
-     array![FixedTrait::new_unscaled(5, false), FixedTrait::new_unscaled(6, false)].span(),
-     array![FixedTrait::new_unscaled(7, false), FixedTrait::new_unscaled(8, false)].span(),
- ]
-     .span();
-
- let target = array![
-     FixedTrait::new_unscaled(2, false),
-     FixedTrait::new_unscaled(4, false),
-     FixedTrait::new_unscaled(6, false),
-     FixedTrait::new_unscaled(8, false)
- ]
-     .span();
-
- let mut tree = TreeRegressorTrait::fit(data, target, 3);
-
- let prediction_1 = tree
-   .predict(
+ tree.predict(
        array![FixedTrait::new_unscaled(1, false), FixedTrait::new_unscaled(2, false),].span()
    );
+
 }
 ```

docs/framework/operators/machine-learning/xgboost-regressor/README.md

@@ -0,0 +1,22 @@
+# Tree Regressor
+
+`XGBoostRegressorTrait` provides a trait definition for xgboost regression. This trait offers functionalities to predict target values based on input features.
+
+```rust
+use orion::operators::ml::XGBoostRegressorTrait;
+```
+
+### Data types
+
+Orion supports currently only fixed point data types for `XGBoostRegressorTrait`.
+
+| Data type            | dtype                                                         |
+| -------------------- | ------------------------------------------------------------- |
+| Fixed point (signed) | `TreeRegressorTrait<FP8x23 \| FP16x16 \| FP64x64 \| FP32x32>` |
+
+***
+
+| function | description |
+| --- | --- |
+| [`xgboost.predict`](xgboost.predict.md) | Predicts the target value for a set of features using the provided ensemble of decision trees. |
+

docs/framework/operators/machine-learning/xgboost-regressor/xgboost.predict.md

@@ -0,0 +1,44 @@
+# XGBoostRegressorTrait::predict
+
+```rust 
+   fn predict(ref self: Span<TreeNode<T>>, ref features: Span<T>, ref weights: Span<T>) -> T;
+```
+
+Predicts the target value for a set of features using the provided ensemble of decision trees
+and combining their results using given weights.
+
+## Args
+
+* `self`: A reference to a span representing a ensemble of decision trees.
+* `features`:  A reference to a span representing the features for which the prediction is to be made.
+* `weights`:  A reference to a span representing the weights applied to the predictions from each tree.
+
+## Returns
+
+The predicted target value.
+
+## Type Constraints
+
+Constrain input and output types to fixed point.
+
+## Examples
+
+```rust
+use orion::operators::ml::{FP16x16XGBoostRegressor, TreeRegressorTrait, TreeRegressor};
+use orion::numbers::{FP16x16, FixedTrait};
+
+fn xgboost_regressor_example(trees: Span<TreeRegressor<FP16x16>>) {
+
+    let mut features =  array![
+        FixedTrait::new_unscaled(1, false), 
+        FixedTrait::new_unscaled(2, false),
+    ].span();
+
+    let mut weights = array![
+        FixedTrait::new_unscaled(0.5, false),
+        FixedTrait::new_unscaled(0.5, false)
+    ].span();
+
+    FP16x16XGBoostRegressor::predict(ref trees, ref features, ref weights);
+}
+```