AbstractIntegratedModule 0.8.3__tar.gz → 0.8.5__tar.gz

{abstractintegratedmodule-0.8.3 → abstractintegratedmodule-0.8.5}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.8.3
+Version: 0.8.5
 Summary: Library for Advanced Integrated Non-LLM AI Models - Optimized Backend Framework For Non-LLM AI Agent
 Author: Micro-Novelty
 Author-email: hernikpuspita5@gmail.com
@@ -42,7 +42,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
 #### Note: The README here you are reading is a direct copy from my README Repository, to download the necessary files, you can visit my Repository with the provided link above.
 
 ### Library Short Description:
-- Development Stage: 0.8.3 Official Release.
+- Development Stage: 0.8.5 Official Release.
 - Maintainer: Micro-Novelty.
 - library Source-Code is Open-sourced on github.
 - Purpose: Specifically Designed for providing Non-LLM AI Agent Framework for edge Devices, Optimized for ARM64 architecture.
@@ -80,17 +80,16 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Transformer Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage, With Reduced Training Time.
 ______________
   - Changelog:
-     - v0.8.3:
+     - v0.8.5:
         - [=] New features: 
-        
-        - Added more robust inhomogenous shape handling for handling input_ids in Transformer and AccurateAnswerCache architecture.
+        - Added new Optimization module using Cython maths for dynamic weighted ensemble function.
         - Fixed P2P Vulnerabilities:
-            - Empty allowed_ips in PRODUCTION/HARDENED mode now DENIES external IPs instead of allowing all
-            - Startup validation warns about dangerous config combinations
-            - Loopback (127.0.0.1) always permitted for local agent comms
-            - DEVELOPMENT/STAGING retains allow-all behavior with explicit warning since local P2P testing requires it
-            - pickle.loads() replaced by json.loads with utf-8 encoding order.
-            - generate self signed cert fixes and added client.crt for fallback when users dont provide any SSL cert and key for both server and client.
+           - Empty allowed_ips in PRODUCTION/HARDENED mode now DENIES external IPs instead of allowing all
+           - Startup validation warns about dangerous config combinations
+           - Loopback (127.0.0.1) always permitted for local agent comms
+           - DEVELOPMENT/STAGING retains allow-all behavior with explicit warning since local P2P testing requires it
+           - pickle.loads() replaced by json.loads with utf-8 encoding order.
+           - generate self signed cert fixes and added client.crt for fallback when users dont provide any SSL cert and key for both server and client.
 
 ____________
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />

{abstractintegratedmodule-0.8.3 → abstractintegratedmodule-0.8.5}/AbstractIntegratedModule.py

@@ -61,7 +61,8 @@ try:
         optimized_ame_encoder,
         optimized_anisotropy,
         optimized_cosine_similarity,
-        optimized_softmax_2d
+        optimized_softmax_2d,
+        optimized_dynamic_weighted_ensemble
     )
     _OPT_AVAILABLE = True
     print('[=] Cython acceleration loaded ✅')
@@ -3020,82 +3021,116 @@ class WeightedEnsemblePredictor:
 
         return anisotropy
 
-    def _dynamic_weighted_ensemble(self, trans_probs, mlp_probs, attn_weights, input_ids, lstm_probs,
-                lstm_weight_hint):
-        batch_size = trans_probs.shape[0]
-      
+    def _dynamic_weighted_ensemble(self, trans_probs, mlp_probs, attn_weights,
+                                    input_ids, lstm_probs=None, lstm_weight_hint=0.0):
+        # normalize all inputs to guaranteed 2D float64
         try:
-            n_trans_classes = trans_probs.shape[1]
-            n_mlp_classes = mlp_probs.shape[1]
-            n_lstm_classes = lstm_probs.shape[1]
-        except:
-            n_trans_classes = trans_probs.shape[-1]
-            n_mlp_classes = mlp_probs.shape[-1]   
-            n_lstm_classes = lstm_probs.shape[-1]     
+            trans_probs = np.asarray(trans_probs, dtype=np.float64)
+            mlp_probs   = np.asarray(mlp_probs,   dtype=np.float64)
 
