AbstractIntegratedModule 1.1.2__tar.gz → 1.1.4__tar.gz

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

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

@@ -485,12 +485,12 @@ class GeometricWeightShaping:
             subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
             gradient = np.gradient(subnet.flatten())
 
-        grad_energy = np.mean(np.linalg.norm(gradient, axis=-1))       
+        mean_vector_mag  = np.mean(np.linalg.norm(gradient, axis=-1))       
         X_mag = np.mean(np.linalg.norm(X, axis=-1))
         # Regular AME Equations, higher AME provides capabilities for the model to experience errors during abstraction
         # Lower AME means lower chance for un optimal abstraction.
 
-        AME =  np.log1p(X_mag) * np.log1p(grad_energy) 
+        AME =  np.log1p(X_mag) * np.log1p(mean_vector_mag) 
         return AME
 
     # anisotropy provides the model the standard complexity of the data geometry, allowing it to know how complex the data needs to be processed.
@@ -1920,6 +1920,48 @@ class MLP:
             
         return self.softmax.forward(x) 
 
+    def k_fold_split(self, X, y, k=5, seed=42, min_fold_size=2):
+        X = np.asarray(X)
+        y = np.asarray(y)
+        n = len(X)
+
+        # adapt k downward for small datasets, never produce
+        # folds smaller than min_fold_size
+        effective_k = min(k, max(2, n // min_fold_size))
+        if effective_k < k:
+            print(f'[⚠️] k_fold_split: reduced k from {k} to {effective_k} '
+                f'for n={n} samples, to avoid folds smaller than '
+                f'{min_fold_size} samples')
+
+        rng = np.random.default_rng(seed)
+        idx = rng.permutation(n)
+        folds = np.array_split(idx, effective_k)
+
+        for i in range(effective_k):
+            val_idx = folds[i]
+            train_idx = np.concatenate([folds[j] for j in range(effective_k) if j != i])
+            yield X[train_idx], y[train_idx], X[val_idx], y[val_idx]
+
+
+    def confusion_matrix(self, y_true, y_pred, num_classes):
+        y_true = np.asarray(y_true)
+        y_pred = np.asarray(y_pred)
+
+        cm = np.zeros((num_classes, num_classes), dtype=int)
+
+        # Convert to label arrays: use argmax only if input is one-hot/prob (2D+),
+        # otherwise need to treat as already being class labels.
+        true_labels = np.argmax(y_true, axis=1) if y_true.ndim > 1 else y_true
+        pred_labels = np.argmax(y_pred, axis=1) if y_pred.ndim > 1 else y_pred
+
+        for t, p in zip(true_labels, pred_labels):
+            if 0 <= t < num_classes and 0 <= p < num_classes:
+                cm[t, p] += 1
+            else:
+                print(f'[⚠️] confusion_matrix: label out of range '
+                    f'(true={t}, pred={p}, num_classes={num_classes}) — skipped')
+        return cm
+            
     def performance_calculation(self, x, AME=None, anisotropy=None):
         eps = 1e-5
         standard_low_error_mean = eps
@@ -1943,7 +1985,7 @@ class MLP:
 
         return performance_score
 
-    def forward(self, x, AME=None, anisotropy=None):
+    def forward(self, x, y=None, AME=None, anisotropy=None, condition=None):
         eps = 1e-5
         performance_score = self.performance_calculation(x, AME=AME, anisotropy=anisotropy)
 
@@ -1951,6 +1993,11 @@ class MLP:
             x = layer.forward(x, performance_score)
 
         output = self.softmax.forward(x)
+        if not condition == 'training' and y is not None:
+            if y.shape == output.shape:
+                acc = np.mean(np.argmax(output, axis=1) == np.argmax(y, axis=1))
+                loss = Loss.categorical_crossentropy(y, output)
+                print(f"[=] MLP Forward validation score: | loss: {loss:.4f} | Acc: {acc:.2%}")
 
         return output
         
@@ -2175,7 +2222,7 @@ class MLP:
             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)
+                    y_pred = self.forward(X, y=y, AME=AME, anisotropy=anisotropy, condition='training')
                 else:
                     y_pred = self.focused_forward(X, AME=AME, anisotropy=anisotropy)
 
@@ -3402,7 +3449,7 @@ class WeightedEnsemblePredictor:
         AME = self.pipeline.model2.AME_Encoder(input_ids)
 
         trans_probs, attn_weights = self.pipeline.model2.forward(input_ids, AME=AME, embedded=embedded)
-        mlp_probs = self.pipeline.model3.forward(X_mlp)
+        mlp_probs = self.pipeline.model3.forward(X_mlp, y=y_true)
         lstm_probs, lstm_weight_hint = self._get_lstm_probs(input_ids, X_mlp, label_bins=label_bins)
 
         established_agreement = self.query_node._establish_node_connection("PredictEnsemble")
@@ -4447,9 +4494,8 @@ class ExplainabilityModule:
             print('[=] Note: Very little Consistency meaning Transformer attention quality is Healthy and focused')
 
         if isinstance(final_conf, np.ndarray):
-            final_conf = 1.0 / (1.0 + np.std(final_conf))
-            # growth deviation of arrayed final confidence helped to distinguish noise from unnecessary distribution, 
-            # with real covariance of distribution from the data.
+            final_conf = 1.0 / (1.0 + np.exp(-final_conf))
+            # Apply a sigmoid transformation to ensure the confidence is between 0 and 1
 
         if np.isnan(final_conf).any() or np.isinf(final_conf).any():
             final_conf = self.pipeline.confidence_threshold
@@ -5944,10 +5990,13 @@ class ModelStorage:
 
         try:
             weights = result
-            self.pipeline.network_model.cell.W  = np.array(weights['lstm_W'])
-            self.pipeline.network_model.cell.b  = np.array(weights['lstm_b'])
-            self.pipeline.network_model.Wy      = np.array(weights['Wy']) if weights['Wy'] else None
-            self.pipeline.network_model.by      = np.array(weights['by'])
+            if isinstance(weights, str):
+                weights = json.loads(weights)
+            
+            self.pipeline.network_model.cell.W  = np.array(weights.get('lstm_W'))
+            self.pipeline.network_model.cell.b  = np.array(weights.get('lstm_b'))
+            self.pipeline.network_model.Wy      = np.array(weights.get('Wy')) if weights.get('Wy') else None
+            self.pipeline.network_model.by      = np.array(weights.get('by'))
             self.pipeline.lstm_engine.residual_mean = weights.get('residual_mean', 0.0)
             self.pipeline.lstm_engine.residual_std  = weights.get('residual_std',  1.0)
             self.pipeline.lstm_engine.n_samples     = weights.get('n_samples', self.pipeline.lstm_engine.n_samples)
@@ -5963,6 +6012,7 @@ class ModelStorage:
 
         except Exception as e:
             print(f'[!] Cant load any Weights due to: {e}')
+            traceback.print_exc()
 
 
     def load_transformer_dict(self, memory_name):
@@ -9544,6 +9594,10 @@ class IntegratedPipeline:
         self.lstm_lr = 5e-2
         self.lstm_hidden_dim = 64
 
+        self.unsuitable_tolerance = False
+        self.unsuitable_conditions = False
+        self.unsuitable_peer_request  = False
+
         # Main component setup
         self.standard_scaler = StandardScaler()
         self.tfidf = TfidfVectorizer(max_features=70)
@@ -9818,6 +9872,133 @@ class IntegratedPipeline:
                 f"Unexpected memory type: {type(memory).__name__}",
                 "Clear and reinitialize memory")
 
