AbstractIntegratedModule 1.1.7__tar.gz → 1.1.8__tar.gz

{abstractintegratedmodule-1.1.7 → abstractintegratedmodule-1.1.8}/AbstractIntegratedModule.egg-info/PKG-INFO

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

@@ -730,6 +730,8 @@ class Transformer:
         
         self.cache = {}
 
+
+
     def _clear_forward_cache(self, keep_essential=True, max_age_forward_passes=5):
         """Clear cache entries older than max_age_forward_passes."""
         
@@ -3705,11 +3707,11 @@ class WeightedEnsemblePredictor:
         n_trans_classes = trans_probs.shape[1]        
         n_mlp_classes = mlp_probs.shape[1]
         
+        anisotropy = self.anisotropy_measurement(attn_weights)            
         n_classes = max(n_trans_classes, n_mlp_classes)       
         for i in range(batch_size):
             trans_row = np.zeros(n_classes)
-            mlp_row = np.zeros(n_classes)
-            
+            mlp_row = np.zeros(n_classes)         
             trans_row[:n_trans_classes] = trans_probs[i]
             mlp_row[:n_mlp_classes] = mlp_probs[i]
             
@@ -3717,8 +3719,7 @@ class WeightedEnsemblePredictor:
             mlp_row = mlp_row / (mlp_row.sum() + 1e-8)
 
             if i < len(attn_weights):
-                attn = attn_weights[i]
-                anisotropy = self.anisotropy_measurement(attn)                
+                attn = attn_weights[i]              
                 # Attention entropy: lower entropy = more focused = trust transformer more
                 if attn.size > 0:
                     attn_flat = attn.flatten()
@@ -3835,7 +3836,8 @@ class WeightedEnsemblePredictor:
             # Calculate weight based on meta features
             trans_conf = meta_features[i, 0]
             mlp_conf = meta_features[i, 1]
-            agreement = meta_features[i, 4]
+            agreement_idx = 6 if has_lstm else 4
+            agreement = meta_features[i, agreement_idx]
             
             trans_pred = int(np.argmax(trans_probs[i]))
             mlp_pred   = int(np.argmax(mlp_probs[i])) 
@@ -4474,6 +4476,8 @@ class ExplainabilityModule:
     
     def _get_final_output(self, mlp_pred, mlp_conf, trans_pred, trans_conf, attn_weights):
         eps = 1e-5
+        consensus_conf = 0.0 
+
         if isinstance(mlp_conf, np.ndarray):
             mlp_conf = np.clip(np.mean(mlp_conf), 0, 1)
         if isinstance(trans_conf, np.ndarray):
@@ -4481,7 +4485,7 @@ class ExplainabilityModule:
 
         if mlp_pred == trans_pred:
             final_pred = mlp_pred
-            final_conf = max(mlp_conf, trans_conf)
+            consensus_conf = max(mlp_conf, trans_conf)
         else:
             sliced_attention_weight = attn_weights[0]
             if isinstance(sliced_attention_weight, np.ndarray):
@@ -4513,11 +4517,11 @@ class ExplainabilityModule:
             print('[=] Note: Very little Consistency meaning Transformer attention quality is Healthy and focused')
 
         if isinstance(consensus_conf, np.ndarray):
-            consensus_conf = 1.0 / (1.0 + np.exp(-final_conf))
+            consensus_conf = 1.0 / (1.0 + np.exp(-consensus_conf))
             # Apply a sigmoid transformation to ensure the confidence is between 0 and 1
 
         # averaged all confidences to get the final confidence.
-        final_conf = mlp_conf + trans_conf + final_conf / 3
+        final_conf = mlp_conf + trans_conf + consensus_conf / 3
         if np.isnan(final_conf).any() or np.isinf(final_conf).any():
             final_conf = self.pipeline.confidence_threshold
 
@@ -7238,7 +7242,7 @@ class AgentDistributedInference:
         # Sort keys for consistent serialization
         sorted_message = {k: signed_message[k] for k in sorted(signed_message.keys())}
 
-        message_bytes = json.dumps(sorted_message, sort_key=True, default=str).encode('utf-8')
+        message_bytes = json.dumps(sorted_message, sort_keys=True, default=str).encode('utf-8')
       
         key = self.secret_key.encode() if isinstance(self.secret_key, str) else self.secret_key
         signature = hmac.new(key, message_bytes, hashlib.sha256).hexdigest()
