AbstractIntegratedModule 1.2.0__tar.gz → 1.2.2__tar.gz

{abstractintegratedmodule-1.2.0 → abstractintegratedmodule-1.2.2}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.2.0
+Version: 1.2.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.2.0 → abstractintegratedmodule-1.2.2}/AbstractIntegratedModule.py

@@ -406,7 +406,6 @@ class GeometricWeightShaping:
 
     def spectral_signature(self, x, structured_noise, k=5):
         raw_X = np.asarray(x, dtype=np.float64)
-
         if raw_X.ndim > 2:
             X = raw_X.reshape(raw_X.shape[0], -1)
         else:
@@ -535,7 +534,6 @@ class GeometricWeightShaping:
         spectral_similarity = self.spectral_similarity(x, floating_point, structured_noise)
 
         AEL = (0.3 + spectral_similarity + eps) * anisotropy 
-
         scaled_anisotropy = anisotropy / (anisotropy + 1.0)
         
         abstraction_efficiency = (1.0 + AEL) * (1.0 - AMR) + eps
@@ -1925,7 +1923,7 @@ class Transformer:
             mask_expanded = np.broadcast_to(
                 mask, (batch, heads, seq_len, seq_len)
             )
-            # FIX 1 — inplace operations, ARM64 NEON works better on contiguous memory
+            # inplace operations, ARM64 NEON works better on contiguous memory
             attn_weights = attn_weights * mask_expanded
             row_sums     = attn_weights.sum(axis=-1, keepdims=True) + eps
             attn_weights = attn_weights / row_sums
@@ -2729,7 +2727,6 @@ class AdamOptimizer:
 class MLP:
     def __init__(self):
         self.layers = []
-        self.layers2 = []
         self.lr = 0.1
 
         self.error_counts = None
@@ -3100,7 +3097,7 @@ class LSTMCell:
                 self.input_size,
                 self.hidden_size
             )
-            return hs, cs, cache 
+            return hs, cs, cache
 
         T              = x_seq.shape[0]
         H              = self.hidden_size
@@ -3151,6 +3148,7 @@ class LSTMCell:
             hs[t] = h
             cs[t] = c
 
+            
         return hs, cs, cache
 
     # ________ backward method for Cell class __________
@@ -3191,6 +3189,7 @@ class LSTMCell:
             dtanhc = dh_total * o
             dc_new = dtanhc * tanh_deriv(tanh_c) + dc
 
+
             df = dc_new * c_prev
             di = dc_new * g
             dg = dc_new * i
@@ -10677,7 +10676,7 @@ class IntegratedPipeline:
         self.tfidf = TfidfVectorizer(max_features=70)
         # LSTM __init__ setup
         self.network_model = LSTMNetwork(self, input_size=self.input_size, hidden_size=self.hidden, output_size=self.output_size)
-        self.scrapper_model = LSTMEngine(self, self.network_model, dropout=self.dropout_rate, n_samples=50)        
+        self.scrapper_model = LSTMEngine(self, self.network_model, dropout=self.dropout_rate, n_samples=50)
 
         # kNN Transformer
         self.memory_capacity = 8000
@@ -14266,7 +14265,6 @@ class IntegratedPipeline:
         # build and calibrate engine
         self.lstm_engine = LSTMEngine(self, self.network_model, 
                                        dropout=self.dropout_rate, n_samples=self.lstm_n_samples)
-        
         engine = self.lstm_engine
 
         self.lstm_engine.fit_stm(X_train_full, Y_train_full, epochs=self.lstm_training_epochs, hidden=self.lstm_hidden_dim, lr=self.lstm_lr)
@@ -17592,11 +17590,13 @@ class PipelinePredictionManager:
 
         return titles, y, label_map
 
-    def knn_forward_inference(self, X, y, memory_metric='euclidean', training=False, batch_size=2, train_mode='fixed_backward', lr=0.1):
+    def knn_forward_inference(self, X, y, label_map=None, memory_metric='euclidean', training=False, batch_size=2, train_mode='fixed_backward', lr=0.1):
         trans_probs = None
         use_embedded = True
         num_classes = self.pipeline._get_num_classes()
