AbstractIntegratedModule 1.1.0__tar.gz → 1.1.2__tar.gz

{abstractintegratedmodule-1.1.0 → abstractintegratedmodule-1.1.2}/AbstractIntegratedModule.egg-info/PKG-INFO

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

@@ -21,6 +21,7 @@ from collections import defaultdict
 import hashlib
 import ssl
 import os
+import glob
 import asyncio
 import queue
 import threading
@@ -1567,6 +1568,7 @@ class Transformer:
         acc   = float(np.mean(preds == true))
 
         return loss, acc
+
         
     def _sanitize_string_chars(self, x):
         if isinstance(x, (str, np.str_)):
@@ -2035,8 +2037,10 @@ class MLP:
             # re adapt shape of pred_counts and error_counts if they don't match prob shape
             if self.pred_counts.shape != prob.shape:
                 self.pred_counts = np.zeros_like(prob)
+                self.pred_counts *= decay
             if self.error_counts.shape != prob.shape:
                 self.error_counts = np.zeros_like(prob)
+                self.error_counts *= decay
 
         except Exception as e:
             print(f'[!] Cant check and calibrate probs based on penalty due to: {e}')    
@@ -2155,6 +2159,7 @@ class MLP:
         X = self._sanitize_string_chars(X)
         y = self._sanitize_string_chars(y)
         focused_fit_condition = False
+        parameters = sum(w.size for w in self.layers[0].W) + sum(b.size for b in self.layers[0].b)
 
         AME = self.AME_Encoder(X)     
         AMR = 1.0 / (1.0 + np.exp(-float(AME)))
@@ -2167,7 +2172,7 @@ class MLP:
         if training_not_allowed:
             print(f'[!] MLP Training not allowed due to unsuitable data characteristics. Anisotropy: {anisotropy:.4f}, AME: {AME:.4f}')
         else:
-            print('[+] MLP Training started...')
+            print(f'[+] MLP Training started with: {parameters} Parameters.')
             for epoch in range(epochs):
                 if not focused_fit_condition:
                     y_pred = self.forward(X, AME=AME, anisotropy=anisotropy)
@@ -3899,9 +3904,6 @@ class CrossSessionAutomation:
         print(f"✅ Session imported! Total memories: {len(self.pipeline.memory)}")
     
     def sync_with_another_device(self, device_ip, port=5000):
-        import socket
-        import pickle
-        
         # Export current session
         temp_file = self.export_session(f"sync_{self.session_id}")
         
@@ -3919,8 +3921,6 @@ class CrossSessionAutomation:
 
     
     def list_sessions(self, name):
-        import glob
-
         sessions = glob.glob(f"{name}*.json")
         
         print(f"\n📚 Available Sessions: {sessions}")
@@ -4267,7 +4267,7 @@ class ExplainabilityModule:
         if not self.learned_from_feedback:
             return
         
-        print(f"\n🔄 Consolidating {len(self.learned_from_feedback)} supervised memories...")
+        print(f"\n[🔄] Consolidating {len(self.learned_from_feedback)} supervised memories...")
         
         # Extract all supervised examples
         texts = [m['input'] for m in self.learned_from_feedback]
@@ -4523,7 +4523,7 @@ class ExplainabilityModule:
 
     def _compute_anisotropy(self, attn_weights):
         if attn_weights is None or len(attn_weights) == 0:
-            return 0.5
+            return self.pipeline.confidence_threshold
         
         try:
     
@@ -4537,7 +4537,7 @@ class ExplainabilityModule:
             return np.std(val) / (np.mean(val) + 1e-8)
 
         except:
-            return 0.5
+            return self.pipeline.confidence_threshold
     
     def _compute_attention_quality(self, attn_weights):
         eps = 1e-5
@@ -4568,9 +4568,9 @@ class ExplainabilityModule:
 
             quality = norm_entropy * (1.0 - AMR) + avg_max * AMR + norm_var * AMR
             return np.clip(quality, 0, 1)
