debot_ml 3.0.7

ML prediction
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

// src/lib.rs

#[cfg(feature = "classification")]
mod classifier;

mod regressor;

use debot_db::{ModelParams, SerializableModel};
use smartcore_proba::ensemble::random_forest_regressor::RandomForestRegressor;
use smartcore_proba::linalg::basic::arrays::Array2;
use smartcore_proba::linalg::basic::matrix::DenseMatrix;

#[cfg(feature = "classification")]
use classifier::ModelWithWeights;
#[cfg(feature = "classification")]
use smartcore_proba::ensemble::random_forest_classifier::RandomForestClassifier;

/// Unified RandomForest wrapper supporting classification and regression
pub struct RandomForest {
    model: RandomForestModel,
    #[cfg(feature = "classification")]
    /// Weights for expected-score calculation (loss, expired-profit, take-profit)
    weights: (f64, f64, f64),

    extra_regressors: [RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>>; 2],
}

impl RandomForest {
    /// Access classification weights
    #[cfg(feature = "classification")]
    pub fn weights(&self) -> (f64, f64, f64) {
        self.weights
    }

    /// Load model from storage (classification or regression)
    pub async fn new(key: &str, model_params: &ModelParams) -> Self {
        #[cfg(feature = "classification")]
        {
            let serial: SerializableModel = model_params
                .load_model(&format!("{}_0", key))
                .await
                .expect("Failed to load classifier model");

            let mw: ModelWithWeights = bincode::deserialize(&serial.model)
                .expect("Failed to deserialize ModelWithWeights");

            let extra_1: SerializableModel = model_params
                .load_model(&format!("{}_1", key))
                .await
                .expect("Failed to load regression model 1");
            let extra_2: SerializableModel = model_params
                .load_model(&format!("{}_2", key))
                .await
                .expect("Failed to load regression model 2");

            let reg1: RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>> =
                bincode::deserialize(&extra_1.model).unwrap();
            let reg2: RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>> =
                bincode::deserialize(&extra_2.model).unwrap();

            return RandomForest {
                model: RandomForestModel::Classifier(mw.model),
                weights: mw.weights,
                extra_regressors: [reg1, reg2],
            };
        }

        #[cfg(all(feature = "regression", not(feature = "classification")))]
        {
            let reg0: SerializableModel = model_params
                .load_model(&format!("{}_0", key))
                .await
                .expect("Failed to load regression model 0");
            let reg1: SerializableModel = model_params
                .load_model(&format!("{}_1", key))
                .await
                .expect("Failed to load regression model 1");
            let reg2: SerializableModel = model_params
                .load_model(&format!("{}_2", key))
                .await
                .expect("Failed to load regression model 2");

            let model: RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>> =
                bincode::deserialize(&reg0.model).unwrap();
            let extra_1: RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>> =
                bincode::deserialize(&reg1.model).unwrap();
            let extra_2: RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>> =
                bincode::deserialize(&reg2.model).unwrap();

            return RandomForest {
                model: RandomForestModel::Regressor(model),
                extra_regressors: [extra_1, extra_2],
            };
        }

        #[cfg(not(any(feature = "classification", feature = "regression")))]
        panic!("Either 'classification' or 'regression' feature must be enabled");
    }

    /// Predict raw outputs: class labels (as f64) or continuous values
    pub fn predict(&self, x: &DenseMatrix<f64>) -> Vec<f64> {
        match &self.model {
            #[cfg(feature = "classification")]
            RandomForestModel::Classifier(clf) => clf
                .predict(x)
                .unwrap()
                .into_iter()
                .map(|v| v as f64)
                .collect(),

            #[cfg(feature = "regression")]
            RandomForestModel::Regressor(reg) => reg.predict(x).unwrap(),

            #[allow(unreachable_patterns)]
            _ => unreachable!(),
        }
    }

    /// For classification: predict probabilities and compute expected score
    #[cfg(feature = "classification")]
    pub fn predict_proba(&self, x: &DenseMatrix<f64>) -> (DenseMatrix<f64>, f64) {
        let clf = match &self.model {
            RandomForestModel::Classifier(clf) => clf,
            #[cfg(feature = "regression")]
            RandomForestModel::Regressor(_) => unreachable!("predict_proba on regression model"),
        };
        let probs: DenseMatrix<f64> = clf.predict_proba(x).unwrap();
        log::trace!("Predicted probabilities: {:?}", probs);
        let row = probs.get_row(0).iterator(0).copied().collect::<Vec<f64>>();
        let (w0, w1, w2) = self.weights;
        let exp_score = w0 * row[0] + w1 * row[1] + w2 * row[2];
        (probs, exp_score)
    }

    /// Predict timeout durations from extra regressors
    pub fn predict_timeout(&self, x: &DenseMatrix<f64>) -> (f64, f64) {
        let pred1 = self.extra_regressors[0].predict(x).unwrap();
        let pred2 = self.extra_regressors[1].predict(x).unwrap();
        (pred1[0], pred2[0])
    }
}

/// Enum of underlying model variants
pub enum RandomForestModel {
    #[cfg(feature = "classification")]
    Classifier(RandomForestClassifier<f64, i32, DenseMatrix<f64>, Vec<i32>>),

    #[cfg(feature = "regression")]
    Regressor(RandomForestRegressor<f64, f64, DenseMatrix<f64>, Vec<f64>>),
}

// Re-export training functions
#[cfg(feature = "classification")]
pub use classifier::grid_search_and_train_classifier;
#[cfg(feature = "classification")]
pub use classifier::Metric::*;

pub use regressor::grid_search_and_train_regressor;