AbstractIntegratedModule 0.9.6__tar.gz → 0.9.7__tar.gz

{abstractintegratedmodule-0.9.6 → abstractintegratedmodule-0.9.7}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.6
+Version: 0.9.7
 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.9.6 Official Release.
+- Development Stage: 0.9.7 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.

{abstractintegratedmodule-0.9.6 → abstractintegratedmodule-0.9.7}/AbstractIntegratedModule.py

@@ -1950,10 +1950,7 @@ class MLP:
 
                     if isinstance(self.pred_counts[c], (int, float)) and self.pred_counts[c] > 0:
                         error_rate    = self.error_counts[c] / (self.pred_counts[c] + 1e-8)
-                        # sigmoid-shaped dampening — never goes negative
-                        # error_rate=0.0 → multiplier=1.0 (no change)
-                        # error_rate=0.5 → multiplier≈0.67
-                        # error_rate=1.0 → multiplier≈0.5
+                    
                         reputation    = 1.0 / (1.0 + error_rate)
                         if c < len(prob):
                             prob[c]  *= reputation
@@ -3173,8 +3170,6 @@ class WeightedEnsemblePredictor:
     
     
 
-
-
     def explainability_prediction_batch(self, texts, mlp_probs, trans_probs, attn_weights, show_explanation=False):
         results = []
         for text in texts:
@@ -3186,7 +3181,6 @@ class WeightedEnsemblePredictor:
         return results
     
 
-     
 
     def predict_ensemble(self, input_ids, X_mlp, y_true, method='dynamic', embedded=False):
         label_bins=None
@@ -3235,7 +3229,9 @@ class WeightedEnsemblePredictor:
         elif method == 'meta':
             # Meta-learner that decides weights
             ensemble_probs = self._meta_ensemble(
-                trans_probs, mlp_probs, attn_weights, X_mlp
+                trans_probs, mlp_probs, attn_weights, X_mlp,
+                lstm_probs=lstm_probs,
+                lstm_weight_hint=lstm_weight_hint
             )
         
         elif method == 'calibration':
@@ -3439,7 +3435,6 @@ class WeightedEnsemblePredictor:
 
     
     def _attention_weighted_ensemble(self, trans_probs, mlp_probs, attn_weights):
-
         if attn_weights is None:
             return (trans_probs + mlp_probs) / 2
         
@@ -3448,8 +3443,8 @@ class WeightedEnsemblePredictor:
 
         n_trans_classes = trans_probs.shape[1]        
         n_mlp_classes = mlp_probs.shape[1]
-        n_classes = max(n_trans_classes, n_mlp_classes)
-
+        
+        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)
@@ -3486,35 +3481,65 @@ class WeightedEnsemblePredictor:
         
         return ensemble
     
-    def _meta_ensemble(self, trans_probs, mlp_probs, attn_weights, X_mlp):
+    def _meta_ensemble(self, trans_probs, mlp_probs, attn_weights, X_mlp, 
+                         lstm_probs=None, lstm_weight_hint=0.0):
+        lstm_row = None
+
         batch_size = trans_probs.shape[0]
         n_classes = trans_probs.shape[1]
         threshold_feature = 0.1 + self.pipeline.confidence_threshold
 
         n_trans_classes = trans_probs.shape[1]        
         n_mlp_classes = mlp_probs.shape[1]
-        n_classes = max(n_trans_classes, n_mlp_classes)
+
+        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:
+            lstm_probs = np.zeros((B, 1), dtype=np.float64)  # dummy, not used
+            n_lstm = 0
+ 
+        n_classes = max(n_trans_classes, n_lstm, n_mlp_classes)
+        print(f"🔄 Aligning classes: trans={n_trans_classes} mlp={n_mlp_classes} "
+            f"lstm={n_lstm} → {n_classes}") 
 
         # Create meta features
         meta_features = []
         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]
-            
+            if has_lstm:
+                lstm_row = np.zeros(n_classes)
+                lstm_row[:n_lstm] = lstm_probs[i]
+                lstm_row = lstm_row / (lstm_row.sum() + 1e-8)
+
             trans_row = trans_row / (trans_row.sum() + 1e-8)
             mlp_row = mlp_row / (mlp_row.sum() + 1e-8)
 