-        except:
-            print("[-] Error occurred while computing attention quality.")
-            AMR = 0.1
+        except Exception as e:
+            print(f"[-] Error occurred while computing attention quality: {e}")
+            AMR = self.pipeline.confidence_threshold
             if attn_weights is not None:
                 print(f"[-] Attention weights shape: {attn_weights.shape}")
                 AME = self.AME_Encoder(attn_weights)
@@ -4680,19 +4680,19 @@ class ExplainabilityModule:
         d1 = self.decision_history[idx1]
         d2 = self.decision_history[idx2]
         
-        comparison.append(f"🔄 Decision Comparison")
+        comparison.append(f"🔄 Ensemble Decision Comparison")
         comparison.append("====================================")
         
-        comparison.append("[<] Earlier Decision:")
+        comparison.append("[<] Ensemble Earlier Decision:")
         comparison.append(f"[+] Input: {d1['input']}")
         comparison.append(f"[+] Detail Focus: {d1['prediction']} ({d1['confidence']:.1%})")
         
-        comparison.append("🧠 Later Decision:")
+        comparison.append("🧠 Ensemble Later Decision:")
         comparison.append(f"[=] Input: {d2['input']}")
         comparison.append(f"[=] Detail Focus: {d2['prediction']} ({d2['confidence']:.1%})")
         
-        comparison.append("🔬 Learning Progress: ")
-        comparison.append(f"• Confidence {'increased' if d2['confidence'] > d1['confidence'] else 'decreased'} from {d1['confidence']} to {d2['confidence']}")
+        comparison.append("🔬 Ensemble Learning Progress: ")
+        comparison.append(f"• Confidence {'increased' if d2['confidence'] > d1['confidence'] else 'decreased'} from {d1['confidence']:.1%} to {d2['confidence']:.1%}")
         comparison.append(f"• The model is becoming {'more' if d2['confidence'] > d1['confidence'] else 'less'} certain")
         
         return '\n'.join(comparison)
@@ -4709,9 +4709,9 @@ class ExplainabilityModule:
         
         # Check transformer confidence
         if details['transformer']['confidence'] > 0.8:
-            factors.append(f"✅ Transformer is confident ({details['transformer']['confidence']}) with focused attention")
+            factors.append(f"✅ Transformer is confident ({details['transformer']['confidence']:.1%}) with focused attention")
         elif details['transformer']['confidence'] < 0.5:
-            factors.append(f"🤔 Transformer is uncertain ({details['transformer']['confidence']}) due to scattered attention")
+            factors.append(f"🤔 Transformer is uncertain with uncertainty up to: ({details['transformer']['confidence']:.1%}), due to scattered attention")
         
         # Check agreement
         if details['agreement']:
@@ -4721,9 +4721,9 @@ class ExplainabilityModule:
         
         # Attention quality
         if details.get('attention_quality', 0) > 0.7:
-            factors.append(f"[✅] High attention quality ({details['attention_quality']}) indicates clear consistent patterns!")
+            factors.append(f"[✅] High attention quality: ({details['attention_quality']:.1%}) indicates clear consistent patterns!")
         elif details.get('attention_quality', 0) < 0.3:
-            factors.append(f"[-] Low Attention Quality! : ({details['attention_quality']}) Indicates noisy unnecessary patterns on seen data!")
+            factors.append(f"[-] Low Attention Quality: ({details['attention_quality']:.1%}) Indicates inconsistent and ambiguous patterns on seen data!")
         
         return '\n'.join(factors)
     
@@ -9177,6 +9177,7 @@ class QueryNode:
 
         return self.permission
 
+
     def _connect_with_peer(self, node):
         node_id = id(node)
 
@@ -9206,6 +9207,7 @@ class QueryNode:
 
         return self.permission
 
+
     def _adjust_trust(self, node_id, delta):
         """
         trust that actually evolves. EMA-style bounded adjustment.
@@ -9214,6 +9216,7 @@ class QueryNode:
         updated = float(np.clip(current + delta, 0.0, 1.0))
         self._trust_scores[node_id] = updated
 
+
     def _identify_node(self, node):
         eps = 1e-5
         node_id = id(node)
@@ -9237,6 +9240,7 @@ class QueryNode:
         ) + eps
         return False
 
+
     def _node_safety_check(self, node):
         node_id = id(node)
         trust   = self._trust_scores.get(node_id, self._default_trust)
@@ -12092,9 +12096,15 @@ class IntegratedPipeline:
             if 0 <= mlp_target < n_classes and i < calibrated.shape[0]:
                 if mlp_target_int is None:
                     mlp_target_int = int(mlp_target.flat[0])
-                calibrated[i, mlp_target_int] = min(
-                    calibrated[i, mlp_target_int] * (1.5 * (1.0 - abstract_score)), 0.95
-                )
+
+                if len(calibrated.shape) >= 2:
+                    calibrated[i, mlp_target_int] = min(
+                        calibrated[i, mlp_target_int] * (1.5 * (1.0 - abstract_score)), 0.95
+                    )
+                else:
+                    calibrated[mlp_target_int] = min(
+                        calibrated[mlp_target_int] * (1.5 * (1.0 - abstract_score)), 0.95
+                    )
 
             if i <= len(calibrated):
                 try:
@@ -13110,41 +13120,65 @@ class IntegratedPipeline:
         return unsuitable_training
 
     def sequence_encoding(self, datasets=None, label_map=None, max_len=32):
+        if not datasets:
+            raise Warning('[!] Dataset is None or empty! Make sure you provide a dataset or create it automatically.')
+
+        if not self.model2:
+            intents = [d[1] for d in datasets]
+            intent_to_id = {intent: i for i, intent in enumerate(sorted(set(intents)))}
+            num_classes = self._get_num_classes(label_map=label_map)
+            self.model2 = Transformer(
+                vocab_size=len(self.vocab),
+                d_model=self.transformer_d_model,
+                n_heads=self.transformer_heads,
+                num_classes=num_classes
+            )
+
+        self._sync_vocab_to_embedding()   # once, not per-item
+
+        vocab_size = self.model2.token_embedding.shape[0]   # for bounds guard
+
         input_sequences = []
+        for item in datasets:
+            text = item[0] if isinstance(item, tuple) else item
 
-        if datasets:
-            for item in datasets:
-                if not self.model2:
-                    intents = [d[1] for d in datasets]
-                    intent_to_id = {intent:i for i, intent in enumerate(sorted(set(intents)))}
-                    num_classes = self._get_num_classes(label_map=label_map)                
-                    self.model2 = Transformer(
-                        vocab_size=len(self.vocab),
-                        d_model=self.transformer_d_model,
-                        n_heads=self.transformer_heads,
-                        num_classes=num_classes
-                    ) 
-                    
-                self._sync_vocab_to_embedding()
-                text = item[0] if isinstance(item, tuple) else item
+            token_ids = self.encode(text, self.vocab, max_len=max_len)
+            token_ids = np.asarray(token_ids)
 
-                token_ids = self.encode(text, self.vocab, max_len=max_len)
-                token_embs = self.model2.token_embedding[token_ids]         # (max_len, d_model)
-                pos_embs = self.model2.pos_embedding[:max_len]              # (max_len, d_model)
+            # bounds guard before indexing, with informative context
+            out_of_bounds = (token_ids < 0) | (token_ids >= vocab_size)
+            if out_of_bounds.any():
+                n_bad = out_of_bounds.sum()
+                print(f'[⚠️] sequence_encoding: {n_bad} token id(s) out of '
+                    f'range [0, {vocab_size}) for text="{str(text)[:50]}" '
+                    f'— clamping to valid range. This usually means vocab '
+                    f'grew after model2 was constructed; consider rebuilding '
+                    f'model2 or resizing token_embedding.')
+                token_ids = np.clip(token_ids, 0, vocab_size - 1)
+
+            token_embs = self.model2.token_embedding[token_ids]
+            pos_embs   = self.model2.pos_embedding[:max_len]
+
+            sequence_input = token_embs + pos_embs
+            input_sequences.append(sequence_input)
+
+        return np.stack(input_sequences)
 
-                sequence_input = token_embs + pos_embs
-                input_sequences.append(sequence_input)
-            return np.stack(input_sequences)  # shape: (batch, max_len, d_model)
-        else:
-            raise Warning('[!] Dataset is None! make sure you provide a dataset or create it Automatically!')
-            
-            return None
 
     def transformer_pooled_features(self, sequence_inputs):
-        # mean/max/std pooling over sequence dimension
+        """Mean/max/std pooling over the sequence dimension."""
+        sequence_inputs = np.asarray(sequence_inputs)
+
+        # guard degenerate single-timestep input, where std=0
+        # everywhere is mathematically correct.
+        if sequence_inputs.shape[1] == 1:
+            print('[=] transformer_pooled_features: single-timestep input, '
+                'std_pool will be all zeros (no variance across T=1)')
+
         mean_pool = np.mean(sequence_inputs, axis=1)
-        max_pool = np.max(sequence_inputs, axis=1)
-        std_pool = np.std(sequence_inputs, axis=1)
+        max_pool  = np.max(sequence_inputs, axis=1)
+        std_pool  = np.std(sequence_inputs, axis=1)
+
         return np.concatenate([mean_pool, max_pool, std_pool], axis=-1)
 
     def _features_to_sequence(self, X_provided, d_model=None, min_seq_len=2):
@@ -13462,6 +13496,16 @@ class IntegratedPipeline:
             else:
                 self.vocab_size = 1
 
+            onehot_validation = self._validate_onehot(y)
+            if onehot_validation:
+                if n_classes != len(label_map):
+                    n_classes = len(label_map)
+                if n_classes > np.max(y):
+                    y = np.eye(n_classes)[np.asarray(y)]
+                else:
+                    print('[⚠️] Warning: Y onehot encoding fails, Returning Y samples as is, This may cause Exploding Gradient in MLP Training!')
+                    y = y.copy()
+
             if self.model2 is None:
                 self.model2 = Transformer(
                     vocab_size=self.vocab_size,
@@ -17127,6 +17171,42 @@ class PipelinePredictionManager:
 
         return X_train, X_val, y_train, y_val
 
+    def _compute_need_ensemble_method(self, anisotropy, AME, error_counts,
+                                    anisotropy_threshold=0.3,
+                                    ame_threshold=0.3,
+                                    error_threshold=0.3,
+                                    min_signals_required=1):
+        """
+        Ensemble fallback is a safety net — it should trigger if ANY
+        single strong risk signal fires, not only when all signals
+        happen to align simultaneously. Uses max() over error_counts
+        so a single persistently-wrong class triggers assistance even
+        when most other classes are healthy.
+        """
+        signals = []
+
+        if anisotropy is not None and anisotropy > anisotropy_threshold:
+            signals.append(f'anisotropy={anisotropy:.3f}')
+
+        if AME is not None and AME > ame_threshold:
+            signals.append(f'AME={AME:.3f}')
+
+        if error_counts is not None and len(error_counts) > 0:
+            # FIX — max, not mean: catches localized single-class failure
+            # that a flat average would dilute away
+            worst_class_idx = int(np.argmax(error_counts))
+            max_error = float(error_counts[worst_class_idx])
+            if max_error > error_threshold:
+                signals.append(f'error_rate(class={worst_class_idx}, '
+                            f'value={max_error:.2f})')
+
+        need_ensemble = len(signals) >= min_signals_required
+
+        if need_ensemble:
+            print(f'[=] Ensemble method triggered by: {", ".join(signals)}')
+
+        return need_ensemble
+
     def advanced_prediction_method(self, titles=None, label_map=None, rules=None,
                                 X=None, y=None,
                                 show_proba=False, top_k=3, 
@@ -17155,6 +17235,7 @@ class PipelinePredictionManager:
             X_gen = None
             sec_chosen_label = None
             sec_confidence = 0.0
+            final_confidence = 0.0
 
             correct = 0
             sec_correct= 0
@@ -17199,7 +17280,7 @@ class PipelinePredictionManager:
 
                 if 0 in X.shape:
                     print(f"[⚠️] Warning: X has zero samples in the total shapes, X shapes: {X.shape}. Creating an empty array with shape (1, n_features) for processing..")
-                    X = np.empty((1, X.shape[1]))  # Create an empty array with shape (1, n_features)
+                    X = np.empty((1, X.shape[1]))  # Created an empty array with shape (1, n_features)
                     X = X.reshape(1, -1)  # Reshape to (1, n_features) if empty but has features
 
                 X_train, X_val, y_train, y_val = self._prepare_train_val_split(
@@ -17336,7 +17417,7 @@ class PipelinePredictionManager:
             if hasattr(self.pipeline.mlp, 'predict_proba'):
                 mlp_probs = self.pipeline.model3.predict_proba(X)
             else:
-                logits = self.pipeline.mlp.forward(X)
+                logits = self.pipeline.model3.forward(X)
                 mlp_probs = self.pipeline._softmax(logits)
             
              # Validate all MLP predictions at once
@@ -17358,7 +17439,6 @@ class PipelinePredictionManager:
             if sequence_ids is not None:
                 print("\n[🔍] Using sequence encoding for transformer input due to low anisotropy.")
                 input_ids = sequence_ids.copy()
-
             # verify samples for accurate answer from cache
             print('[🔍] Verifying Samples for possible predicted output in cache for accurate answer...')
             cached = self.pipeline.accurate_cache_lookup.lookup(
@@ -17404,12 +17484,13 @@ class PipelinePredictionManager:
             else:
                 lstm_probs = None
 
-            need_ensemble_method = (
-                anisotropy > 0.3 and 
-                AME is not None and 
-                AME > 0.3 and
-                np.mean(self.error_counts) > 0.3 
-            )
+            
+            threshold = 0.5 + (self.pipeline.confidence_threshold + np.mean(self.error_counts)) / 2
+            need_ensemble_method = self._compute_need_ensemble_method(anisotropy, AME, self.error_counts,
+                                    anisotropy_threshold=threshold,
+                                    ame_threshold=threshold,
+                                    error_threshold=threshold,
+                                    min_signals_required=1)
             
             results = []
             attention_data = [] if return_attention else None
@@ -17722,7 +17803,7 @@ class PipelinePredictionManager:
                 if not results[0].get('models_agree', True) and self.pipeline.use_transformer:
                     trans_confidence = results[0].get('trans_confidence', 1e-8)
                     confidence = (confidence + trans_confidence / 2) + 1e-5
-                    print(f'[=] Calibrating confidence around: {confidence:.1%} Due to disagreement between Transformer and MLP.')
+                    print(f'[=] Calibrating confidence around: {confidence:.1%}')
                     
                 if isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
                     if chosen_label is None or chosen_label.startswith('unknown'):
@@ -17999,7 +18080,7 @@ class PipelinePredictionManager:
             print(f"[!] Error in advanced prediction method: {e}, Initiating regular prediction method...")
             traceback.print_exc()            
             try:
-                results = self.regular_prediction_method(titles=titles, label_map=label_map, rules=rules, X=X, y=y, show_proba=False, top_k=3, batch_size=2, use_transformer=True)
+                results = self.regular_prediction_method(titles=titles, label_map=label_map, rules=rules, X=X, y=y, show_proba=False, top_k=3, batch_size=2, use_transformer=self.pipeline.use_transformer)
                 chosen_label = results[0]['predicted']
                 confidence = results[0]['confidence']
             except Exception as error:
@@ -18040,7 +18121,7 @@ class PipelinePredictionManager:
         self.pred_counts  *= decay
 
         if final_probs is None:
-            print('[!] Warning final probabilities is None! returning the probabilities...')
+            print('[!] Warning final probabilities is None! returning the None probabilities...')
             return final_probs
 
         try:
@@ -18074,12 +18155,15 @@ class PipelinePredictionManager:
             prob_sum = final_probs.sum()
             if prob_sum > 1e-8:
                 final_probs /= prob_sum
-
+                
             # re adapt shape of pred_counts and error_counts if they don't match prob shape
             if self.pred_counts.shape != final_probs.shape:
                 self.pred_counts = np.zeros_like(final_probs)
+                self.pred_counts *= decay
             if self.error_counts.shape != final_probs.shape:
                 self.error_counts = np.zeros_like(final_probs)
+                self.error_counts *= decay
+                
 
         except Exception as e:
             print(f'[!] Cant check and calibrate probs based on penalty due to: {e}')