AbstractIntegratedModule 1.1.3__tar.gz → 1.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.1.3
+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.3 → 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):
@@ -9822,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:
         """
@@ -11505,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:
@@ -12878,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
@@ -12921,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:
@@ -12987,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 =====")
@@ -13224,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())
@@ -13316,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]
@@ -13349,7 +13529,7 @@ class IntegratedPipeline:
             )
 
         if issues:
-            print(f"[>] [{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
@@ -13358,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
 
@@ -13520,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(
@@ -13534,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') 
@@ -16386,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:
@@ -17431,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:
@@ -17571,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
@@ -17649,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
@@ -17834,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:
@@ -18122,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!')
@@ -18184,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 
 
@@ -20301,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 ===