-            features = [
-                np.max(trans_row),           # Transformer confidence
-                np.max(mlp_row),              # MLP confidence
-                np.std(trans_row),             # Transformer spread
-                np.std(mlp_row),               # MLP spread
-                1.0 if np.argmax(trans_row) == np.argmax(mlp_row) else 0.0,  # Agreement
-            ]
-            
+            if lstm_row is None:
+                features = [
+                    np.max(trans_row),           # Transformer confidence
+                    np.max(mlp_row),              # MLP confidence
+                    np.std(trans_row),             # Transformer spread
+                    np.std(mlp_row),               # MLP spread
+                    1.0 if np.argmax(trans_row) == np.argmax(mlp_row) else 0.0,  # Agreement
+                ]
+            else:
+                features = [
+                    np.max(trans_row),           # Transformer confidence
+                    np.max(mlp_row),              # MLP confidence
+                    np.max(lstm_row),
+                    np.std(trans_row),             # Transformer spread
+                    np.std(mlp_row),               # MLP spread
+                    np.std(lstm_row),
+                    1.0 if np.argmax(trans_row) == np.argmax(mlp_row) else 0.0,  # Agreement
+                ]    
+
             # Add attention stats if available
             if attn_weights is not None and i < len(attn_weights):
                 attn = attn_weights[i]
@@ -3540,6 +3565,9 @@ class WeightedEnsemblePredictor:
             mlp_conf = meta_features[i, 1]
             agreement = meta_features[i, 4]
             
+            trans_pred = int(np.argmax(trans_probs[i]))
+            mlp_pred   = int(np.argmax(mlp_probs[i])) 
+                                  
             # Boost weight when models agree
             base_weight = threshold_feature + AME_sigmoid * agreement
             
@@ -3550,11 +3578,26 @@ class WeightedEnsemblePredictor:
             else:
                 trans_weight = 1.0 - base_weight
                 mlp_weight = base_weight
-
-            try:
-                ensemble[i] = trans_weight * trans_row + mlp_weight * mlp_row
-            except:
-                ensemble = trans_weight * trans_row + mlp_weight * mlp_row                
+                
+            if has_lstm:
+                if lstm_row is None:
+                    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 = trans_weight + mlp_weight + lw + 1e-8
+                ensemble[i] = (trans_weight/total) * trans_row + \
+                            (mlp_weight/total) * mlp_row   + \
+                            (lw/total) * lstm_row
+            else:
+                try:
+                    ensemble[i] = trans_weight * trans_row + mlp_weight * mlp_row 
+                except:
+                    ensemble = trans_weight * trans_row + mlp_weight * mlp_row                
         
         return ensemble
     
@@ -5962,7 +6005,7 @@ class AsyncMessageQueue:
     async def publish(self, message: Message) -> Any:
         await self._ensure_started()
 
-        # plain increment, no lock needed (no await in critical section)
+        # plain increment
         self._counter += 1
         counter = self._counter
         
@@ -15474,7 +15517,7 @@ class PipelinePredictionManager:
             if titles is not None and rules is not None:
                 print(f"[🔍] Preparing data for {len(titles)} titles with {len(rules)} length of rules.")
                 if X is None and y is None or X is None or y is None:
-                    print('[🔄] Creating automatic X samples because X is not provided manually.')
+                    print('[🔄] Creating automatic X samples because X Samples is not provided manually.')
                     datasets, X_gen = self.pipeline.data_preparation(titles, label_map)  
                     _, y, _, _ = self.pipeline.mlp_training_features(rules, datasets)                  
                 else:
@@ -15735,7 +15778,7 @@ class PipelinePredictionManager:
         num_classes = num_classes or mlp_probs.shape[1]
         models_agree = False
 
-        # ── MLP ─────────────────────────────────────────────
+        # ── MLP layer ─────────────────────────────────────────────
         mlp_class_idx  = int(np.argmax(mlp_probs[i]))
         is_valid_index = 0 <= mlp_class_idx < num_classes
 
@@ -15891,6 +15934,7 @@ class PipelinePredictionManager:
                                 use_transformer=True, return_attention=False,
                                 save_results=True, batch_size=2):
         try:
+            # ____ init temporary layer ____
             eps = 1e-5
             trans_probs = None
             attn_weights = None