AbstractIntegratedModule 1.0.3__tar.gz → 1.0.5__tar.gz

{abstractintegratedmodule-1.0.3 → abstractintegratedmodule-1.0.5}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.3
+Version: 1.0.5
 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.0.3 → abstractintegratedmodule-1.0.5}/AbstractIntegratedModule.py

@@ -8125,7 +8125,7 @@ class AgentDistributedInference:
                     continue
 
                 if message.get('type') == 2:  # PREDICT_RESPONSE
-                    continue  # Skip, we'll read it in request_prediction_method
+                    continue  # Skipped
 
                 message = self._receive_message(client) 
                 self.temporary_message = message
@@ -8630,7 +8630,7 @@ class AgentDistributedInference:
                 return response['prediction'], response['text']
             return None, None
         except Exception as e:
-            print(f"Vote request failed: {e}")
+            print(f"[-] Vote request failed: {e}")
             return None, None
     
     def sync_memory_with_agent(self, agent_id, memory_name, timeout=10):
@@ -16996,201 +16996,222 @@ class PipelinePredictionManager:
             if isinstance(confidence, (np.ndarray, list)):
                 confidence = np.mean(confidence)
 
-            print(f"\n[🎯] Initial chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")
+            return_single_condition = (
+                not self.pipeline.use_transformer or
+                not need_ensemble_method 
 
-            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
-            
-            # Only recalibrate if models disagreed
-            elif results and not results[0].get('models_agree', True) or not self.pipeline.agreement:
-                need_peer_condition = not results[0].get('models_agree', True) and self.pipeline.peer_assistance_threshold > 0.3
-                print("\n[⚠️] Disagreement detected between MLP and Transformer predictions. Using calibrated probabilities for final decision.")
-                if not self.pipeline.autonomous 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()
-                    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]))
-
-                    try:
-                        print(final_probs)
-                        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      
-                        
-                elif self.pipeline.autonomous and need_peer_condition and attn_weights is not None:
-                    if agreement is None:
-                        agreement = False
-
-                    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()
-                    original_idx = final_idx              
+            )
+            if return_single_condition:
+                print('[=] Displaying 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%} Due to disagreement between Transformer and MLP.')
+
+                print(f"\n[🎯] Predicted label: {chosen_label} || With Certain Confidence: {confidence:.1%}")
+                payload = {
+                    'X_samples': X,
+                    'input_ids': input_ids
+                }
+                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 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)  
+                return results, chosen_label, confidence
 
-                    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      
+            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
+                    
+                # 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:
 
+                    need_peer_condition = not results[0].get('models_agree', True) 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:
+                        print('|| Uncertain advanced prediction, requesting peer assistance if allowed...')
+                        final_probs = self.pipeline._handle_distributed_connections(final_probs, attn_weights, input_ids, agreement) 
 
-                elif not results[0].get('models_agree', True) and 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()
                         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)  
-                    else:
-                        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()
-                        original_idx = final_idx
-                        if final_idx > len(reverse_map):
+
+                        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}")               
-                        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)
-                    
+                        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      
+               
+                    elif self.pipeline.autonomous and need_peer_condition and attn_weights is not None:
+                        if agreement is None:
+                            agreement = False
+
+                        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()
-                        original_idx = final_idx 
+                        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(final_idx)  
 
                         chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
                         try:
-                            confidence = float(final_probs[0][final_idx])   
+                            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             
-                    else:
-                        if final_probs is None:
-                            final_probs = mlp_probs
+                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
 
-                        final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
 
-                        final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
+                    elif not results[0].get('models_agree', True) and 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)
                         
-                        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 = final_probs[0].argmax()
+                            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)  
+                        else:
+                            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()
+                            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 None:
-                            final_probs = target_probs.copy()
-
                         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()
+                            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             
-                        except:
+                        else:
+                            if final_probs is None:
+                                final_probs = mlp_probs
+
+                            final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
+
+                            final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
+                            
+                            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 None:
+                                final_probs = target_probs.copy()
+
                             try:
-                                confidence = float(final_probs[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             
                             except:
-                                confidence = self.pipeline.confidence_threshold
+                                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):
+                    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
+                        attn_quality = 1.0 / (1.0 + np.exp(-attn_weights.mean()) + eps) if attn_weights is not None else 0.5
+                        anisotropy = self.pipeline.anisotropy_measurement(attn_weights.mean() if attn_weights is not None else 0.5)
 
-            elif 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
-                    attn_quality = 1.0 / (1.0 + np.exp(-attn_weights.mean()) + eps) if attn_weights is not None else 0.5
-                    anisotropy = self.pipeline.anisotropy_measurement(attn_weights.mean() if attn_weights is not None else 0.5)
+                    else:
+                        normalized_entropy = self.calculate_entropy(input_ids)  # Max entropy for uniform distribution
+                        attn_quality = self.pipeline.confidence_threshold
+                        anisotropy = self.anisotropy_measurement(input_ids) if hasattr(self.pipeline, 'anisotropy_measurement') else 0.5
+
+                    mean_entropy = np.mean(normalized_entropy)
+
+                    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
+                    attn_quality < 0.4
+                    )
 
