AbstractIntegratedModule 0.5.1__tar.gz → 0.5.2__tar.gz

{abstractintegratedmodule-0.5.1 → abstractintegratedmodule-0.5.2/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.5.1
+Version: 0.5.2
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - 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: Beta, 0.5.1.
+- Development Stage: Beta, 0.5.2.
 - 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.
@@ -64,11 +64,13 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
    - LSTM is Optimized efficiently for scarce data with AWE method.
    - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
+   - Transformer Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage.
 - Changelog:
-     - v0.5.1:
-         [=] New features: 
-          - Added new dynamic gate for Transformer Fixed and dynamic switching condition.
-          - Added Capabilities for the Model to save the Transformer weights as binaries in local SQlite database.
+     - v0.5.2:
+          - [=] New features: 
+          - Transformer is now Optimized using Cython!
+          - Refined memory checks to reduce further corruption in IntegratedPipeline memory.
+          - Added safety guards for cosine similarity to prevent float cascading through the flow.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />

{abstractintegratedmodule-0.5.1 → abstractintegratedmodule-0.5.2}/AbstractIntegratedModule.egg-info/SOURCES.txt

@@ -2,6 +2,11 @@ AbstractIntegratedModule.cp313-win_amd64.pyd
 AbstractIntegratedModule.cpython-310-aarch64-linux-gnu.so
 AbstractIntegratedModule.cpython-312-x86_64-linux-gnu.so
 AbstractIntegratedModule.py
+AbstractOptimizedModules.c
+AbstractOptimizedModules.cp313-win_amd64.pyd
+AbstractOptimizedModules.cpython-310-aarch64-linux-gnu.so
+AbstractOptimizedModules.cpython-312-x86_64-linux-gnu.so
+AbstractOptimizedModules.pyx
 MANIFEST.in
 README.md
 pyproject.toml
@@ -10,4 +15,5 @@ AbstractIntegratedModule.egg-info/PKG-INFO
 AbstractIntegratedModule.egg-info/SOURCES.txt
 AbstractIntegratedModule.egg-info/dependency_links.txt
 AbstractIntegratedModule.egg-info/requires.txt
-AbstractIntegratedModule.egg-info/top_level.txt
+AbstractIntegratedModule.egg-info/top_level.txt
+C:/Users/Dell/OneDrive/Desktop/AIM-PIP-Packaging/AbstractOptimizedModules.c

{abstractintegratedmodule-0.5.1 → abstractintegratedmodule-0.5.2}/AbstractIntegratedModule.egg-info/top_level.txt

@@ -1 +1,2 @@
 AbstractIntegratedModule
+AbstractOptimizedModules

{abstractintegratedmodule-0.5.1 → abstractintegratedmodule-0.5.2}/AbstractIntegratedModule.py

@@ -42,6 +42,22 @@ import psutil
 from sklearn.preprocessing import StandardScaler
 import io
 
+# Optimized Modules In Cython implementation.
+try:
+    from AbstractOptimizedModules import (
+        optimized_sigmoid,
+        optimized_sigmoid_deriv,
+        optimized_tanh_deriv,
+        optimized_lstm_cell_forward,
+        optimized_project_heads,
+        optimized_ame_encoder
+    )
+    _OPT_AVAILABLE = True
+    print('[=] Cython acceleration loaded ✅')
+except ImportError:
+    _OPT_AVAILABLE = False
+    print('[=] Cython not available, using numpy fallback')
+
 # initial Setup logging for AgentDistributedInference and ModelStorage class logger and security logger
 logger = logging.getLogger(__name__)
 _integrated_pipeline_lock = threading.Lock()
@@ -611,10 +627,19 @@ class Transformer:
         W_q_mix = (1 - alpha) * self.W_q_fixed + alpha * self.W_q
         W_k_mix = (1 - alpha) * self.W_k_fixed + alpha * self.W_k
         W_v_mix = (1 - alpha) * self.W_v_fixed + alpha * self.W_v
-        
-        Q = np.einsum('bsd,hdm->bhsm', x, W_q_mix)
-        K = np.einsum('bsd,hdm->bhsm', x, W_k_mix)
-        V = np.einsum('bsd,hdm->bhsm', x, W_v_mix)         
+
+        # Optimized Project heads with Cython implementation.
+        if _OPT_AVAILABLE:
+            B, S, D = batch_size, seq_len, d_model
+            M = D // self.n_heads 
+
+            Q = optimized_project_heads(x, W_q_mix, B, S, self.n_heads, D, M)
+            K = optimized_project_heads(x, W_k_mix, B, S, self.n_heads, D, M)
+            V = optimized_project_heads(x, W_v_mix, B, S, self.n_heads, D, M)
+        else:
+            Q = np.einsum('bsd,hdm->bhsm', x, W_q_mix)
+            K = np.einsum('bsd,hdm->bhsm', x, W_k_mix)
+            V = np.einsum('bsd,hdm->bhsm', x, W_v_mix)    
         
         # Store for backward
         self.cache['Q'] = Q
@@ -638,7 +663,7 @@ class Transformer:
         return output, attn_weights
     
 
-    def forward(self, input_ids, embedded=False, pad_token_id=0, training=True, attn_dropout=0.1, ffn_dropout=0.1):
+    def forward(self, input_ids, AME=None, embedded=False, pad_token_id=0, training=True, attn_dropout=0.1, ffn_dropout=0.1):
         if embedded:
             x = np.asarray(input_ids)
             if x.ndim == 2:
@@ -666,7 +691,6 @@ class Transformer:
         self.cache['x_pos'] = x
         
         # Multi-head attention with residual     
-        AME = self.AME_Encoder(x)
         alpha = 1.0 / (1.0 + np.exp(-AME))
         attn_out, attn_weights = self.multi_head_attention(x, mask=mask, alpha=alpha)
   
@@ -1004,7 +1028,7 @@ class Transformer:
         return grads, total_norm  # return norm for monitoring    
 
 
-    def train_step(self, input_ids, epoch, y_true, lr=0.01, mode=None, embedded=False, max_norm=1.0, pad_token_id=0):
+    def train_step(self, input_ids, epoch, y_true, lr=0.01, AME=None, mode=None, embedded=False, max_norm=1.0, pad_token_id=0):
         y_true = np.asarray(y_true)
         if len(y_true.shape) < 2:
             y_true = y_true.reshape(-1, 1)
@@ -1014,7 +1038,7 @@ class Transformer:
         if y_true.ndim == 1:
             y_true = y_true[np.newaxis, :]   
 
-        probs, attn_weights = self.forward(input_ids, embedded=embedded, pad_token_id=pad_token_id, training=True, attn_dropout=self.attn_dropout_rate, ffn_dropout=self.ffn_dropout_rate)
+        probs, attn_weights = self.forward(input_ids, AME=AME, embedded=embedded, pad_token_id=pad_token_id, training=True, attn_dropout=self.attn_dropout_rate, ffn_dropout=self.ffn_dropout_rate)
         y_true_smooth = self.smoothing_labels_utility(y_true, smoothing=0.1)
 
         if y_true_smooth.shape[0] and y_true_smooth.shape[1] != probs.shape[0] and probs.shape[1]:
@@ -1092,9 +1116,8 @@ class Transformer:
             # input_ids_list is now a list of (B, T) arrays
             # y_true_list is now a list of (B, num_classes) arrays
 
-
+        AME = self.AME_Encoder(input_ids_list)
         print(f"[==] Starting comprehensive training for {epochs} epochs with mode: {mode}, learning rate: {lr}, schedule: {schedule}")
-
         for epoch in range(epochs):
             epoch_losses = []
             epoch_accs = []
@@ -1108,7 +1131,7 @@ class Transformer:
                 if y_true.ndim == 1:
                     y_true = y_true[np.newaxis, :]
                     
-                loss, acc = self.train_step(input_ids, epoch, y_true, current_lr, mode, 
+                loss, acc = self.train_step(input_ids, epoch, y_true, current_lr, AME=AME, mode=mode, 
                                             embedded=embedded, max_norm=max_norm, pad_token_id=pad_token_id)
                 epoch_losses.append(loss)
                 epoch_accs.append(acc)
@@ -1127,14 +1150,19 @@ class Transformer:
     def predict(self, input_ids, embedded=False):
         if not embedded and input_ids.ndim == 1:
             input_ids = input_ids.reshape(1, -1)
-        
-        probs, attn_weights = self.forward(input_ids, embedded=embedded, training=False, attn_dropout=0.0, ffn_dropout=0.0)
+
+        AME = self.AME_Encoder(input_ids)
+        probs, attn_weights = self.forward(input_ids, AME=AME, embedded=embedded, training=False, attn_dropout=0.0, ffn_dropout=0.0)
         preds = np.argmax(probs, axis=1)
         
         return preds, probs, attn_weights
 
 
     def AME_Encoder(self, x):
+        # Optimized AME_Encoder for Transformer
+        if _OPT_AVAILABLE and np.asarray(x).ndim == 2:
+            return optimized_ame_encoder(np.asarray(x, dtype=np.float64))     
+
         X = np.asarray(x)
         # Regular AME Equations, higher AME provides capabilities for the model to experience errors during abstraction
         # Lower AME means lower chance for un optimal abstraction.
@@ -1455,6 +1483,18 @@ class LSTMCell:
 
     # _________ forward method for cell class _____________
     def forward(self, x_seq: np.ndarray, h0=None, c0=None):
+
+        # Optimized LSTM Cell Implementation with Cython based Language.
+        if _OPT_AVAILABLE:
+            hs, cs, cache = optimized_lstm_cell_forward(
+                np.ascontiguousarray(x_seq, dtype=np.float64),  # force float64
+                np.ascontiguousarray(self.W,  dtype=np.float64),
+                np.ascontiguousarray(self.b,  dtype=np.float64),
+                self.input_size,
+                self.hidden_size
+            )
+            return hs, cs, cache 
+
         T              = x_seq.shape[0]
         H              = self.hidden_size
         expected_input = self.input_size
@@ -2407,7 +2447,9 @@ class WeightedEnsemblePredictor:
             print('[=] label_bins cache found!')
             label_bins = self.pipeline.cache['label_bins']
 
-        trans_probs, attn_weights = self.pipeline.model2.forward(input_ids, embedded=embedded)
+        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.mlp.forward(X_mlp)
         lstm_probs, lstm_weight_hint = self._get_lstm_probs(input_ids, X_mlp, label_bins=label_bins)
 
@@ -2731,9 +2773,11 @@ class WeightedEnsemblePredictor:
     def calibrate_weights(self, input_ids, X_mlp, y_true, step=3):
         print("\n🔧 Calibrating ensemble weights...")
         
-        best_weight = 0.1 + self.pipeline.confidence_threshold
+        best_weight = self.pipeline.confidence_threshold + self.pipeline.confidence_threshold
         best_accuracy = 0
-        
+
+        AME = self.pipeline.model2.AME_Encoder(input_ids)
+
         # Try different weights
         for w in np.linspace(0, 1, 11):
             self.transformer_weight = w
@@ -2742,7 +2786,7 @@ class WeightedEnsemblePredictor:
             correct = 0
             total = 0
             for i in range(step):
-                trans_probs, _ = self.pipeline.model2.forward(input_ids)
+                trans_probs, _ = self.pipeline.model2.forward(input_ids, AME=AME, embedded=True)
                 mlp_probs = self.pipeline.mlp.forward(X_mlp)
                 
                 ensemble = w * trans_probs + (1-w) * mlp_probs
@@ -4016,6 +4060,100 @@ class ModelStorage:
             return [self._prepare_for_serialization(item) for item in obj]
         return obj
 
+    def load_model_dict(self, memory_name):
+        conn = None
+        try:
+            try:
+                conn = sqlite3.connect(self.db_path)
+            except:
+                conn = sqlite3.connect(self.get_database_path())
+
+            c = conn.cursor()
+            c.execute("""
+                SELECT model_data FROM model_storage
+                WHERE memory_name = ? AND is_active = 1
+                ORDER BY id DESC LIMIT 1
+            """, (memory_name,))
+
+            result = c.fetchone()
+            if not result:
+                return None
+
+            data = json.loads(result[0])
+            data = self._validate_and_repair(data, memory_name)
+            return data   # actually return data
+
+        except Exception as e:
+            print(f'[!] Error loading model dict: {e}')
+            return None
+        finally:
+            if conn:
+                conn.close()
+
+
+    def _validate_and_repair(self, data, memory_name=None):
+        """Validate loaded data and repair if corrupted."""
+
+        if data is None:
+            return {}
+
+        # get num_classes safely without touching pipeline
+        num_classes = 0
+        try:
+            # try pipeline first
+            if hasattr(self, 'pipeline') and self.pipeline is not None:
+                num_classes = self.pipeline._get_num_classes()
+            # fallback — infer from data itself
+            elif isinstance(data, dict):
+                for v in data.values():
+                    if isinstance(v, (list, np.ndarray)):
+                        arr = np.asarray(v)
+                        if arr.ndim == 1:
+                            num_classes = len(arr)
+                            break
+        except Exception as e:
+            print(f'[!] Could not determine num_classes: {e}')
+            num_classes = 0
+
+        # handle list data
+        if isinstance(data, list) and len(data) > 0:
+            if num_classes > 0 and len(data) != num_classes:
+                print(f'[!] Shape mismatch: got {len(data)}, expected {num_classes} — repairing')
+                return {}
+
+            if all(isinstance(x, (int, float)) for x in data[:10]):
+                print(f'[!] List appears to be probabilities, wrapping')
+                return {'_cached_probs': np.array(data, dtype=np.float64)}
+
+        # handle dict data
+        if isinstance(data, dict):
+            repaired = {}
+            for key, value in data.items():
+
+                # dynamic corruption check instead of hardcoded 133
+                if isinstance(value, list):
+                    arr = np.asarray(value)
+                    if arr.ndim > 2:
+                        print(f'[!] Corrupted value for key {key} '
+                            f'(ndim={arr.ndim}), removing')
+                        continue
+
+                    if num_classes > 0 and arr.ndim == 1 and \
+                    len(arr) not in (num_classes, num_classes * 2):
+                        print(f'[!] Suspicious shape for key {key}: '
+                            f'{arr.shape}, expected {num_classes} — removing')
+                        continue
+
+                # None values — skip silently
+                if value is None:
+                    continue
+
+                repaired[key] = value
+
+            return repaired
+
+        return data
+
 
     def _convert_to_arrays(self, data):
         """
@@ -4040,6 +4178,7 @@ class ModelStorage:
             return self._convert_value(data)
 
 
+
     def _convert_value(self, value):
         """
         Convert a single value to appropriate type.
@@ -4207,8 +4346,8 @@ class ModelStorage:
         elif type_func == 'Node':
             data = self._load_node_dict(name)            
         else:
-            data = self.load_model_dict(name)
-        
+           data = self.load_model_dict(memory_name)
+
         if data is None:
             print(f"[-] No memory found: {name}")
             return {}
@@ -4610,56 +4749,7 @@ class ModelStorage:
             print(f'|| Cant load peer request memory due to: {e}') 
             return None, None  
 
-
-    def load_model_dict(self, memory_name):
-        try:
-            try:
-                conn = sqlite3.connect(self.db_path)
-            except:
-               db_path = self.get_database_path()
-               conn = sqlite3.connect(db_path)  
-            c = conn.cursor()
         
-            c.execute("""
-            SELECT model_data FROM model_storage 
-            WHERE memory_name = ? AND is_active = 1
-            """, (memory_name,))
-        
-            result = c.fetchone()
-            conn.close()
-        
-            if result:
-                data = json.loads(result[0])
-                data = self._validate_and_repair(data)
-        except Exception as e:
-            print(f'Error handling model dict: {e}')
-        return None
-        
-    def _validate_and_repair(self, data):
-        """Validate loaded data and repair if corrupted"""
-        
-        # If data is an array with wrong shape
-        if isinstance(data, list) and len(data) > 0:
-            # Check if it's a probability array
-            if len(data) != self.pipeline._get_num_classes():  
-                print(f'[!] Detected corrupted memory with shape {len(data)}, repairing...')
-                # Return empty dict to trigger retraining
-                return {}
-            
-            # Try to convert list to dict format
-            if all(isinstance(x, (int, float)) for x in data[:10]):
-                print(f'[!] List appears to be probabilities, wrapping')
-                return {'_cached_probs': np.array(data)}
-
-        
-        # If data is dict, ensure values are correct
-        if isinstance(data, dict):
-            for key, value in data.items():
-                if isinstance(value, list) and len(value) == 133:
-                    print(f'[!] Corrupted value for key {key}, removing')
-                    data[key] = None
-        
-        return data
 
     def fix_corrupted_memory(self, memory_name):
         # Clear corrupted memory entries
@@ -7771,8 +7861,19 @@ class IntegratedPipeline:
 
 
     def cosine_robust_similarity(self, a, b):
-        norm_a = np.linalg.norm(a)
-        norm_b = np.linalg.norm(b[0])
+        if isinstance(b, (float, int)) or isinstance(a, (float, int)):
+            print('[!] Value is single scalar! returning 0.0 similarity')
+            return 0.0
+
+        if isinstance(a[0], (np.ndarray, list)):
+            norm_a = np.linalg.norm(a[0])
+        else:
+            norm_a = np.linalg.norm(a) 
+            
+        if isinstance(b[0], (np.ndarray, list)):
+            norm_b = np.linalg.norm(b[0])
+        else:
+            norm_b = np.linalg.norm(b)
     
         try:
             dot_product = np.dot(a, b)
@@ -7981,6 +8082,10 @@ class IntegratedPipeline:
 
     def cosine_similarity(self, a, b):
         eps = 1e-5
+        if isinstance(b, (float, int)) or isinstance(a, (float, int)):
+            print('[!] Value is single scalar! returning 0.0 similarity')
+            return 0.0
+
         b = b[0]
         
         try:
@@ -8319,20 +8424,42 @@ class IntegratedPipeline:
             return None
 
     def _gate_from_list(self, memory: list, x, x2) -> Optional[np.ndarray]:
-        # xtract from list memory (fallback for corrupted storage)
+        print('[=] Extracting from list memory.. handling possible corruption...')
 
-        print('[=] Extracting from list memory.. handling possible corruption of data...')
         for item in memory:
-            if isinstance(item, (tuple, list)) and len(item) >= 2:
-                stored_x = item[0]
-                stored_out = item[1]
-                
-                # Check similarity
-                print('[=] checking similarity from stored X data and stored output...')
-                if self.cosine_robust_similarity(x, stored_x) >= 0.9:
+            if not isinstance(item, (tuple, list)) or len(item) < 2:
+                continue
+
+            stored_x   = item[0]
+            stored_out = item[1]
+
+            # guard against corrupted float entries
+            if isinstance(stored_x, (int, float)):
+                print(f'[!] Skipping corrupted entry — stored_x is scalar: {stored_x}')
+                continue
+
+            # guard against None
+            if stored_x is None or stored_out is None:
+                continue
+
+            # ensure array before similarity
+            try:
+                stored_x_arr = self._to_numpy_array(stored_x)
+                if stored_x_arr is None or stored_x_arr.ndim == 0:
+                    continue
+            except Exception as e:
+                print(f'[!] Could not convert stored_x to array: {e}')
+                continue
+
+            try:
+                print('[=] Checking similarity from stored X data...')
+                if self.cosine_robust_similarity(x, stored_x_arr) >= 0.775:
                     return self._to_numpy_array(stored_out)
+            except Exception as e:
+                print(f'[!] Similarity check failed: {e}')
+                continue
 
-        print('[=] Cant get item from memory, possible dangerous data Corruption!')
+        print('[=] Cant get item from memory, possible dangerous data corruption!')
         return None
 
 
@@ -11775,9 +11902,10 @@ class PipelinePredictionManager:
                 input_ids_list.append(np.array(ids))
             
                 input_ids = np.array(input_ids_list)
+                AME = self.pipeline.model2.AME_Encoder(input_ids)                
             
             # Get transformer probabilities
-                trans_probs, attn_weights = self.pipeline.model2.forward(input_ids)
+                trans_probs, attn_weights = self.pipeline.model2.forward(input_ids, AME=AME)
             else:
                 print("⚡ Using MLP only for predictions")
                 trans_probs = None
@@ -12302,7 +12430,9 @@ class PipelinePredictionManager:
                 # Get transformer predictions with attention
                 print(f"[⚡] anisotropy rate detected on input: {anisotropy:.1%}.")                
                 use_embedded = True
-                trans_probs, attn_weights = self.pipeline.model2.forward(sequence_ids, embedded=use_embedded)
+                
+                AME = self.pipeline.model2.AME_Encoder(sequence_ids)                
+                trans_probs, attn_weights = self.pipeline.model2.forward(sequence_ids, AME=AME, embedded=use_embedded)
 
             else:
                 print("\n[⚡] Running MLP-only predictions")
@@ -12748,6 +12878,7 @@ class PipelinePredictionManager:
 
         except Exception as e:
             print(f"[!] Error in advanced prediction method: {e}, Initiating regular prediction method...")
+            traceback.print_exc()            
             try:
                 results = self.regular_prediction_method(titles, label_map, rules, X=X, y=y, show_proba=False, top_k=3, batch_size=2,use_transformer=True)
                 chosen_label = results[0]['predicted']
@@ -12796,8 +12927,8 @@ class PipelinePredictionManager:
             
             # Agreement indicator
             agree_symbol = "✓" if result.get('models_agree', True) else "⚠️"
-            print(f"   {agree_symbol} FINAL: {result['predicted']} ({result['confidence']:.1%})")
-            
+            print(f"[=] {agree_symbol} FINAL: {result['predicted']} ({result['confidence']:.1%})")
+
             # MLP vs Transformer
             print(f"      ├─ [⚡] MLP: {result['mlp_prediction']} ({result['mlp_confidence']:.1%})")
             if result.get('transformer_prediction'):