correlation_score + fmt

server/src/services/analytic_service/analytic_service.rs

@@ -174,7 +174,7 @@ impl AnalyticService {
             }
         };
     }
-    
+
     // TODO: maybe make `consume_response` async
     fn consume_response(&mut self, res: types::ResponseType) {
         match res {
@@ -219,9 +219,9 @@ impl AnalyticService {
         self.analytic_unit_config = new_conf;
         if need_learning {
             self.consume_request(RequestType::RunLearning);
-            // TODO: it's not fullu correct: we need to wait when the learning starts 
+            // TODO: it's not fullu correct: we need to wait when the learning starts
             match tx.send(()) {
-                Ok(_) => {},
+                Ok(_) => {}
                 Err(_e) => {
                     println!("Can`t send patch config notification");
                 }
@@ -234,7 +234,7 @@ impl AnalyticService {
                     async move {
                         au.unwrap().write().await.set_config(cfg);
                         match tx.send(()) {
-                            Ok(_) => {},
+                            Ok(_) => {}
                             Err(_e) => {
                                 println!("Can`t send patch config notification");
                             }
@@ -243,7 +243,7 @@ impl AnalyticService {
                 });
             } else {
                 match tx.send(()) {
-                    Ok(_) => {},
+                    Ok(_) => {}
                     Err(_e) => {
                         println!("Can`t send patch config notification");
                     }

server/src/services/analytic_service/analytic_unit/pattern_analytic_unit.rs

@@ -182,7 +182,6 @@ impl PatternAnalyticUnit {
 
 #[async_trait]
 impl AnalyticUnit for PatternAnalyticUnit {
-
     fn set_config(&mut self, config: AnalyticUnitConfig) {
         if let AnalyticUnitConfig::Pattern(cfg) = config {
             self.config = cfg;
@@ -363,21 +362,21 @@ impl AnalyticUnit for PatternAnalyticUnit {
                 }
             }
 
-            {
+            let model_positive = {
                 let mut backet = Vec::<f64>::new();
                 for j in 0..pattern_match_len {
                     backet.push(nan_to_zero(ts[i + j].1));
                 }
                 let fs = PatternAnalyticUnit::get_features(&backet);
-                let detected = lr.model.lock().predict(Array::from_vec(fs.to_vec()));
+                lr.model.lock().predict(Array::from_vec(fs.to_vec()))
-                if detected {
+            };
-                    pattern_match_score += self.config.model_score;
-                }
-            }
 
-            if pattern_match_score - anti_pattern_match_score * self.config.anti_correlation_score
+            let mut score = pattern_match_score * self.config.correlation_score;
-                >= self.config.threshold_score
+            score -= anti_pattern_match_score * self.config.anti_correlation_score;
-            {
+            if model_positive {
+                score += self.config.model_score;
+            }
+            if score >= self.config.threshold_score {
                 results.push((ts[i].0, ts[i + pattern_match_len - 1].0));
             }
         }

server/src/services/analytic_service/analytic_unit/threshold_analytic_unit.rs

@@ -17,7 +17,6 @@ impl ThresholdAnalyticUnit {
     pub fn new(config: ThresholdConfig) -> ThresholdAnalyticUnit {
         ThresholdAnalyticUnit { config }
     }
-    
 }
 
 #[async_trait]