-                else:
-                    normalized_entropy = self.calculate_entropy(input_ids)  # Max entropy for uniform distribution
-                    attn_quality = self.pipeline.confidence_threshold
-                    anisotropy = self.anisotropy_measurement(input_ids) if hasattr(self.pipeline, 'anisotropy_measurement') else 0.5
-
-                mean_entropy = np.mean(normalized_entropy)
-
-                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
-                attn_quality < 0.4
-                )
+                    if use_simple_prediction:
+                        print("\n[⚡] Condition is poorly unviable to handle agreement. Using robust prediction method for better reliability.")
+                        predicted_label, confidence = self.simple_pass_prediction(self.pipeline, titles=titles, label_map=label_map, X_raw=X, y=y, show_proba=show_proba, top_k=top_k)
+                        if predicted_label is not None:
+                            print(f"\n[🎯] Robust prediction result: {predicted_label} with confidence {confidence:.1%}")
+                            return _, predicted_label, confidence
 
-                if use_simple_prediction:
-                    print("\n[⚡] Condition is poorly unviable to handle agreement. Using robust prediction method for better reliability.")
-                    predicted_label, confidence = self.simple_pass_prediction(self.pipeline, titles=titles, label_map=label_map, X_raw=X, y=y, show_proba=show_proba, top_k=top_k)
-                    if predicted_label is not None:
-                        print(f"\n[🎯] Robust prediction result: {predicted_label} with confidence {confidence:.1%}")
-                        return _, predicted_label, confidence
+                    else:
+                        final_idx = final_probs[0].argmax()
+                        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() 
 
                 else:
+                    print("\n[🎯] Using initial Regular final prediction as final decision.")
                     final_idx = final_probs[0].argmax()
-                    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}")                    
+                    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() 
-
-            else:
-                print("\n[🎯] Using initial Regular final prediction as final decision.")
-                final_idx = final_probs[0].argmax()
-
-                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             
-            
+                    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 
                 print(f'[⚡] Confidence calibrated to be around: {confidence}')
@@ -17198,7 +17219,7 @@ class PipelinePredictionManager:
             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
+                    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.")
             else:
@@ -17367,7 +17388,7 @@ class PipelinePredictionManager:
                 if 'sec_predicted' in result:
                     sec_status = ": ✅" if result['sec_predicted'] == result['expected'] else ": ❌"                
                     print(f"[=] Second Expectation: {result['expected']} || Model Answer: {sec_status}")    
-                    if result['sec_predicted'] == result['expected']:
+                    if 'sec_predicted' in result and 'sec_confidence' in result and result['sec_predicted'] == result['expected']:
                         self.pipeline.accurate_cache_lookup.add_verified(
                             X_samples, input_ids, 
                             result['sec_predicted'], result['sec_confidence'], result['sec_index'],
@@ -17380,15 +17401,17 @@ class PipelinePredictionManager:
                             self.error_counts[result.get('predicted_idx')] += 1.0
 
                 if result['predicted'] == result['expected']:
-                    if result['sec_index'] is None:
+                    if 'sec_index' in result and result['sec_index'] is None:
                         result['sec_index'] = None
 
-                    self.pipeline.accurate_cache_lookup.add_verified(
-                        X_samples, input_ids, 
-                        result['predicted'], result['confidence'], result['predicted_idx'],
-                        source='automatic_verified')      
+                    if 'predicted_idx' in result and 'confidence' in result and 'predicted' in result:
+                        self.pipeline.accurate_cache_lookup.add_verified(
+                            X_samples, input_ids, 
+                            result['predicted'], result['confidence'], result['predicted_idx'],
+                            source='automatic_verified')      
 
-                    correct += 1
+                        correct += 1
+                        
                 else:
                     error += 1
                     if isinstance(self.error_counts[result.get('predicted_idx')], (int, float)):
@@ -17716,7 +17739,7 @@ class ConsecutivePeerAgent:
         
         best_result = local_result
         
-        # Step 2: If low confidence, ask peers
+        # Step 2: If low confidence, asking peers
         if local_result['confidence'] < confidence_threshold and peer_addresses or peer_addresses:
             if local_result['confidence'] < confidence_threshold:
                 print(f"[ConsecutivePeerAgent] Low confidence, asking {len(peer_addresses)} peers...")
@@ -17734,7 +17757,17 @@ class ConsecutivePeerAgent:
                     print(f'[==] Peer result: {result['prediction']} With Confidence: {result['confidence']}')
 
             if peer_results:
-                best_peer = max(peer_results, key=lambda x: x['confidence'])                                   
+                best_peer = max(peer_results, key=lambda x: x['confidence']) 
+                if isinstance(peer_results[0], dict):
+                    total_weight = len(peer_addresses) + 1
+                    best_result = best_peer.get('prediction') 
+                    best_confidence = min(best_peer.get('confidence') / total_weight, 1.0)
+                    
+                    print(f"[ConsecutivePeerAgent] Using Ensemble prediction result is: {best_result} || With Confidence: ({best_confidence:.1%})")
+                    self.stats['predictions'] += 1
+
+                    return best_peer  
+
                 if best_peer['confidence'] > local_result['confidence']:
                     best_result = best_peer
                     print(f"[ConsecutivePeerAgent] Using peer result: {best_peer['prediction']} || Confidence: ({best_peer['confidence']:.1%})")
@@ -18104,7 +18137,7 @@ class CohesiveAgentDeployment:
         
     async def _prediction_worker(self, texts: list, api_key: str = None, client_ip: str = None) -> dict:
         # Worker function for processing predictions
-        # This runs in a thread pool via asyncio.to_thread
+        # runs in a thread pool via asyncio.to_thread
         return self.async_manager.predict(
             texts=texts,
             timeout=self.pipeline.timeout,
@@ -18319,11 +18352,11 @@ class CohesiveAgentDeployment:
                 
                 # Send heartbeat to check connection
                 try:
-                    # self.pipeline.distribution._send_message(
-                        # sock, {'type': 'PING', 'timestamp': time.time()}
-                   # )
-                   sock.getpeername()
-                   print(f'[==] Peer name: {sock.getpeername()}')
+                    self.pipeline.distribution._send_message(
+                        sock, {'type': 'PING', 'timestamp': time.time()}
+                    )
+                    sock.getpeername()
+                    print(f'[==] Peer name: {sock.getpeername()}')
                 except:
                     logger.warning(f"[-] Peer {peer_host}:{peer_port} disconnected")
                     break
@@ -18340,30 +18373,10 @@ class CohesiveAgentDeployment:
             sock.close()
 
     
-    async def _peer_health_monitor(self):
-        # Monitor peer health and reconnect if needed
-        logger.info("[💓] Peer health monitor started")
-        
-        while not self._shutdown_event.is_set():
-            await asyncio.sleep(30)
-            
-            try:
-                # Ping all connected peers
-                alive_agents = self.pipeline.distribution.broadcast_ping()
-                logger.info(f"[=+=] Connected peers: {len(alive_agents)}")
-                
-                # Reconnect to known peers that went offline
-                for peer_key, peer_info in self._known_peers.items():
-                    if not peer_info.get('connected', False):
-                        logger.info(f"[==] Attempting to reconnect to {peer_key}")
-                        await self._connect_to_peer(peer_info['host'], peer_info['port'])
-                        
-            except Exception as e:
-                logger.error(f"[❌] Peer health monitor error: {e}")
-       
     
     async def _health_monitor(self):
         # Background health monitoring
+        print("[💓] Peer health monitor started")
         while not self._shutdown_event.is_set():
             await asyncio.sleep(30)
             
@@ -18719,7 +18732,7 @@ class CohesiveAgentDeployment:
             if already_connected:
                 continue
             
-            # ✅ Step 4: Single connection attempt (NO RETRY)
+            # ✅ 4: Single connection attempt (NO RETRYS)
             print(f"[=] Connecting to {peer_key}...")
             
             try:
@@ -18792,35 +18805,6 @@ class CohesiveAgentDeployment:
             logger.warning(f"[=-] Peer {agent_id} failed: {e}")
             return None
 
-    def _ensemble_predictions(self, local: dict, peers: list) -> dict:
-        # Combine predictions from multiple agents
-        try:
-            print('[=+=] Initiating Ensemble weighting with: {peers} peers total')
-            votes = defaultdict(float)
-            votes[local.get('prediction', 'unknown')] += local.get('confidence', 0)
-            
-            for peer in peers:
-                if peer and isinstance(peer, dict):
-                    votes[peer.get('prediction', 'unknown')] += peer.get('confidence', 0)
-            
-            best_pred = max(votes.items(), key=lambda x: x[1])
-            
-            total_weight = len(peers) + 1
-            return {
-                'prediction': best_pred[0],
-                'confidence': min(best_pred[1] / total_weight, 1.0),
-                'local_prediction': local.get('prediction'),
-                'local_confidence': local.get('confidence'),
-                'peer_count': len(peers),
-                'ensemble_votes': dict(votes)
-            }
-        except Exception as e:
-            print(f'[-] Error in ensemble weighting; {e}, returning local prediction with 0.0 confidence')
-            return {
-                'prediction': local,
-                'confidence': 0.0,
-                'peer_count': 0.0,
-            }
      
 
     async def predict_batch_async(self, texts: List[str], api_key: str = None, client_ip: str = None) -> List[dict]: