AbstractIntegratedModule 0.8.4__tar.gz → 0.8.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.8.4
+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.4 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,10 +80,9 @@ 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.4:
+     - v0.8.5:
         - [=] New features: 
-        - Added more robust inhomogenous shape handling for handling input_ids in Transformer and AccurateAnswerCache architecture.
-        - Added improvements for handling batch prediction responses, ensuring robust references and graceful conditions for edge cases.
+        - 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

{abstractintegratedmodule-0.8.4 → 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):
 
@@ -13575,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()}")