-        n_classes = max(n_trans_classes, n_mlp_classes)
-        
-        print(f"🔄 Aligning classes: {n_trans_classes} and {n_mlp_classes} → {n_classes}")
-        ensemble = np.zeros((batch_size, n_classes))
-        for i in range(batch_size):
-            trans_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]
-            
-            trans_row = trans_row / (trans_row.sum() + 1e-8)
-            mlp_row = mlp_row / (mlp_row.sum() + 1e-8)
-            
-            trans_pred = np.argmax(trans_probs[i])
-            mlp_pred = np.argmax(mlp_probs[i])
-            agreement = 1.0 if trans_pred == mlp_pred else 0.3
+            if trans_probs.ndim == 1: trans_probs = trans_probs[np.newaxis, :]
+            if mlp_probs.ndim   == 1: mlp_probs   = mlp_probs[np.newaxis, :]
 
-            if attn_weights is not None and i < len(attn_weights):
-                print('🔄 Sophisticated confidence assembling')
-                attn = attn_weights[i]
-                anisotropy = self.anisotropy_measurement(attn) 
+            B = trans_probs.shape[0]
 
-                attn_focus = np.std(attn) if attn.size > 0 else 0.5
-                attn_growth = 1.0 / (1.0 + np.exp(-attn_focus))
-                attn_limit = (1.0 - attn_focus + attn_growth) * anisotropy
+            n_trans = trans_probs.shape[1]
+            n_mlp   = mlp_probs.shape[1]
 
-                trans_conf_factor = attn_growth + attn_limit * attn_focus 
+            has_lstm = lstm_probs is not None
+            if has_lstm:
+                lstm_probs = np.asarray(lstm_probs, dtype=np.float64)
+                if lstm_probs.ndim == 1: lstm_probs = lstm_probs[np.newaxis, :]
+                n_lstm = lstm_probs.shape[1]
             else:
-                attn_growth = 1.0 / (1.0 + np.exp(-attn_weights))
-                anisotropy = self.anisotropy_measurement(attn_weights)
-                trans_conf_factor = attn_growth * anisotropy
+                lstm_probs = np.zeros((B, 1), dtype=np.float64)  # dummy, not used
+                n_lstm = 0
 
-            mlp_entropy = -np.sum(mlp_probs[i] * np.log(mlp_probs[i] + 1e-8))
-            mlp_conf_factor = 1.0 / (1.0 + mlp_entropy)  # Lower entropy = higher confidence
-            
-            trans_weight = trans_conf_factor * (1.0 + agreement) / 2
-            mlp_weight = mlp_conf_factor * (1.0 + agreement) / 2
+            n_classes = max(n_trans, n_mlp, n_lstm)
+            print(f"🔄 Aligning classes: trans={n_trans} mlp={n_mlp} "
+                f"lstm={n_lstm} → {n_classes}")
 
-            if lstm_probs is not None:
-                lstm_row = np.zeros(n_classes)
-                lstm_row[:n_lstm_classes] = lstm_probs[i]
-                lstm_row = lstm_row / (lstm_row.sum() + 1e-8)
+            if attn_weights is not None:
+                attn_arr = np.asarray(attn_weights, dtype=np.float64)
+                attn_flat = attn_arr.reshape(B, -1) if attn_arr.ndim > 1 \
+                            else np.tile(attn_arr.ravel(), (B, 1))
+            else:
+                attn_flat = np.full((B, 1), 0.5, dtype=np.float64)
 