+    def k_fold_cross_validate(self, X, y, input_dim, n_classes, k=5, seed=42,
+                            epochs=None, lr=None, log_to_diagnostics=True):
+        """
+        Orchestrates init → train → predict across k folds. Each fold gets
+        a FRESH model (no weight carryover between folds), and the model
+        that existed before k-fold started is restored afterward — k-fold
+        here is purely an evaluation procedure, not a permanent side effect.
+        """
+        X = np.asarray(X)
+        y = np.asarray(y)
+
+        # preserve pre-existing model, restore it once CV is done
+        original_model = getattr(self, 'model3', None)
+
+        recorder = None
+        if log_to_diagnostics:
+            try:
+                from abstract_diagnostics import get_recorder
+                recorder = get_recorder(self.memory_name)
+            except ImportError:
+                pass   # diagnostics package not installed — silently skip, no crash
+
+        aggregate_cm    = np.zeros((n_classes, n_classes), dtype=int)
+        fold_accuracies = []
+
+        for fold_idx, (X_tr, y_tr, X_val, y_val) in enumerate(
+            self.model3.k_fold_split(X, y, k=k, seed=seed)
+        ):
+            # FRESH model every fold — this is the load-bearing line
+            self.initialize_model_(X_tr, input_dim, n_classes)
+            self.model3.train(X_tr, y_tr,
+                            epochs=epochs or self.mlp_training_epochs,
+                            lr=lr or self.mlp_lr)
+
+            y_pred = self.model3.forward(X_val)
+            cm = self.model3.confusion_matrix(y_val, y_pred, n_classes)
+            aggregate_cm += cm
+
+            fold_acc = np.trace(cm) / max(cm.sum(), 1)
+            fold_accuracies.append(fold_acc)
+            print(f'[=] Fold {fold_idx + 1}/{k}: accuracy={fold_acc:.2%}')
+
+            if recorder:
+                recorder.log_scalar('mlp/kfold_accuracy', fold_acc, step=fold_idx)
+
+        self.model3 = original_model   # restore — CV was evaluation only
+
+        mean_acc, std_acc = float(np.mean(fold_accuracies)), float(np.std(fold_accuracies))
+        print(f'[=] K-Fold CV complete: {mean_acc:.2%} ± {std_acc:.2%}')
+
+        if recorder:
+            recorder.log_scalar('mlp/kfold_mean_accuracy', mean_acc)
+            recorder.log_scalar('mlp/kfold_std_accuracy', std_acc)
+
+        return {
+            'fold_accuracies': fold_accuracies,
+            'mean_accuracy': mean_acc,
+            'std_accuracy': std_acc,
+            'confusion_matrix': aggregate_cm,
+        }
+
+    def evaluate_mlp_performance(self, X, y, label_map, k=5, seed=42):
+        """
+        input_dim and n_classes are ALWAYS derived from the actual X/y
+        given to this call — never accepted as separate parameters that
+        could silently drift out of sync with the real data (the exact
+        bug class this whole session was about).
+        """
+        X = np.asarray(X)
+        y = np.asarray(y)
+
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+
+        # derived input_dim directly from X, matching this call's
+        # ACTUAL data.
+        input_dim = X.shape[1]
+        model_classes = self._get_num_classes()
+
+        #derived n_classes the same authoritative way used
+        # throughout the rest of the pipeline (_get_num_classes as
+        # primary source, cross-checked against y itself)
+
+        y_arr = np.asarray(y)
+
+        onehot_validation = self._validate_onehot(y)
+        if onehot_validation:
+            if model_classes != len(label_map):
+                model_classes = len(label_map)
+            if model_classes > np.max(y):
+                y = np.eye(model_classes)[np.asarray(y)]
+            else:
+                print('[⚠️] Warning: Proper Y onehot encoding fails, modifying number of classes to exactly match Y values to do one final one hot encoding...')
+                try:
+                    model_classes = np.max(y) + 1
+                    y = np.eye(model_classes)[np.asarray(y)]
+                except:
+                    print('[!] Error: One hot encoding failed, please check your Y values and label map for consistency, passing raw Y and skipping MLP Training...')
+                    unsuitable = True
+                    y = y.copy()  # fallback to raw y if one-hot fails
+
+        if y_arr.ndim > 1:
+            n_classes_from_y = y_arr.shape[1]
+        else:
+            n_classes_from_y = int(y_arr.max()) + 1
+
+        if model_classes is not None and model_classes != n_classes_from_y:
+            print(f'[⚠️] evaluate_mlp_performance: n_classes mismatch — '
+                f'model reports {model_classes}, y data implies '
+                f'{n_classes_from_y}. Using y-derived value ({n_classes_from_y}) '
+                f'since k-fold must match the ACTUAL labels being evaluated.')
+        n_classes = n_classes_from_y
+
+        print(f'[=] evaluate_mlp_performance: derived input_dim={input_dim}, '
+            f'n_classes={n_classes} from provided X/y (shapes: '
+            f'X={X.shape}, y={y_arr.shape})')
+
+        result = self.k_fold_cross_validate(X, y, input_dim, n_classes, k=k, seed=seed)
+
+        print('========= MLP Performance Evaluation Summary ============')
+        print(f'[=>] MLP performance evaluation complete: mean accuracy={result["mean_accuracy"]:.2%}, '
+              f'std accuracy={result["std_accuracy"]:.2%}')
+        print(f'[=>] Confusion matrix:\n{result["confusion_matrix"]}')
+        print(f'[=>] Fold accuracies: {result["fold_accuracies"]}')
+        print(f'[=>] K-Fold CV complete: {result["mean_accuracy"]:.2%} ± {result["std_accuracy"]:.2%}')
+        return result
+
 
     def _validate_tuple_memory(self, memory: tuple, num_classes: int) -> tuple:
         """
@@ -11501,7 +11682,7 @@ class IntegratedPipeline:
                     method='dynamic', embedded=embedded
                 )
             else:
-                fresh_probs = self.model3.forward(fresh_X_raw)
+                fresh_probs = self.model3.forward(fresh_X_raw, y=y_true)
                 try:
                     fresh_trans_probs, _ = self.model2.forward(fresh_input_ids, embedded=False)
                 except:
@@ -12102,9 +12283,12 @@ class IntegratedPipeline:
                         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 mlp_target_int < len(calibrated):
+                        calibrated[mlp_target_int] = min(
+                            calibrated[mlp_target_int] * (1.5 * (1.0 - abstract_score)), 0.95
+                        )
+                    else:
+                        calibrated = min(calibrated * (1.5 * (1.0 - abstract_score)), 0.95)
 
             if i <= len(calibrated):
                 try:
@@ -12513,7 +12697,7 @@ class IntegratedPipeline:
                         lengths.add(1)
 
                 if len(lengths) > 1:
-                    # RAGGED — pad to uniform length 
+                    # RAGGED — pad to uniform length.
                     max_len = max(lengths)
                     print(f'[=] AME_Encoder: ragged input detected '
                         f'(lengths: {lengths}) — padding to {max_len}')
@@ -12871,6 +13055,7 @@ class IntegratedPipeline:
 
         return float(np.asarray(arr).flat[-1])  # ultimate fallback, never crashes
 
+
     def _get_ensemble_confidence_for_true_class(self, X, Y, input_ids=None, eps=1e-3):
         """
         Computes, per sample, how confident the MLP + Transformer ensemble