@@ -7352,7 +7356,7 @@ class AgentDistributedInference:
         # Sort keys for consistent serialization
         sorted_msg = {k: temp_msg[k] for k in sorted(temp_msg.keys())}
           
-        message_bytes = pickle.dumps(sorted_msg, protocol=pickle.HIGHEST_PROTOCOL)
+        message_bytes = json.dumps(sorted_msg, sort_keys=True, default=str).encode('utf-8')
          
         key = self.secret_key.encode() if isinstance(self.secret_key, str) else self.secret_key
         expected = hmac.new(key, message_bytes, hashlib.sha256).hexdigest()
@@ -7388,6 +7392,7 @@ class AgentDistributedInference:
             # Add to trusted list with FULL trust if not exists
             if agent_id not in self.trusted_agents:
                 self._add_trusted_agent(agent_id, token, TrustLevel.FULL, source="shared_secret")
+                return True
             else:
                 # Update trust level if higher
                 current_level = self.trusted_agents[agent_id].get('trust_level', TrustLevel.BASIC)
@@ -7395,6 +7400,7 @@ class AgentDistributedInference:
                     self.trusted_agents[agent_id]['trust_level'] = TrustLevel.FULL
                     print(f"[=] Upgraded trust level to FULL")
                     self.highly_trusted_peer.append(agent_id)
+                    return True
 
         elif agent_id in self.trusted_agents:
             stored_token = self.trusted_agents[agent_id]['token']
@@ -7491,7 +7497,7 @@ class AgentDistributedInference:
         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
         bind_host = self._get_bind_host()
-        self.socket.bind(('0.0.0.0', self.port))
+        self.socket.bind((bind_host, self.port))
 
         self.socket.settimeout(1.0)
         self.socket.listen(5)
@@ -7570,7 +7576,7 @@ class AgentDistributedInference:
                     print(f"[-] Connection attempt from blocked IP: {host}")
                     self._log_security_event('connection_blocked', {'ip': host})
                     client.close()
-                    return
+                    continue
 
                 print(f"📡 Connected to agent at {addr}")
                 auth_msg = self._receive_message(client)
@@ -7585,7 +7591,7 @@ class AgentDistributedInference:
                     self._log_security_event('authentication_failed', {'agent': f"{addr[0]}:{addr[1]}"})
                     self.report_failure(id(self), 'authentication', reason=f'Failed authentication from {addr}')
                     client.close()
-                    return
+                    continue
 
                 # Send agent info to identify
                 self._send_agent_info(client)
@@ -13701,11 +13707,6 @@ class IntegratedPipeline:
                     print(f'[= ! =] High zero-row ratio ({weak_ratio:.0%}), refitting on current batch')
                     self.tfidf.fit(X_raw_generation)
                     X_raw_features = self.tfidf.transform(X_raw_generation).toarray()  
-
-            should_train_transformer, reason = self._should_train_transformer(sequence_inputs, X_raw, min_seq_len=3, min_anisotropy=0.35, min_samples=10, ram_headroom_mb=max_ram_used)   
-            if should_train_transformer:      
-                transformer_features = self.transformer_pooled_features(sequence_inputs)
-                X_raw_features = np.concatenate([X_raw_features, transformer_features], axis=-1)
             
             zero_rows = np.where(X_raw_features.sum(axis=1) == 0)[0]
             if len(zero_rows) > 0:
@@ -13775,12 +13776,16 @@ class IntegratedPipeline:
                     num_classes=n_classes
                 )
                 
+            should_train_transformer, reason = self._should_train_transformer(sequence_inputs, X_raw, min_seq_len=3, min_anisotropy=0.35, min_samples=10, ram_headroom_mb=max_ram_used)                  
             if self.use_transformer and should_train_transformer:
                 print(f'[=] Transformer Training allowed, Reason: {reason}')
                 self.model2.train(sequence_inputs, y_true, epochs=self.transformer_training_epochs, mode=mode, lr=lr, embedded=True, batch_size=batch_size)
-                       
-            X = self.shape_adaptation(hybrid_X, input_dim)      
 
+            if should_train_transformer:      
+                transformer_features = self.transformer_pooled_features(sequence_inputs)
+                hybrid_X = np.concatenate([hybrid_X, transformer_features], axis=-1)  
+
+            X = self.shape_adaptation(hybrid_X, input_dim)      
             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)