-                # lstm_weight_hint already encodes residual_std confidence
-                lstm_pred   = np.argmax(lstm_probs[i])
-                lstm_agreement = 1.0 if lstm_pred == trans_pred or lstm_pred == mlp_pred else self.pipeline.confidence_threshold
-                lstm_weight = lstm_weight_hint * (1.0 + lstm_agreement) / 2
+            # per-sample lstm_weight_hints
+            if isinstance(lstm_weight_hint, (int, float)):
+                lstm_weight_hints = np.full(B, float(lstm_weight_hint), dtype=np.float64)
+            else:
+                lstm_weight_hints = np.asarray(lstm_weight_hint, dtype=np.float64)
+                if lstm_weight_hints.ndim == 0:
+                    lstm_weight_hints = np.full(B, float(lstm_weight_hints))
+
+                
+            if _OPT_AVAILABLE:
+                try:
+                    print('[+] Using Optimized Dynamic weighted ensemble Method.')
+                    return optimized_dynamic_weighted_ensemble(
+                        np.ascontiguousarray(trans_probs),
+                        np.ascontiguousarray(mlp_probs),
+                        np.ascontiguousarray(attn_flat),
+                        np.ascontiguousarray(lstm_probs),
+                        np.ascontiguousarray(lstm_weight_hints),
+                        float(self.pipeline.confidence_threshold),
+                        has_lstm
+                    )
+                except Exception as e:
+                    print(f'[=] Error in optimized dynamic weighted ensemble: {e}, using regular dynamic ensemble method.')
+                    pass
+
+            # pure Python fallback 
+            ensemble = np.zeros((B, n_classes))
+            for i in range(B):
+                trans_row = np.zeros(n_classes)
+                mlp_row   = np.zeros(n_classes)
+                trans_row[:n_trans] = trans_probs[i]
+                mlp_row[:n_mlp]     = mlp_probs[i]
+                trans_row /= trans_row.sum() + 1e-8
+                mlp_row   /= mlp_row.sum()   + 1e-8
+
+                trans_pred = int(np.argmax(trans_probs[i]))
+                mlp_pred   = int(np.argmax(mlp_probs[i]))
+                agreement  = 1.0 if trans_pred == mlp_pred else 0.3
+
+                attn         = attn_flat[i]
+                attn_focus   = float(np.std(attn)) if attn.size > 1 else 0.5
+                attn_growth  = 1.0 / (1.0 + np.exp(-attn_focus))
+                anisotropy   = self.anisotropy_measurement(attn.reshape(1, -1))
+                attn_limit   = (1.0 - attn_focus + attn_growth) * anisotropy
+                trans_cf     = attn_growth + attn_limit * attn_focus
+
+                mlp_entropy  = -np.sum(mlp_probs[i] * np.log(mlp_probs[i] + 1e-8))
+                mlp_cf       = 1.0 / (1.0 + mlp_entropy)
+
+                tw = trans_cf * (1.0 + agreement) / 2.0
+                mw = mlp_cf   * (1.0 + agreement) / 2.0
+
+                if has_lstm:
+                    lstm_row = np.zeros(n_classes)
+                    lstm_row[:n_lstm] = lstm_probs[i]
+                    lstm_row /= lstm_row.sum() + 1e-8
+                    lstm_pred = int(np.argmax(lstm_probs[i]))
+                    la = 1.0 if (lstm_pred == trans_pred or lstm_pred == mlp_pred) \
+                        else self.pipeline.confidence_threshold
+                    lw    = float(lstm_weight_hints[i]) * (1.0 + la) / 2.0
+                    total = tw + mw + lw + 1e-8
+                    ensemble[i] = (tw/total) * trans_row + \
+                                (mw/total) * mlp_row   + \
+                                (lw/total) * lstm_row
+                else:
+                    total = tw + mw + 1e-8
+                    ensemble[i] = (tw/total) * trans_row + (mw/total) * mlp_row
+
+            return ensemble
+        
+        except Exception as e:
+            print(f'[!] Cant do ensemble prediction due ensemble prediction due to: {e}, returning MLP probabilities')
+            return mlp_probs.copy()
 
-                total = trans_weight + mlp_weight + lstm_weight + 1e-8
-                trans_weight /= total
-                mlp_weight   /= total
-                lstm_weight  /= total
 
-                ensemble[i] = trans_weight * trans_row + mlp_weight * mlp_row + lstm_weight * lstm_row
-            else:
-                # original two-model path — unchanged
-                total = trans_weight + mlp_weight + 1e-8
-                trans_weight /= total
-                mlp_weight   /= total
-                ensemble[i] = trans_weight * trans_row + mlp_weight * mlp_row
-    
-        return ensemble
     
     def _attention_weighted_ensemble(self, trans_probs, mlp_probs, attn_weights):
 
@@ -11687,6 +11722,12 @@ class AccurateAnswerCache:
             flat_ids_a = self.pipeline._safe_to_2d_float(ids_a)
             flat_ids_b = self.pipeline._safe_to_2d_float(ids_b)
 
+            if flat_ids_a.shape != flat_ids_b.shape:
+                min_rows = min(flat_ids_a.shape[0], flat_ids_b.shape[0])
+                min_cols = min(flat_ids_a.shape[1], flat_ids_b.shape[1])
+                flat_ids_a = flat_ids_a[:min_rows, :min_cols]
+                flat_ids_b = flat_ids_b[:min_rows, :min_cols]                          
+
             return flat_ids_a, flat_ids_b
         except Exception as e:
             print(f'[!] cannot adapt indices shape due to: {e}')
@@ -11780,6 +11821,7 @@ class AccurateAnswerCache:
 
                     if ids_a.shape != ids_b.shape:
                         ids_a, ids_b = self._adapt_ids_shape(ids_a, ids_b)
+
                     min_len = min(len(ids_a), len(ids_b))
                     if min_len > 0:
                         seq_sim = float(np.mean(ids_a[:min_len] == ids_b[:min_len]))
@@ -13479,6 +13521,9 @@ class PipelineAsyncManager:
         try:
             attn_weights = None
             final_idx = None
+            attn_weight_rate = None
+            final_idx = None
+
             reverse_label_map = {v: k for k, v in label_map.items()}
 
             if 'attn_weights' in self.pipeline.model2.cache:
@@ -13506,8 +13551,14 @@ class PipelineAsyncManager:
                 result, chosen_label, confidence = self.advanced_prediction_method(
                     self.prediction_manager, test_titles, label_map, rules, 
                     X=X, y=y, method='Transformer_included')
-                if result and 'index' in result[0]:
-                    final_idx = result[0]['index']
+
+                try:
+                    if isinstance(result, list) and len(result) > 0:
+                        final_idx = result[0].get('index')
+                    elif isinstance(result, dict):
+                        final_idx = result.get('index')
+                except (KeyError, IndexError):
+                    final_idx = None
 
             print(f'[=+=] Local single advanced Prediction result: {result}')
 
@@ -13529,7 +13580,10 @@ class PipelineAsyncManager:
                         except IndexError:
                             calibrated_probs = probs + (1.0 - attn_weight_rate) * confidence 
                     else:
-                        calibrated_probs = probs + (1.0 - attn_weight_rate) * confidence 
+                        try:
+                            calibrated_probs = probs + (1.0 - attn_weight_rate) * confidence 
+                        except:
+                            calibrated_probs = calibrated_probs.copy()
 
                 predicted_index = np.argmax(calibrated_probs)  # Get index with highest probability
                 predicted_label = reverse_label_map.get(predicted_index, f"class_{predicted_index}")
@@ -13556,7 +13610,7 @@ class PipelineAsyncManager:
                 else:
                     print(f"[❌] INCORRECT LABEL (expected: {expected})")
 
-                predicted_output.append(f'{text} -> {predicted_label} With {confidence} Confidence')
+                predicted_output.append(f'{text} -> {predicted_label} With {confidence:.1%} Confidence')
 
             # Get stats
             print(f"[=] Stats: {self.get_stats()}")
@@ -15328,7 +15382,7 @@ class ConsecutivePeerAgent:
 
                     response = self._receive_message(sock)
 
-                    print(f'[ConsecutivePeerAgent] Got Authentication response from peer: {response} ')
+                    print(f'[ConsecutivePeerAgent] Got Authentication response from peer!')
                     if not response or response.get('status') != 'ok':
                         sock.close()
                         print('[ConsecutivePeerAgent] Socket is closed!')