@@ -12914,7 +13099,7 @@ class IntegratedPipeline:
                 if X.shape != self.model3.layers[0].W.shape:
                     X = np.reshape(X, (n_samples, self.model3.layers[0].W.shape[0]))
         
-                mlp_probs = np.asarray(self.model3.forward(X), dtype=np.float64)
+                mlp_probs = np.asarray(self.model3.forward(X, y=Y), dtype=np.float64)
                 if mlp_probs.ndim == 1:
                     mlp_probs = mlp_probs.reshape(1, -1)
             except Exception as e:
@@ -12980,6 +13165,7 @@ class IntegratedPipeline:
 
         return confidences
 
+
     def lstm_setup_inference(self, raw_X, raw_Y, input_ids=None):
         print("\n" + "=" * 55)
         print("===== LSTM SETUP INFERENCE =====")
@@ -13086,6 +13272,10 @@ class IntegratedPipeline:
         unsuitable_training = False
 
         probs = self.model_memory_gate(input_ids, x)
+        cache = self.accurate_cache_lookup.lookup(
+                x_mlp=x, 
+                input_ids=input_ids)
+        cached = cache is not None and cache['similarity'] >= 0.95
 
         anisotropy = self.anisotropy_measurement(input_ids)
         AME = self.AME_Encoder(input_ids)
