AbstractIntegratedModule 1.0.2__tar.gz → 1.0.4__tar.gz

{abstractintegratedmodule-1.0.2 → abstractintegratedmodule-1.0.4}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.2
+Version: 1.0.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.0.2 → abstractintegratedmodule-1.0.4}/AbstractIntegratedModule.py

@@ -778,7 +778,8 @@ class Transformer:
     def apply_update(self, param, grad, lr):
         # L2 weight decay applied directly at update time
         # equivalent to: grad += weight_decay * param
-        return param - lr * (grad + self.weight_decay * param)
+        update = param - lr * (grad + self.weight_decay * param)
+        return update
 
     def dropout(self, x, rate=0.1, training=True, alpha=None):
         if not training or rate == 0.0:
@@ -796,7 +797,7 @@ class Transformer:
         return x * mask / (1.0 - effective_rate), mask
 
     def _get_attn_scale(self, d_k):
-        """Cache scale factor — d_k never changes at runtime."""
+        """Cache scale factor — that d_k never changes at runtime."""
         if self._attn_scale is None:
             self._attn_scale = 1.0 / np.sqrt(d_k)
         return self._attn_scale
@@ -2157,7 +2158,7 @@ class LSTMCell:
         cs    = np.zeros((T, H))
         cache = []
 
-        # preallocate xh buffer once
+        # preallocate xh buffer once only here.
         xh = np.empty(expected_input + H)
 
         for t in range(T):
@@ -2403,7 +2404,7 @@ class LSTMEngine:
 
             # confidence error — how wrong was the predicted probability
             # correct prediction   → low error
-            # wrong prediction     → high error
+            # wrong prediction     → high error in here.
             err = np.abs(pred_prob - true_bin)
             confidence_errors.extend(err.tolist())
 
@@ -2445,7 +2446,7 @@ class LSTMEngine:
         b            = cell.b
         H1, H2, H3  = H, H * 2, H * 3   # slice boundaries precomputed
 
-        # FIX 1 — Wy check once before loop, not T times inside
+        # Wy check once before loop
         if self.model.Wy is None:
             self.model.Wy = self.model.weight_shaper.weight_shaping(x_seq)
         Wy = self.model.Wy
@@ -8124,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
@@ -8629,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):
@@ -9295,8 +9296,16 @@ class IntegratedPipeline:
         self.error_decay = 0.85
         self.performance_result = 1.0
 
+        # === TRAINING SETUP ===
         self.mlp_training_epochs = 2000
+        self.mlp_lr = 0.1
+        self.transformer_lr = 0.1
+        self.transformer_d_model = 32
+        self.transformer_heads = 4
         self.transformer_training_epochs = 100
+        self.lstm_training_epochs = 50
+        self.lstm_lr = 5e-2
+        self.lstm_hidden_dim = 64
 
         # Main component setup
         self.standard_scaler = StandardScaler()
@@ -9361,7 +9370,6 @@ class IntegratedPipeline:
         self._prob_save_count = None
 
         self.temperature = 1.0
-        self.transformer_lr = 0.1
         self.max_seq_len = 16
 
         self.memory_name = memory_name
@@ -9970,8 +9978,8 @@ class IntegratedPipeline:
 
         self.model2 = Transformer(
             vocab_size=len(self.vocab),
-            d_model=32,
-            n_heads=4,
+            d_model=self.transformer_d_model,
+            n_heads=self.transformer_heads,
             num_classes=num_classes
         )
 
@@ -12559,7 +12567,7 @@ class IntegratedPipeline:
         
         engine = self.lstm_engine
 
-        self.lstm_engine.fit_stm(X, Y)
+        self.lstm_engine.fit_stm(X, Y, epochs=self.lstm_training_epochs, hidden=self.lstm_hidden_dim, lr=self.lstm_lr)
         engine.calibrate(X_val, Y_val)
 
         print("\n[= LSTM INSIGHT =] Per-sample confidence report:")
@@ -12591,6 +12599,7 @@ class IntegratedPipeline:
         print('[=+=] ==== STATUS REPORT ====')
         print("\n[=] Confidence breakdown for sample 0:")
         r = engine.predict(X_val[0], label_bins=label_bins)
+
         print(f"    MC mean (last step)   : {r['mc_mean'][-1]:+.4f}")
         print(f"    MC std  (last step)   : {r['mc_std'][-1]:.4f}  "
             f"← tight = certain")
@@ -12658,8 +12667,8 @@ class IntegratedPipeline:
                     num_classes = self._get_num_classes(label_map=label_map)                
                     self.model2 = Transformer(
                         vocab_size=len(self.vocab),
-                        d_model=32,
-                        n_heads=4,
+                        d_model=self.transformer_d_model,
+                        n_heads=self.transformer_heads,
                         num_classes=num_classes
                     ) 
                     
@@ -12691,7 +12700,7 @@ class IntegratedPipeline:
         (n_samples, T, d_model) that the Transformer can process with
         embedded=True.
 
-        Strategy: split the feature dimension into d_model-sized windows.
+        Strategy used: split the feature dimension into d_model-sized windows.
         Each window becomes one timestep. This lets the Transformer's
         attention mechanism find relationships BETWEEN feature windows,
         not just within them — genuinely useful when X_provided has
@@ -12900,7 +12909,7 @@ class IntegratedPipeline:
                 
             self.lstm_setup_inference(X, y) 
             self.initialize_model_(X, input_dim, n_classes)
-            self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=0.1)
+            self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=self.mlp_lr)
 
             if self.lstm_engine:
                 self.storage.save_weights(self.memory_name, model_type='Pipeline') 
@@ -12927,8 +12936,8 @@ class IntegratedPipeline:
 
             self.model2 = Transformer(
                 vocab_size=1,
-                d_model=32,
-                n_heads=4,
+                d_model=self.transformer_d_model,
+                n_heads=self.transformer_heads,
                 num_classes=num_classes
             )
 
@@ -12969,6 +12978,8 @@ class IntegratedPipeline:
         self.utility_MLP_set(self.X, y_true)       
         print('✅ Done Training MLP Model! ')
 
+
+
 class AccurateAnswerCache:
     def __init__(self, pipeline, similarity_threshold=0.85, max_size=500):
         self.pipeline = pipeline
@@ -17356,7 +17367,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'],
@@ -17723,7 +17734,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%})")
@@ -18093,7 +18114,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,
@@ -18329,30 +18350,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)
             
@@ -18708,7 +18709,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:
@@ -18781,35 +18782,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]: