AbstractIntegratedModule 1.2.3__tar.gz → 1.2.4__tar.gz

{abstractintegratedmodule-1.2.3 → abstractintegratedmodule-1.2.4}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.2.3
+Version: 1.2.4
 Summary: Integrated Pipeline with Specialized Non-LLM AI Agent Framework for ARM64 architecture
 Author: Micro-Novelty
 Author-email: Micro-Novelty <hernikpuspita5@gmail.com>

{abstractintegratedmodule-1.2.3 → abstractintegratedmodule-1.2.4}/AbstractIntegratedModule.py

@@ -3796,7 +3796,9 @@ class MLP:
             return y_pred, y_true
 
     
-    def train(self, X, y, epochs=1000, lr=0.01, verbose=True, max_samples_for_focused_fit=500):
+    def train(self, X, y, X_val=None, y_val=None, epochs=1000, lr=0.01, verbose=True, max_samples_for_focused_fit=500):
+        y_val_pred = None
+        y_val_true = None
         X = self._sanitize_string_chars(X)
         y = self._sanitize_string_chars(y)
         parameters = sum(w.size for w in self.layers[0].W) + sum(b.size for b in self.layers[0].b)
@@ -3814,6 +3816,10 @@ class MLP:
         else:
             print(f'[+] MLP Training started with: {parameters} Parameters.')
             for epoch in range(epochs):
+                if X_val is not None and y_val is not None:
+                    y_val_pred = self.forward(X_val, y=y_val, AME=AME, anisotropy=anisotropy, condition='training')
+                    y_val_pred, y_val_true = self.adapt_predict_shape(y_val_pred, y_val)
+
                 y_pred = self.forward(X, y=y, AME=AME, anisotropy=anisotropy, condition='training')
                 y_pred, y_true = self.adapt_predict_shape(y_pred, y)
                 
@@ -3823,16 +3829,16 @@ class MLP:
                 try:
                     params = self.layers[0].opt.step(self.layers[0].params, key_grads, clip_norm=5.0)
                 except Exception as e:
-                    print(f'[>] AdamOptimizer failed: {e}')
+                    print(f'[>] AdamOptimizer error occured: {e}')
                     continue
                 
-                if np.isnan(loss) or np.isinf(loss):
-                    if focused_fit_condition:
-                        focused_fit_condition = False
-                
                 if verbose and epoch % 100 == 0:
                     acc = np.mean(np.argmax(y_pred, axis=1) == np.argmax(y_true, axis=1))
-                    print(f"[=] Epoch {epoch} | Loss: {loss:.4f} | Acc: {acc:.2f}")
+                    if y_val_pred is not None and y_val_true is not None:
+                        val_acc = np.mean(np.argmax(y_val_pred, axis=1) == np.argmax(y_val_true, axis=1))
+                        print(f"[=] Epoch {epoch} | Loss: {loss:.4f} | Acc: {acc:.2f} | Validation Acc: {val_acc:.2f}")
+                    else:
+                        print(f"[=] Epoch {epoch} | Loss: {loss:.4f} | Acc: {acc:.2f}")
               
 # ─────────────────────────────────────────────
 #  LSTM Cell
@@ -15422,7 +15428,7 @@ class IntegratedPipeline:
         return True, (f'n={n_samples}, T={T}, anisotropy={anisotropy:.4f} — '
                     f'sufficient structure and data to justify Transformer training')
 
-    def transformer_utilities(self, X_provided= None, X_raw=None, y_true=None, rules=None, 
+    def transformer_utilities(self, X_val=None, y_val=None, X_provided= None, X_raw=None, y_true=None, rules=None, 
                               datasets=None, label_map=None, batch_size=2, min_signal=1e-3,
                               max_samples_for_focused_fit=500, max_ram_used=80):
         unsuitable = False
@@ -15618,7 +15624,7 @@ class IntegratedPipeline:
             self.initialize_model_(X, input_dim, n_classes)
 
             if not unsuitable:
-                self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=self.mlp_lr, max_samples_for_focused_fit=max_samples_for_focused_fit)
+                self.model3.train(X, y, X_val=X_val, y_val=y_val, epochs=self.mlp_training_epochs, lr=self.mlp_lr, max_samples_for_focused_fit=max_samples_for_focused_fit)
             else:
                 print('[->] MLP Training skipped due to unproper Y samples.')
 
@@ -15861,8 +15867,8 @@ class AccurateAnswerCache:
                     if min_len > 0:
                         seq_sim = float(np.mean(ids_a[:min_len] == ids_b[:min_len]))
 
-                combined_env_sim = ((mlp_sim + seq_sim) / 2) * anisotropy
-                deterministic_modelling_sim = ((mlp_sim + seq_sim) / 2) * AME 
+                combined_env_sim = ((mlp_sim + seq_sim) / 2 * anisotropy) 
+                deterministic_modelling_sim = ((mlp_sim + seq_sim) / 2 * AME)  
 
                 combinatorial_absolute_factor = (
                     deterministic_modelling_sim > best_combined_sim and 
@@ -18805,21 +18811,26 @@ def mc_confidence(net, encoder, x, n_samples=20, temperature=1.0,
 # Printing
 # ----------------------------------------------------------------------
  
-def print_confidence_report(results, top_k=3):
-    """Human-readable printout for a list of dicts from
+def print_confidence_report(results, top_k=3, max_print_threshold=50):
+    """readable printout for a list of dicts from
     predict_with_confidence() or mc_confidence()."""
+    pred_cache = []
     for i, r in enumerate(results):
         order = np.argsort(-r["probs"])[:top_k]
         top_str = ", ".join(f"{cls}:{r['probs'][cls]*100:.1f}%" for cls in order)
         std_str = f"  (±{r['confidence_std']*100:.1f}%)" if "confidence_std" in r else ""
-        print(f"[>] Sample {i:3d} -> predicted={r['pred_name']}  "
-              f"|| Confidence={r['confidence']*100:.1f}%{std_str}  "
-              f"|| Entropy={r['entropy_frac']*100:.0f}%  "
-              f"|| Top-{top_k}: [{top_str}]")
+        pred_cache.append(r['pred_name'])
+        if i <= max_print_threshold:
+            print(f"[>] Sample {i:3d} -> predicted={r['pred_name']}  "
+                f"|| Confidence={r['confidence']*100:.1f}%{std_str}  "
+                f"|| Entropy={r['entropy_frac']*100:.0f}%  "
+                f"|| Top-{top_k}: [{top_str}]")
+    return pred_cache
 
 
 
-def train_snn_network(X=None, y=None, epochs=50, batch_size=32, n_steps=20, 
+def train_snn_network(X=None, y=None, net=None, hidden_layer=None, 
+         epochs=50, batch_size=32, n_steps=20, 
          n_hidden=64, lr=2e-3, seed=0, pretrain_steps=200, unsupervised_stdp=False,
          random_state=42):
     tracker = DiagnosticsTracker()
@@ -18830,8 +18841,9 @@ def train_snn_network(X=None, y=None, epochs=50, batch_size=32, n_steps=20,
     X_train, X_test, y_train, y_test, _, _ = _prepare_train_val_split(X=X, y=y, random_state=random_state)
     n_in = X_train.shape[1]
     n_classes = int(y_train.max() + 1)
+    if net is None and hidden_layer is None:
+        net, hidden_layer = build_snn_network(n_in, n_hidden, n_classes, rng)
 
-    net, hidden_layer = build_snn_network(n_in, n_hidden, n_classes, rng)
     encoder = PoissonEncoder(n_steps=n_steps, max_rate=1.0, rng=rng)
     optimizer = Adam(lr=lr, weight_decay=1e-5)
     homeostasis = ThresholdHomeostasis(target_rate=0.15, adjust_rate=0.05)
@@ -18887,7 +18899,7 @@ def train_snn_network(X=None, y=None, epochs=50, batch_size=32, n_steps=20,
     return encoder, net, report, warnings
 
 
-def snn_predict(X=None, y=None, label_map=None, encoder=None, net=None, random_state=42):
+def snn_predict(X=None, y=None, label_map=None, encoder=None, net=None, random_state=42, max_print_threshold=50):
     utility = SNNUtility()
     reverse_map = None
 
@@ -18925,9 +18937,10 @@ def snn_predict(X=None, y=None, label_map=None, encoder=None, net=None, random_s
         test_spikes = encoder.encode(X)
         preds, logits = net.predict(test_spikes)
         if reverse_map is not None:
-            # 3. SNN-specific: uncertainty from the encoder's own stochasticity
+            # SNN-specific: uncertainty from the encoder's own stochasticity
             mc_results = mc_confidence(net, encoder, X, n_samples=20, class_names=reverse_map)
-            print_confidence_report(mc_results) 
+            print(f'[>] Displaying {max_print_threshold} predictions over {len(X)} samples...')
+            _ = print_confidence_report(mc_results, max_print_threshold=max_print_threshold) 
         else:
             print('[>] Label map is Missing during SNN prediction, returning SNN Logits as is without any label mapping...')
     except Exception as e:
@@ -20100,7 +20113,7 @@ class PipelinePredictionManager:
             # max: catches localized single-class failure
             # that a flat average would dilute away
             worst_class_idx = int(np.argmax(error_counts))
-            max_error = float(error_counts[worst_class_idx])
+            max_error = error_counts[worst_class_idx]
             if max_error > error_threshold:
                 signals.append(f'error_rate(class={worst_class_idx}, '
                             f'value={max_error:.2f})')
@@ -20158,6 +20171,35 @@ class PipelinePredictionManager:
         print(f'[+] Transformer Prediction allowed: {propriate_single_transformer}')
         return propriate_single_transformer
 
+    def _get_voted_results(self, probs, reverse_map, n_samples):
+        pred_cache = []
+        _cache = {}
+        cache = []
+        for i in range(n_samples):
+            try:
+                each_idx = probs[i].argmax()
+            except:
+                each_idx = np.argmax(probs[:len(reverse_map)-1])
+            try:
+                confidence = float(probs[each_idx])   
+            except:
+                confidence = float(probs[i][len(reverse_map)-1]) if isinstance(probs[i], (float, int)) else 0.0
+            
+            pred_cache.append(each_idx)
+            _cache[i] = (each_idx, confidence)
+            
+        voted_chosen_label = max(set(pred_cache), key=pred_cache.count)
+        conf_cache = []
+        for i in range(len(_cache)):
+            if _cache[i][0] == voted_chosen_label:
+                confidence = _cache[i][1] 
+                conf_cache.append(confidence)
+
+        float_counts = Counter(conf_cache)
+        voted_confidence, _ = float_counts.most_common(1)[0]      
+
+        return voted_chosen_label, voted_confidence
+
 
     def advanced_prediction_method(self, titles=None, label_map=None, rules=None,
                                 X=None, y=None,
@@ -20207,7 +20249,6 @@ class PipelinePredictionManager:
             self.pipeline.titles = titles
             self.pipeline.labels = label_map
 
-            
             if X is not None and y is not None:
                 print(f"[🔍] Processing X and y samples for prediction and Training...")
                 if isinstance(X, (str, np.str_)):
@@ -20230,7 +20271,6 @@ class PipelinePredictionManager:
                             (x for x in clean_str.split() if x != "..."), dtype=float
                         )
                 
-
                 if len(X) < 5:
                     print(f"[⚠️] Warning: Only {len(X)} samples provided. Consider providing more samples for better prediction accuracy!")
 
@@ -20733,9 +20773,41 @@ class PipelinePredictionManager:
             if float(results[0]['confidence']) < self.pipeline.confidence_threshold:
                 verbose = True
 
-            chosen_label = results[0].get('predicted') if results else None
-            confidence = results[0].get('confidence') if results else 0.0
-            if chosen_label is None:
+            prediction_cache = []
+            confidence_cache = {}
+            agreement_cache = {}
+            _cache = []
+
+            for i in range(len(results)):
+                each_label = results[i].get('predicted') if results else 'Unknown'
+                each_confidence = results[i].get('confidence') if results else 0.0
+                each_agreement = results[i].get('models_agree') if results else False
+
+                prediction_cache.append(each_label)
+                confidence_cache[i] = (each_label, each_confidence)
+                agreement_cache[i] = (each_label, each_agreement)
+
+            voted_chosen_label = max(set(prediction_cache), key=prediction_cache.count)
+            conf_cache = []
+            for i in range(len(confidence_cache)):
+                if confidence_cache[i][0] == voted_chosen_label:
+                    confidence = confidence_cache[i][1] 
+                    conf_cache.append(confidence)
+
+            float_counts = Counter(conf_cache)
+            voted_confidence, _ = float_counts.most_common(1)[0]  
+
+            voted_agreement = []
+            for i in range(len(agreement_cache)):
+                if agreement_cache[i][0] == voted_chosen_label:
+                    get_agreement = agreement_cache[i][1] 
+                    voted_agreement.append(get_agreement)
+
+            counts = Counter(voted_agreement)
+            agreement_counts = counts[True]
+            models_agreement = agreement_counts > counts[False]
+
+            if not isinstance(voted_chosen_label, str):
                 for i in range(num_classes):
                     mlp_class_idx = int(mlp_pred_indices[i])
                     is_valid_index = 0 <= mlp_class_idx < num_classes
@@ -20760,26 +20832,27 @@ class PipelinePredictionManager:
                         'is_valid'   : True,
                     })
                 
-                chosen_label = results[0].get('predicted') if results else None
-                confidence = results[0].get('confidence') if results else 0.0
+                voted_chosen_label = results[0].get('predicted') if results else None
+                voted_confidence = results[0].get('confidence') if results else 0.0
 
-            if isinstance(chosen_label, int) or isinstance(chosen_label, np.integer):
-                chosen_label = str(chosen_label)
+            if isinstance(voted_chosen_label, int) or isinstance(voted_chosen_label, np.integer):
+                voted_chosen_label = str(voted_chosen_label)
                 
-            if isinstance(confidence, (np.ndarray, list)):
-                confidence = np.mean(confidence)
+            if isinstance(voted_confidence, (np.ndarray, list)):
+                voted_confidence = np.mean(voted_confidence)
 
-            return_single_condition = (
-                not self.pipeline.use_transformer or
-                not need_ensemble_method 
-
-            )
-            if return_single_condition:
-                print('[=] Displaying Results....')
+            if not need_ensemble_method:
+                print('[=] Getting Results...')
                 if not results[0].get('models_agree', True) and self.pipeline.use_transformer:
-                    trans_confidence = results[0].get('trans_confidence', 1e-8)
-                    confidence = (confidence + trans_confidence / 2) + 1e-5
-                    print(f'[=] Calibrating confidence around: {confidence:.1%}')
+                    trans_conf_cache = []
+                    for i in range(len(results)):
+                        trans_confidence = results[i].get('trans_confidence', 1e-8)
+                        trans_conf_cache.append(trans_confidence)
+                    
+                    trans_counts = Counter(trans_conf_cache)
+                    trans_confidence, _ = trans_counts.most_common(1)[0]
+                    confidence = (voted_confidence + trans_confidence / 2) + 1e-5
+                    print(f'[=] Calibrating confidence around frequent Transformer confidence distributions: {confidence:.1%}')
                     
                 payload = {
                     'X_samples': X,
@@ -20789,46 +20862,40 @@ class PipelinePredictionManager:
                 if titles is not None and len(titles) > 0:
                     correct, sec_correct = self.display_hybrid_results(payload, final_class_idx, results, top_k, verbose=True)
                     
-                if isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
-                    if chosen_label is None or chosen_label.startswith('unknown'):
-                        chosen_label = 'Unknown'
-                        confidence = 1.0 - confidence  #Invert confidence for unknown class
-                        print(f"\n[⚠️] Final prediction is {chosen_label} with uncertain confidence: {confidence:.1%}. Consider more consistent data for the model to learn from.")
+                if isinstance(voted_chosen_label, str) and voted_chosen_label.startswith("unknown") or float(voted_confidence) < self.pipeline.confidence_threshold:
+                    if voted_chosen_label is None or voted_chosen_label.startswith('unknown'):
+                        voted_chosen_label = 'Unknown'
+                        voted_confidence = 1.0 - voted_confidence  #Invert confidence for unknown class
+                        print(f"\n[⚠️] Frequent predicted label is {voted_chosen_label} with uncertain confidence: {voted_confidence:.1%}. Consider more consistent data for the model to learn from.")
                     else:
-                        print(f"\n[🎯] Predicted label: {chosen_label} || With Certain Confidence: {confidence:.1%}")
+                        print(f"\n[🎯] Frequent Predicted label: {voted_chosen_label} || With Certain Confidence: {voted_confidence:.1%}")
 
-                return results, chosen_label, confidence
+                return results, voted_chosen_label, voted_confidence
 
             else:
-                if results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold and not chosen_label.startswith("unknown"):
-                    print(f"\n[🎯] Proper Confidence of Final chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")
-                    return results, chosen_label, confidence
+                if models_agreement and voted_confidence > self.pipeline.confidence_threshold and not voted_chosen_label.startswith("Unknown"):
+                    print(f'[>] Agreement count: {agreement_counts}, Both models agree frequently on predicted label: {voted_chosen_label}')
+                    print(f"\n[🎯] Proper Confidence of Final chosen label for input: {voted_chosen_label} || Confidence: {voted_confidence:.1%}")
+                    return results, voted_chosen_label, voted_confidence
                     
                 # Only recalibrate if models disagreed
-                elif results and not results[0].get('models_agree', True) or not self.pipeline.agreement and self.pipeline.use_transformer:
+                elif results and not models_agreement or not self.pipeline.agreement and self.pipeline.use_transformer:
 
-                    need_peer_condition = not results[0].get('models_agree', True) and self.pipeline.peer_assistance_threshold > 0.3 and self.pipeline.use_transformer
+                    need_peer_condition = not models_agreement and self.pipeline.peer_assistance_threshold > 0.3 and self.pipeline.use_transformer
                     print("\n[⚠️] Disagreement detected between MLP and Transformer predictions. Usig calibrated probabilities for final decision.")
-                    if confidence < self.pipeline.confidence_threshold and need_peer_condition:
+                    if voted_confidence < self.pipeline.confidence_threshold and need_peer_condition:
                         print('|| Uncertain advanced prediction, requesting peer assistance if allowed...')
                         final_probs = self.pipeline._handle_distributed_connections(final_probs, attn_weights, input_ids, agreement) 
 
-                        final_idx = final_probs[0].argmax()
+                        final_idx, voted_confidence = self._get_voted_results(final_probs, reverse_map, len(X))
                         original_idx = final_idx
 
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                        final_idx = int(final_idx)  
-
-                        chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                        if chosen_label.startswith('unknown'):
-                            final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")
 
-                        try:
-                            confidence = float(final_probs[final_idx])   
-                        except:
-                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
+                        final_idx = int(final_idx)  
+                        voted_chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
                
                     elif self.pipeline.autonomous and need_peer_condition and attn_weights is not None:
                         if agreement is None:
@@ -20837,27 +20904,22 @@ class PipelinePredictionManager:
                         print('[||] Iniating local peer output search in database for best output...')
                         final_probs = self.pipeline.distribution._handle_peer_agent_request(final_probs, attn_weights, input_ids, type='DevicePeer', agreement=agreement)
 
-                        final_idx = final_probs[0].argmax()
+                        final_idx, voted_confidence = self._get_voted_results(final_probs, reverse_map, len(X))
                         original_idx = final_idx              
 
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                        final_idx = int(final_idx)  
-
-                        chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                        try:
-                            confidence = float(final_probs[final_idx])   
-                        except:
-                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
+                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")  
 
+                        final_idx = int(final_idx)  
+                        voted_chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
 
-                    elif not results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold:
+                    elif not models_agreement and voted_confidence > self.pipeline.confidence_threshold:
                         if final_confidence is not None and confidence < self.pipeline.confidence_threshold:
                             print("\n[⚠️] Low confidence detected, but both models don't agree. Using calibrated probabilities for final decision to ensure robustness.")
                             final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset, X=X, y=y, use_embedded=use_embedded)
                         
-                            final_idx = final_probs[0].argmax()
+                            final_idx, voted_confidence = self._get_voted_results(final_probs, reverse_map, len(X))
                             original_idx = final_idx
                             
                             if final_idx > len(reverse_map):
@@ -20868,68 +20930,51 @@ class PipelinePredictionManager:
                             print('[🎯] Stable confidence established, But both Models doesnt Agree, Re-evaluating...')   
                             final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset, X=X, y=y, use_embedded=use_embedded)
                         
-                            final_idx = final_probs[0].argmax()
+                            final_idx, voted_confidence = self._get_voted_results(final_probs, reverse_map, len(X))
                             original_idx = final_idx
                             if final_idx > len(reverse_map):
                                 final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                                 print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
                             final_idx = int(final_idx)    
 
-                        chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                        try:
-                            confidence = float(final_probs[0][final_idx])   
-                        except:
-                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
                     else:
                         if self.pipeline.use_transformer and need_ensemble_method:
                             print("\n[⚠️] Uncertain confidence and disagreement detected. Using ensemble method for final decision.")
                             input_forward = sequence_ids if sequence_ids is not None else input_ids
                             final_probs, details = self.pipeline.ensemble.predict_ensemble(input_forward, X, y, method='dynamic', embedded=use_embedded)
                         
-                            final_idx = final_probs[0].argmax()
+                            final_idx, voted_confidence = self._get_voted_results(final_probs, reverse_map, len(X))
                             original_idx = final_idx 
 
                             if final_idx > len(reverse_map):
                                 final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                            final_idx = int(final_idx)          
+                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")   
 
-                            chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                            try:
-                                confidence = float(final_probs[0][final_idx])   
-                            except:
-                                confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
+                            final_idx = int(final_idx)          
+                            voted_chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
                         else:
                             if final_probs is None:
                                 final_probs = mlp_probs
 
-                            final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
+                            target_cache = []
+                            for i in range(len(target_pred_indices)):
+                                target_cache.append(target_pred_indices[i])
+                                
+                            counter = Counter(target_cache)
+                            predicted_idx, _ = counter.most_common(1)[0]
 
-                            final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
-                            
+                            final_probs = self.calibration_penalized_check(target_probs, predicted_idx)
+                            final_idx, voted_confidence = self._get_voted_results(target_probs, reverse_map, len(X)) 
                             original_idx = final_idx 
 
                             if final_idx > len(reverse_map):
-                                final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                            final_idx = int(final_idx)          
+                                final_idx = int(np.argmax(target_probs[:len(reverse_map)-1]))
+                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")
 
-                            chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                            if final_probs is None:
-                                final_probs = target_probs.copy()
+                            final_idx = int(final_idx)          
+                            voted_chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
 
-                            try:
-                                try:
-                                    confidence = float(final_probs[0][final_idx])   
-                                except:
-                                    confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-                            except:
-                                try:
-                                    confidence = float(final_probs[final_idx]) 
-                                except:
-                                    confidence = self.pipeline.confidence_threshold
-
-                elif confidence < self.pipeline.confidence_threshold and not self.pipeline.agreement and not results[0].get('models_agree', True):
+                elif voted_confidence < self.pipeline.confidence_threshold and not self.pipeline.agreement and not results[0].get('models_agree', True):
                     if trans_probs is not None:
                         prob_entropy = self.calculate_entropy(final_probs)
                         normalized_entropy = prob_entropy / np.log(prob_entropy.shape[-1]) if prob_entropy.shape[-1] > 1 else 0
@@ -20946,8 +20991,8 @@ class PipelinePredictionManager:
                     use_simple_prediction = (
                     anisotropy < 0.3 or
                     mean_entropy < 0.5 or  # High uncertainty
-                    results[0].get('confidence', 0) < 0.4 or  # Low confidence
-                    not results[0].get('models_agree', True) or  # Disagreement
+                    voted_confidence < 0.4 or  # Low confidence
+                    not models_agreement or  # Disagreement
                     attn_quality < 0.4
                     )
 
@@ -20959,73 +21004,47 @@ class PipelinePredictionManager:
                             return _, predicted_label, confidence
 
                     else:
-                        final_idx = final_probs[0].argmax()
+                        final_idx, confidence =self._get_voted_results(final_probs, reverse_map, len(X)) 
                         original_idx = final_idx
 
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                             print(f"[⚠️] Clamping {final_idx} → {final_idx}")                      
                         final_idx = int(final_idx) 
-
-                        chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                        if final_probs is not None:
-                            try:
-                                confidence = float(final_probs[0][final_idx])   
-                            except:
-                                confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0  
-            
-                        else:
-                            final_probs = target_probs.copy() 
+                        voted_chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
 
                 else:
                     print("\n[🎯] Using initial Regular final prediction as final decision.")
-                    final_idx = final_probs[0].argmax()
+                    final_idx, voted_confidence = self._get_voted_results(final_probs, reverse_map, len(X))
 
                     if final_idx > len(reverse_map):
                         final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                         print(f"[⚠️] Clamping {final_idx} → {final_idx}")                    
                     final_idx = int(final_idx)
+                    voted_chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
 
-                    chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-
-                    try:
-                        confidence = float(final_probs[0][final_idx])   
-                    except:
-                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-                
-            if confidence > 0.8:
-                confidence = (confidence + performance_score) / 2 
+            if voted_confidence > 0.8:
+                voted_confidence = (voted_confidence + performance_score) / 2 
                 print(f'[⚡] Confidence calibrated to be around: {confidence}')
 
-            if isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
-                if chosen_label.startswith("unknown"):
-                    chosen_label = 'Unknown'
-                    confidence = 1.0 - confidence  #Invert confidence for unknown class
+            if isinstance(voted_chosen_label, str) and voted_chosen_label.startswith("unknown") or float(voted_confidence) < self.pipeline.confidence_threshold:
+                if voted_chosen_label.startswith("unknown"):
+                    voted_chosen_label = 'Unknown'
+                    voted_confidence = 1.0 - voted_confidence  #Invert confidence for unknown class
 
-                print(f"\n[⚠️] Final prediction is {chosen_label} with uncertain confidence: {confidence:.1%}. Consider more consistent data for the model to learn from.")
+                print(f"\n[⚠️] Final prediction is {voted_chosen_label} with uncertain confidence: {voted_confidence:.1%}. Consider more consistent data for the model to learn from.")
             else:
-                print(f"\n[🎯] Final chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")  
+                print(f"\n[🎯] Final chosen label for input: {voted_chosen_label} || Confidence: {voted_confidence:.1%}")  
 
             try:
                 consecutive_probs = self.pipeline.distribution._handle_peer_agent_request(target_probs, attn_weights, input_ids, type='DevicePeer', agreement=agreement)
-                sec_final_idx = consecutive_probs[0].argmax()
+                sec_final_idx, sec_confidence = self._get_voted_results(consecutive_probs, reverse_map, len(X))
 
                 if sec_final_idx > len(reverse_map):
                     sec_final_idx = int(np.argmax(consecutive_probs[:len(reverse_map)-1]))
-                    print(f"[⚠️] Clamping {sec_final_idx} → {sec_final_idx}")                    
-                sec_final_idx = int(sec_final_idx)
+                    print(f"[⚠️] Clamping {sec_final_idx} → {sec_final_idx}")            
 
-                sec_chosen_label = reverse_map.get(sec_final_idx, f"unknown_{sec_final_idx}")
-                try:
-                    sec_confidence = float(consecutive_probs[0][sec_final_idx])   
-                except:
-                    sec_confidence = float(consecutive_probs[0][len(reverse_map)-1]) if isinstance(consecutive_probs[0], (float, int)) else self.pipeline.confidence_threshold  
-
-                if isinstance(confidence, (np.ndarray, list)):
-                    confidence = np.mean(confidence)
-                if isinstance(sec_confidence, (np.ndarray, list)):
-                    sec_confidence = np.mean(sec_confidence) 
-                    
+                sec_final_idx = int(sec_final_idx)  
                 if sec_confidence > 0.8:
                     sec_confidence = (sec_confidence + performance_score) + eps / 2 
 
@@ -21039,8 +21058,8 @@ class PipelinePredictionManager:
                     results[0]['sec_index'] = sec_final_idx
 
                     if confidence > results[0]['confidence']:
-                        results[0]['predicted'] = chosen_label
-                        results[0]['confidence'] = confidence
+                        results[0]['predicted'] = voted_chosen_label
+                        results[0]['confidence'] = voted_confidence
                         results[0]['predicted_idx'] = final_idx
                 else:
                     print('[!] No prediction in results cache are found!')
@@ -21048,8 +21067,8 @@ class PipelinePredictionManager:
             except Exception as e:
                 print(f'[!] Error initiating second prediction in Advanced prediction method: {e} ')
 
-                results[0]['sec_predicted'] = chosen_label
-                results[0]['sec_confidence'] = confidence
+                results[0]['sec_predicted'] = voted_chosen_label
+                results[0]['sec_confidence'] = voted_confidence
                 results[0]['sec_index'] = final_idx
 
 
@@ -21058,12 +21077,12 @@ class PipelinePredictionManager:
             traceback.print_exc()            
             try:
                 results = self.regular_prediction_method(titles=titles, label_map=label_map, rules=rules, X=X, y=y, show_proba=False, top_k=3, batch_size=2, use_transformer=self.pipeline.use_transformer)
-                chosen_label = results[0]['predicted']
-                confidence = results[0]['confidence']
+                voted_chosen_label = results[0]['predicted']
+                voted_confidence = results[0]['confidence']
             except Exception as error:
                 print(f'[= ! =] Error in all prediction method: {error}')
                 traceback.print_exc()
-                results, chosen_label, confidence = None, None, 0.0
+                results, voted_chosen_label, voted_confidence = None, None, 0.0
 
         print('[=] Displaying Results....')
         payload = {
@@ -21078,17 +21097,17 @@ class PipelinePredictionManager:
             chosen_label = sec_chosen_label # overrides previous chosen label if accuracy is higher
         elif self.pipeline.autonomous and sec_confidence > self.pipeline.confidence_threshold:
             print(f'[⚡] Autonomous Prediction used second predicted label: {sec_chosen_label}')
-            chosen_label = sec_chosen_label
+            voted_chosen_label = sec_chosen_label
         else:
-            print(f'[⚡] Final Prediction: {chosen_label} with confidence: {confidence:.1%}')
-            chosen_label = chosen_label
+            print(f'[⚡] Final Prediction: {voted_chosen_label} with confidence: {voted_confidence:.2%}')
+            voted_chosen_label = voted_chosen_label
 
         self.pipeline.evaluate_mlp_performance(X, y, self.label_map)
         # delete pipelines cache
         print('[🔍] Pipelines Cache Cleaned!')
         self.pipeline.cache.clear()
 
-        return results, chosen_label, confidence
+        return results, voted_chosen_label, voted_confidence
 
 
     def calibration_penalized_check(self, final_probs, predicted_index):