@@ -13104,11 +13294,15 @@ class IntegratedPipeline:
         # AMR is guaranteed to give sufficient ratio on how modelling error error could be sufficient enough to guarantee the model successful training 
         # (not too high that it shows unstability, not too low that it shows rigidity), high anisotropy correlates to a much complex non linearity that the model will have a hard time adjusting
         # Too high AAC means the model is likely to be in a regime where training could lead to overfitting or divergence due to insufficient modelling capacity relative to the complexity of the data, especially if the confidence score is also low, indicating that the model is not currently confident in its predictions and may not benefit from further training on this data.
-        unsuitable_tolerance = probs is not None or AAC > 0.75
+        unsuitable_tolerance = probs is not None and cached or AAC > 0.75
         unsuitable_conditions = anisotropy > 0.85 or final_conf > confidence_threshold or self.froze_learning
         unsuitable_peer_request = probs is not None and self.peer_assistance_threshold > self.confidence_threshold
 
-        if unsuitable_tolerance or unsuitable_conditions or unsuitable_peer_request:
+        self.unsuitable_tolerance = unsuitable_tolerance
+        self.unsuitable_conditions = unsuitable_conditions
+        self.unsuitable_peer_request  = unsuitable_peer_request
+
+        if self.unsuitable_tolerance or self.unsuitable_conditions or self.unsuitable_peer_request:
             print(f'[==] Unsuitable training condition detected! Tolerance: {unsuitable_tolerance} || Unsuitable Conditions: {unsuitable_conditions}')
             print(f'[==] Peer assistance condition: {unsuitable_peer_request} || Peer assistance threshold: {self.peer_assistance_threshold}')
             unsuitable_training = True
@@ -13174,6 +13368,8 @@ class IntegratedPipeline:
         if sequence_inputs.shape[1] == 1:
             print('[=] transformer_pooled_features: single-timestep input, '
                 'std_pool will be all zeros (no variance across T=1)')
+            print('[=] Reshaping sequence inputs to 2 dimension...')
+            sequence_inputs = sequence_inputs.reshape(-1, 1)
 
         mean_pool = np.mean(sequence_inputs, axis=1)
         max_pool  = np.max(sequence_inputs, axis=1)
@@ -13207,6 +13403,7 @@ class IntegratedPipeline:
 
         if isinstance(X_provided, (str, np.str_)):
             X_provided = _safe_parse_string(X_provided)
+    
 
         if isinstance(X_provided, np.ndarray) and np.issubdtype(X_provided.dtype, np.character):
             joined = ' '.join(X_provided.astype(str).flatten())
@@ -13299,7 +13496,7 @@ class IntegratedPipeline:
 
         issues = []
 
-        # 1. Values outside [0, 1] — catches your [5,3,1,4,3,2] case directly
+        # 1. Values outside [0, 1].
         out_of_range = (y_true < 0) | (y_true > 1)
         if out_of_range.any():
             bad_rows = np.where(out_of_range.any(axis=1))[0]
@@ -13332,7 +13529,7 @@ class IntegratedPipeline:
             )
 
         if issues:
-            print(f"[WARNING] [{context}] y_true failed one-hot validation, one-hot encoding y sample...")
+            print(f"[>] [{context}] y sample is not properly one-hot encoded, one-hot encoding y sample...")
             return True
 
         return False
@@ -13341,6 +13538,7 @@ class IntegratedPipeline:
     def transformer_utilities(self, X_provided= None, X_raw=None, y_true=None, rules=None, 
                               datasets=None, label_map=None, batch_size=2, min_signal=1e-3,
                               max_samples_for_focused_fit=500):
+        unsuitable = False
         if X_provided is not None:
             X_raw = X_provided
 
@@ -13443,7 +13641,7 @@ class IntegratedPipeline:
             weak_rows = np.where(row_sums < min_signal)[0]
             weak_ratio = len(weak_rows) / len(X_raw_features)
 
-            print(f'[!] Zero ratio in samples: {weak_ratio * 100}%')
+            print(f'[>] Zero ratio in samples: {weak_ratio * 100}%')
             if weak_ratio > 0.3:  # more than 30% zero rows means vocab mismatch
                 if isinstance(X_raw_generation[0], str):
                     print(f'[= ! =] High zero-row ratio ({weak_ratio:.0%}), refitting on current batch')
@@ -13503,8 +13701,14 @@ class IntegratedPipeline:
                 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()
+                    print('[⚠️] Warning: Proper Y onehot encoding fails, modifying number of classes to exactly match Y values to do one final one hot encoding...')
+                    try:
+                        n_classes = np.max(y) + 1
+                        y = np.eye(n_classes)[np.asarray(y)]
+                    except:
+                        print('[!] Error: One hot encoding failed, please check your Y values and label map for consistency, passing raw Y and skipping MLP Training...')
+                        unsuitable = True
+                        y = y.copy()  # fallback to raw y if one-hot fails
 
             if self.model2 is None:
                 self.model2 = Transformer(
@@ -13517,9 +13721,15 @@ class IntegratedPipeline:
             if self.use_transformer:
                 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)         
+            X = self.shape_adaptation(hybrid_X, input_dim)      
+
+
             self.initialize_model_(X, input_dim, n_classes)
-            self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=self.mlp_lr, max_samples_for_focused_fit=max_samples_for_focused_fit)
+            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)
+            else:
+                print('[->] MLP Training skipped due to unproper Y samples.')
+
             self.lstm_setup_inference(X, y, input_ids=sequence_inputs) 
             if self.lstm_engine:
                 self.storage.save_weights(self.memory_name, model_type='Pipeline') 
@@ -13527,7 +13737,7 @@ class IntegratedPipeline:
             print('🎉 All Model Trained!')
         else:
             print(f'[=] No suitable condition for training!')
-            print('[=] Saving Weights for prediction')
+            print('[>] Loading Weights for prediction...')
 
             num_classes = self._get_num_classes(label_map=label_map) if label_map else (y_true.shape[1] if y_true.ndim > 1 else len(np.unique(y_true)))
 