-
+        if label_map and isinstance(label_map, dict):
+            reverse_map = {v: k for k, v in label_map.items()}
+    
         if self.pipeline.model2 is not None:
             self.pipeline.knn_tf = KNNAugmentedTransformer(
                                  vocab_size=self.pipeline.vocab_size, d_model=self.pipeline.transformer_d_model, n_heads=self.pipeline.transformer_heads, num_classes=num_classes,
@@ -17653,19 +17653,28 @@ class PipelinePredictionManager:
                 print('[>] Starting kNN Augmented Transformer Training...')
                 sequence_ids_train = self.pipeline._features_to_sequence(X_train)
                 losses, accs = self.pipeline.knn_tf.train(input_ids_list=sequence_ids_train, y_true_list=y, epochs=self.pipeline.transformer_training_epochs, mode=train_mode, lr=lr, embedded=True, batch_size=batch_size)
-                return losses, accs
+                return losses, accs, None
             else:
-                print('[>] Returning Transformer probabilities directly...')
+                print('[>] Processing kNN Augmented Transformer probabilities...')
                 sequence_ids = self.pipeline._features_to_sequence(X)
                 trans_probs, attn_weights = self.pipeline.knn_tf.forward(input_ids=sequence_ids, AME=AME, embedded=use_embedded)
 
-            return trans_probs, attn_weights
+            if label_map is None:
+                print('[⚠️] > label_map is None, returning kNN Transformer probabilities without any label mapping...')
+                return trans_probs, attn_weights, None
+            else:
+                trans_pred_indices = np.argmax(trans_probs, axis=-1).tolist()
+                trans_pred_idx = max(set(trans_pred_indices), key=trans_pred_indices.count)
+                predict_confidence = trans_probs[0][trans_pred_idx]
+                prediction = reverse_map.get(trans_pred_idx, 'Unknown')
+                print(f"[=] kNN Augmented Transformer Prediction: {prediction} with probability {predict_confidence:.2%}")
+                return trans_probs, attn_weights, prediction
         
         except Exception as e:
             print(f'[>] Error initating kNN forward Inference: {e}')
             traceback.print_exc()
-            return [], []
-        
+            return [], [], None
+
 
 
     def regular_prediction_method(self, titles=None, label_map=None, rules=None, X=None, y=None, show_proba=False, top_k=3, batch_size=2, use_transformer=True):
@@ -18787,9 +18796,11 @@ class PipelinePredictionManager:
                 X = X_gen if X_gen is not None else X
 
             if X_gen is not None:
-                self.pipeline.transformer_utilities(X_provided=X_train, X_raw=X_gen, y_true=y_train, rules=rules, datasets=dataset, label_map=label_map, batch_size=batch_size, max_samples_for_focused_fit=len(X))
+                self.pipeline.transformer_utilities(X_provided=X_train, X_raw=X_gen, y_true=y_train, rules=rules, datasets=dataset, 
+                                                    label_map=label_map, batch_size=batch_size, max_samples_for_focused_fit=len(X))
             else:
-                self.pipeline.transformer_utilities(X_provided=X_train, X_raw=X, y_true=y_train, rules=rules, datasets=dataset, label_map=label_map, batch_size=batch_size, max_samples_for_focused_fit=len(X))
+                self.pipeline.transformer_utilities(X_provided=X_train, X_raw=X, y_true=y_train, rules=rules, datasets=dataset, 
+                                                    label_map=label_map, batch_size=batch_size, max_samples_for_focused_fit=len(X))
 
 
             if dataset is not None:
@@ -19040,7 +19051,6 @@ class PipelinePredictionManager:
                         trans_label = reverse_map.get(trans_class_idx, f"unknown_{trans_class_idx}")
 
                         if need_ensemble_method:
-                            print(f"[🔄] Ensemble method activated for sample {i} due to high anisotropy")
                             calibration = self.pipeline._calibrate_probs(target_probs, target_pred_indices, attn_weights, input_ids)
                             # Blend predictions (MLP decides class, transformer calibrates confidence)
                             mlp_weight = mlp_confidence / (target_confidence + trans_confidence + eps)
@@ -19069,19 +19079,16 @@ class PipelinePredictionManager:
                             # Calculate agreement
                             agreement = mlp_class_idx == trans_class_idx
                         else:
-                            print(f"[🔄] Ensemble method not activated for sample {i} due to unmet conditions")
                             if lstm_confidence is None:
                                 lstm_confidence = mlp_confidence
                             if mlp_confidence > trans_confidence and mlp_confidence > lstm_confidence and not mlp_confidence > 0.95:
                                 final_probs = mlp_probs[i] if i < len(mlp_probs) else mlp_probs[0]
                                 final_class_idx = mlp_class_idx
                                 final_confidence = mlp_confidence
-                                print(f"[🔄] MLP chosen for sample {i} due to highest confidence: {mlp_confidence:.1%}")
                             elif trans_confidence > lstm_confidence:
                                 final_probs = trans_probs[i] if i < len(mlp_probs) else trans_probs[0]
                                 final_class_idx = trans_class_idx
                                 final_confidence = trans_confidence
-                                print(f"[🔄] Transformer chosen for sample {i} due to highest confidence: {trans_confidence:.1%}")
                             else:
                                 chosen_probs = mlp_probs[i] if i < len(mlp_probs) else mlp_probs[0]
 
@@ -19307,7 +19314,7 @@ class PipelinePredictionManager:
                         print(f"\n[⚠️] Final prediction is {chosen_label} with uncertain confidence: {confidence:.1%}. Consider more consistent data for the model to learn from.")
                     else:
                         print(f"\n[🎯] Predicted label: {chosen_label} || With Certain Confidence: {confidence:.1%}")
-                    
+
                 return results, chosen_label, confidence
 
             else:
@@ -19653,10 +19660,9 @@ class PipelinePredictionManager:
                 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}') 
-
+            
         return final_probs