@@ -16369,15 +16579,8 @@ class PipelinePredictionManager:
                 X_tfidf = X
 
             # Forward pass through MLP
-            if hasattr(self.pipeline.mlp, 'predict_proba'):
-                if X_tfidf is None:
-                    X_tfidf = X
-                mlp_probs = self.pipeline.model3.predict_proba(X)
-            else:
-                # Fallback if predict_proba not available
-                logits = self.pipeline.model3.forward(X)
-                mlp_probs = self.pipeline._softmax(logits)
-                
+            mlp_probs = self.pipeline.model3.forward(X, y=y)
+           
             # Validate all MLP predictions at once
             mlp_pred_indices = np.argmax(mlp_probs, axis=1)
             if num_classes <= 0:
@@ -17414,12 +17617,8 @@ class PipelinePredictionManager:
                     X = np.asarray(X)
                 
             # MLP forward pass  
-            if hasattr(self.pipeline.mlp, 'predict_proba'):
-                mlp_probs = self.pipeline.model3.predict_proba(X)
-            else:
-                logits = self.pipeline.model3.forward(X)
-                mlp_probs = self.pipeline._softmax(logits)
-            
+            mlp_probs = self.pipeline.model3.forward(X, y=y_val)
+          
              # Validate all MLP predictions at once
             mlp_pred_indices = np.argmax(mlp_probs, axis=1)
             if num_classes <= 0:
@@ -17554,7 +17753,9 @@ class PipelinePredictionManager:
                 
                     # Transformer prediction and blending
                     if trans_probs is not None and attn_weights is not None:
-                        trans_probs_i = trans_probs[i]
+                        if i < len(trans_probs):
+                            trans_probs_i = trans_probs[i]
+
                         trans_class_idx = np.argmax(trans_probs_i)
                         if isinstance(trans_probs_i, float):
                             trans_confidence = target_confidence
@@ -17632,7 +17833,10 @@ class PipelinePredictionManager:
                             agreement = mlp_class_idx == trans_class_idx
 
                     else:
-                        final_probs = mlp_probs[i]
+                        if i < len(mlp_probs):
+                            final_probs = mlp_probs[i]
+                        else:
+                            final_probs = mlp_probs[0]
 
                         final_class_idx = target_class_idx
                         final_confidence = target_confidence[0] if isinstance(target_confidence, np.ndarray) else target_confidence
@@ -17817,9 +18021,11 @@ class PipelinePredictionManager:
                     'X_samples': X,
                     'input_ids': input_ids
                 }
+                print('[=] Displaying Test Performance Results....')
                 if titles is not None and len(titles) > 0:
                     correct, sec_correct = self.display_hybrid_results(payload, final_class_idx, results, top_k, verbose=True)
-
+                    
+                
                 return results, chosen_label, confidence
 
             else:
@@ -18105,6 +18311,7 @@ class PipelinePredictionManager:
         else:
             print(f'[⚡] Final Prediction: {chosen_label} with confidence: {confidence:.1%}')
             chosen_label = chosen_label
+
         
         # delete pipelines cache
         print('[🔍] Pipelines Cache Cleaned!')
@@ -18167,7 +18374,9 @@ class PipelinePredictionManager:
 
         except Exception as e:
             print(f'[!] Cant check and calibrate probs based on penalty due to: {e}') 
-            traceback.print_exc()   
+            traceback.print_exc()  
+
+         
         
         return final_probs 
 
@@ -20284,6 +20493,21 @@ def PermissiveTest():
     ("Watching Slack", "communication"),
     ("Programming in Visual Studio Code", "focused_work"),
     ("Watching netflix.com - Chrome", "break"),
+    ("Listening to Spotify", "entertainment"),
+    ("Playing Steam Game", "gaming"),
+    ("Checking Discord messages", "communication"),
+    ("Reading documentation on StackOverflow", "research"),
+    ("Downloading files from Google Drive", "file_work"),
+    ("Using Terminal to run scripts", "system_work"),
+    ("Analyzing data in Excel", "data_work"),
+    ("Attending Zoom meeting", "communication"),
+    ("Designing in Photoshop", "creative"),
+    ("Learning from Coursera course", "learning"),
+    ("Using Calculator utility", "utility"),
+    ("Browsing Facebook on Chrome", "social_media"),
+    ("Reading an eBook in PDF format", "reading"),
+    ("Listening to a podcast", "audio_learning"),
+    ("Using Google Translate", "utility"),
     ]
     rules = [
         # === WORK / PRODUCTIVITY ===