AbstractIntegratedModule 0.4.5__tar.gz → 0.4.6__tar.gz

{abstractintegratedmodule-0.4.5 → abstractintegratedmodule-0.4.6/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.4.5
+Version: 0.4.6
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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.4.5.
+- Development Stage: Beta, 0.4.6.
 - 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.
@@ -379,6 +379,10 @@ B. [=] Advanced Prediction without Transformer, Only Specialized MLP + LSTM usin
 
 ### Both performance Overview
 <img width="1536" height="1024" alt="WhatsApp Image 2026-05-24 at 10 27 00" src="https://github.com/user-attachments/assets/9404277f-281f-4893-8367-e494833230ea" />
+_______________________________________
+- Note: 
+   - This performance metric was calculated in older versions, With newer Transformers that has more, newer modules, The resulting cpu consumed may Increase 1.5 - 2x much more in Docker ARM64 Environment + QEMU, 
+   MLP And LSTM stays the same and still fully optimized.
 
 ## Source code of AbstractIntegratedModule 
 - Note: The source code is provided in the repository.
@@ -650,7 +654,8 @@ async_manager = PipelineAsyncManager(main_model,
 
 async_manager.start(method='Transformer_included', bootstrap_token=None) # boothstrap token is optional for better security
 
-texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': example_rules, 'use_transformer': True}
+texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': example_rules, 'X': None, 'y':None, 'use_transformer': True} # all samples needed for advanced prediction method. (X and y are optional samples)
+
 regular_predict = async_manager.predict(
    texts=texts,
    timeout=60,
@@ -660,7 +665,9 @@ regular_predict = async_manager.predict(
 # with retries: async_manager.predict(texts, timeout=60, retries=5, api_key=secret_key) # 5 times retry if failed
 
 print('[==] Initiating advanced batch prediction')
-predicted_output = async_manager.advanced_batch_prediction(test_titles, label_map, example_rules, secret_key, client_ip=None) # you can add client_ip to provide a robust authentication paired with secret_key
+         predicted_output = async_manager.advanced_batch_prediction(test_titles, label_map, example_rules, 
+         X=None, y=None, # provide your initialized X and y samples (Also Optional, can be set to None)
+         secret_key=secret_key, client_ip=None) # you can add client_ip to provide a robust authentication paired with secret_key
 # for better and faster advanced prediction, consider using advanced batch prediction like in the above example
 
 ```
@@ -766,7 +773,7 @@ try:
      api_key = agent1.get_api_key()
      print(f"\n🔑 Using API Key: {api_key[:20]}...")
 
-     texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True, "agent_id": agent_id}
+     texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, 'X': None, "y":None, "use_transformer": True, "agent_id": agent_id} # (X and y are optional samples here too)
 
      # texts dictionary must contain test_titles, label_map, and rules that you can assign,
      # agent ID can be strings, int, or floats, recommendded to make it long for better security.

{abstractintegratedmodule-0.4.5 → abstractintegratedmodule-0.4.6}/AbstractIntegratedModule.py

@@ -388,10 +388,11 @@ class GeometricWeightShaping:
             gradient = np.gradient(x)
         except:
             subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
-            gradient = np.gradient(subnet.flatten())        
-     
+            gradient = np.gradient(subnet.flatten())
+
         val = [np.linalg.norm(v) for v in gradient]
         anisotropy = np.std(val) / np.mean(val) + eps
+
         return anisotropy
 
     # weight shaping provides directional context in which how the data should be processed in order to align with the data geometry
@@ -859,8 +860,10 @@ class Transformer:
         d_ffn1 = np.sum(np.matmul(self.cache['ffn_input'].transpose(0, 2, 1), d_ffn_pre), axis=0)
         
         # Layer norm 1 gradient
-        d_ln1 = self.layer_norm_backward(d_x, self.cache['x_ln1_input'], self.ln1_scale, self.ln1_shift)
-        
+        d_ln1 = self.layer_norm_backward(
+            d_prev, self.cache['x_ln1_input'], self.ln1_scale, self.ln1_shift
+        ) 
+
         d_residual = d_ln1
         d_attn = d_ln1
         dx = d_prev + d_residual
@@ -950,7 +953,12 @@ class Transformer:
 
     def smoothing_labels_utility(self, y_true, smoothing=0.1):
         # y_true: (B, num_classes) one-hot
-        num_classes = y_true.shape[1]
+        try:
+            num_classes = y_true.shape[1]
+        except:
+            y_true_2d = y_true.reshape(-1, 1)
+            num_classes = y_true_2d.shape[1] 
+            
         return y_true * (1.0 - smoothing) + smoothing / num_classes
 
     def learning_rate_warm_up(self, epoch, epochs, lr_base, schedule='cosine_warmup', warmup_frac=0.1):
@@ -997,6 +1005,10 @@ class Transformer:
 
 
     def train_step(self, input_ids, epoch, y_true, lr=0.01, 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)
+
         if not embedded and input_ids.ndim == 1:
             input_ids = input_ids[np.newaxis, :]   # (1, T), single sample
         if y_true.ndim == 1:
@@ -1138,13 +1150,13 @@ class Transformer:
     def anisotropy_measurement(self, x):
         eps = 1e-5
         try:
-            gradient = np.gradient(x, axis=-1)
+            gradient = np.gradient(x)
         except:
-            subset = x[:, 0, 0]
-            gradient = np.gradient(subset)
+            subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
+            gradient = np.gradient(subnet.flatten())
 
         val = [np.linalg.norm(v) for v in gradient]
-        anisotropy = np.std(val) / np.mean(val) + eps
+        anisotropy = np.std(val) / np.mean(val) + eps 
 
         return anisotropy
 
@@ -1379,14 +1391,13 @@ class MLP:
     def anisotropy_measurement(self, x):
         eps = 1e-5
         try:
-            gradient = np.gradient(x, axis=-1)
+            gradient = np.gradient(x)
         except:
-            subset = x[:, 0, 0]
-            gradient = np.gradient(subset)
+            subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
+            gradient = np.gradient(subnet.flatten())
 
         val = [np.linalg.norm(v) for v in gradient]
         anisotropy = np.std(val) / np.mean(val) + eps
-
         return anisotropy
 
 
@@ -2484,10 +2495,40 @@ class WeightedEnsemblePredictor:
         
     def anisotropy_measurement(self, x):
         eps = 1e-5
-        gradient = np.gradient(x)
+        try:
+            try:
+                grads = np.gradient(x)
+                # Stack gradients into a single array of vectors and find the norm of each
+                # automatically handles multi-dimensional arrays (e.g., 2D, 3D volumes)
+                stacked_grads = np.stack(grads, axis=-1)
+                norms = np.linalg.norm(stacked_grads, axis=-1)
+                
+                # Safely filter out potential NaNs or infs (common at array boundaries)
+                valid_norms = norms[np.isfinite(norms)]
+                
+                if len(valid_norms) == 0:
+                    return 0.0 # Return zero or appropriate default if no valid values exist
+                    
+                # Calculate statistics using the clean data
+                std_val = np.std(valid_norms)
+                mean_val = np.mean(valid_norms)
+                
+                anisotropy = std_val / (mean_val + eps)    
+                if np.isnan(anisotropy) or np.isinf(anisotropy):
+                    anisotropy = self.pipeline.confidence_threshold
+            except:
+                try:
+                    gradient = np.gradient(x)
+                except:
+                    subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
+                    gradient = np.gradient(subnet.flatten())
+
+                val = [np.linalg.norm(v) for v in gradient]
+                anisotropy = np.std(val) / np.mean(val) + eps 
+        except Exception as e:
+            print(f'[!] Cant calculate anisotropy due to: {e}')   
+            anisotropy = self.pipeline.confidence_threshold
 
-        val = [np.linalg.norm(v) for v in gradient]
-        anisotropy = np.std(val) / np.mean(val) + eps
         return anisotropy
 
     def _dynamic_weighted_ensemble(self, trans_probs, mlp_probs, attn_weights, input_ids, lstm_probs,
@@ -5776,6 +5817,8 @@ class AgentDistributedInference:
         test_titles = None
         label_map = None
         rules = None
+        X = None
+        y = None
         
         # ✅ Check payload (which is a dict), not the message itself
         if isinstance(payload, dict):
@@ -5783,6 +5826,8 @@ class AgentDistributedInference:
                 test_titles = payload.get('test_titles')
                 label_map = payload.get('label_map')
                 rules = payload.get('rules')
+                X = payload.get('X')
+                y = payload.get('y')
                 
                 # Sanitize if needed
                 if test_titles:
@@ -5791,9 +5836,15 @@ class AgentDistributedInference:
                     label_map = self._sanitize_structured(label_map)
                 if rules:
                     rules = self._sanitize_structured(rules)
+                if X is not None:
+                    X = self._sanitize_structured(X)
+                if y is not None:
+                    y = self._sanitize_structured(y)
 
-                print('[=] Got necessary titles, label_map and rules')
-
+                if X is None or y is None:
+                    print('[=] Got necessary titles, label_map and rules.')
+                else:
+                    print('[=] Got necessary titles, label_map, rules and X And Y samples.')
             else:
                 text = payload.get('text')
                 if text:
@@ -5819,7 +5870,7 @@ class AgentDistributedInference:
                 if self.predict_manager is not None:
                     result = await asyncio.to_thread(
                         self.predict_manager.advanced_prediction_method,
-                        test_titles, label_map, rules,
+                        test_titles, label_map, rules, X=X, y=y,
                         show_proba=True,
                         use_transformer=self.pipeline.use_transformer
                     )
@@ -5879,6 +5930,8 @@ class AgentDistributedInference:
             test_titles = message.get('test_titles')
             label_map = message.get('label_map')
             rules = message.get('rules')
+            X = message.get('X')
+            y = message.get('y')
 
             test_titles = self._sanitize_input(test_titles)
             label_map = self._sanitize_input(label_map)
@@ -5898,7 +5951,7 @@ class AgentDistributedInference:
             if method != 'basic_prediction' or predict_manager:
                 result = await asyncio.to_thread(
                     predict_manager.advanced_prediction_method,
-                    test_titles, label_map, rules, show_proba=False, use_transformer=self.pipeline.use_transformer
+                    test_titles, label_map, rules, X=X, y=y, show_proba=False, use_transformer=self.pipeline.use_transformer
                 )
             else:
                 print('[=] basic prediction method')
@@ -5964,13 +6017,13 @@ class AgentDistributedInference:
         finally:
             loop.close()
 
-    async def request_advanced_prediction_async(self, manager: Any, use_transformer: bool=False, agent_id: str=None, test_titles: List[tuple]=None, label_map: Dict[str, int]=None, rules: List[tuple]=None, timeout: float = 30.0, callback: Optional[Callable] = None):
+    async def request_advanced_prediction_async(self, manager: Any, use_transformer: bool=False, agent_id: str=None, test_titles: List[tuple]=None, label_map: Dict[str, int]=None, rules: List[tuple]=None, X: np.ndarray=None, y: np.ndarray=None, timeout: float = 30.0, callback: Optional[Callable] = None):
         # Asynchronous prediction request
         # Local bypass - NO QUEUE
         if agent_id == 'local':
             logger.info(f"[=] Local request - direct execution")
             # Run sync prediction in thread pool
-            result = await asyncio.to_thread(manager.advanced_prediction_method, test_titles, label_map, rules, show_proba=True, use_transformer=use_transformer)
+            result = await asyncio.to_thread(manager.advanced_prediction_method, test_titles, label_map, rules, X=X, y=y, show_proba=True, use_transformer=use_transformer)
             logger.info(f"[=] Local result: {result[1]} || confidence: {result[2]}")
             return result  
 
@@ -5980,7 +6033,7 @@ class AgentDistributedInference:
             type='predict_request',
             sender=self.temporary_agent_id,
             recipient=agent_id,
-            payload={'test_titles': test_titles, 'label_map': label_map, 'rules': rules},
+            payload={'test_titles': test_titles, 'label_map': label_map, 'rules': rules, 'X':X, 'y':y},
             timestamp=datetime.now(),
             timeout=timeout,
             callback=callback,
@@ -6457,7 +6510,8 @@ class AgentDistributedInference:
             n_classes = probs.shape[0]
 
         batch_size = len(target_preds)
-        anisotropy = self.pipeline.anisotropy_measurement(attn_weights)    
+        anisotropy = self.pipeline.anisotropy_measurement(attn_weights)  
+
 
         if isinstance(attn_weights, (str, np.str_)):
             clean_str = str(attn_weights).replace('[', '').replace(']', '')
@@ -6465,7 +6519,9 @@ class AgentDistributedInference:
         elif isinstance(attn_weights, np.ndarray) and np.issubdtype(attn_weights.dtype, np.character):
             # catches arrays filled with string text
             clean_str = ' '.join(attn_weights.astype(str).flatten()).replace('[', '').replace(']', '')
-            attn_weights = np.fromstring(clean_str, sep=' ')
+            attn_weights = np.fromiter(
+                    (x for x in clean_str.split() if x != "..."), dtype=float
+                ) 
         else:
             # Ensure standard float array if it was integers or objects
             attn_weights = np.asarray(attn_weights, dtype=float)
@@ -6503,14 +6559,14 @@ class AgentDistributedInference:
 
                 consensus = np.allclose(target_prob_indices, target_attn_indices, atol=eps)
 
-                justified = (1.0 - AEL) + attn_quality * consensus
-                boost = (1.0 - justified) * anisotropy + eps
+                justified = (1.0 - AEL) * consensus + eps
+                boost = (1.0 + justified) * attn_quality + eps
 
-            quality_temperature = (boost + 1.0 - AEL) + (1.0 - attn_quality) * anisotropy + eps
-            self.query_node.peer_trust = quality_temperature + justified * anisotropy
+            abstract_error_quality_score = (1.0 - attn_quality) * anisotropy + eps
+            self.query_node.peer_trust = (1.0 - abstract_error_quality_score) + boost * justified 
 
             try:
-                calibrated[i, mlp_target] = min(calibrated[i, mlp_target] * (1.5 * quality_temperature), 0.95)
+                calibrated[i, mlp_target] = min(calibrated[i, mlp_target] * (1.5 * (1.0 - abstract_error_quality_score)), 0.95)
             except:
                 return calibrated
 
@@ -6539,18 +6595,20 @@ class AgentDistributedInference:
                 attn_weights = np.array(attn_weights)
         
             batch_similarity = self.pipeline.cosine_similarity(attn_weights, self_attn_weights)
-        
+
             anisotropy = self.pipeline.anisotropy_measurement(attn_weights)
             AME = self.pipeline.AME_Encoder(attn_weights)
             AMR = 1.0 / (1.0 + np.exp(-AME))
-            weighted_similarity = batch_similarity * (1.0 - AMR) * anisotropy
 
-            if weighted_similarity > 0.75:
+            weighted_quality_rate = (1.0 - AMR) * anisotropy
+            
+            print(f'[=] Batch similarity: {batch_similarity} With quality rate of attention: {weighted_quality_rate}')
+            if weighted_quality_rate > 0.75 and batch_similarity > 0.75:
                 return self.process_peer_request(probs, target_preds, attn_weights, input_ids)
             else:
-                print('[-] Low uncertainty, normalizing with local agent data...')
+                print('[!] Low uncertainty, normalizing with local agent data...')
 
-                AEL = 0.3 + weighted_similarity * anisotropy
+                AEL = self.pipeline.confidence_threshold + weighted_quality_rate + (1.0 - AMR) * anisotropy
                 calibrated = self._calibrate_peer_probs(probs, target_preds, self_attn_weights, attn_weights, input_ids, AEL)
                 return calibrated
 
@@ -6623,18 +6681,22 @@ class AgentDistributedInference:
             titles = message.get('test_titles')
             label_map = message.get('label_map')
             rules = message.get('rules')
+            X = message.get('X')
+            y = message.get('y')
             if not titles and label_map and rules:
                 return {'type': self.MSG_TYPES['PREDICT_RESPONSE'], 'error': 'No test titles provided'}
             
             titles = self._sanitize_arrays_and_dicts(titles)
             label_map = self._sanitize_arrays_and_dicts(label_map)
             rules = self._sanitize_arrays_and_dicts(rules)
+            X = self._sanitize_arrays_and_dicts(X)
+            y = self._sanitize_arrays_and_dicts(y)
 
             if not self._check_rate_limit(sender_id):
                 return {'type': self.MSG_TYPES['PREDICT_RESPONSE'], 'error': 'Rate limit exceeded'}
 
             try:
-                result, chosen_label, confidence = self.predict_manager.advanced_prediction_method(titles, label_map, rules, show_proba=True, use_transformer=self.pipeline.use_transformer)
+                result, chosen_label, confidence = self.predict_manager.advanced_prediction_method(titles, label_map, rules, X=X, y=y, show_proba=True, use_transformer=self.pipeline.use_transformer)
             
                 # Log the interaction
                 self._log_interaction(sender_id, 'prediction', confidence)
@@ -7788,92 +7850,131 @@ class IntegratedPipeline:
     def cosine_similarity(self, a, b):
         eps = 1e-5
         b = b[0]
+        
+        try:
+            # Handle variable b
+            if isinstance(b, (str, np.str_)):
+                clean_str = str(b).replace('[', '').replace(']', '')
+                b = np.fromstring(clean_str, sep=' ')
+            elif isinstance(b, np.ndarray) and np.issubdtype(b.dtype, np.character):
+                clean_str = ' '.join(b.astype(str).flatten()).replace('[', '').replace(']', '')
+                b = np.fromstring(clean_str, sep=' ')
+            else:
+                b = np.asarray(b, dtype=float)
 
-        if isinstance(a, (str, np.str_)):
-            clean_str = str(a).replace('[', '').replace(']', '')
-            a = np.fromstring(clean_str, sep=' ')
-        elif isinstance(a, np.ndarray) and np.issubdtype(a.dtype, np.character):
-            # catches arrays filled with string text
-            clean_str = ' '.join(a.astype(str).flatten()).replace('[', '').replace(']', '')
-            try:
+            # handle variable a            
+            if isinstance(a, (str, np.str_)):
+                clean_str = str(a).replace('[', '').replace(']', '')
                 a = np.fromstring(clean_str, sep=' ')
-            except:
-                clean_string = clean_str.strip(",")  
-                a = np.fromstring(clean_string, sep=' ')                              
-        else:
-            # Ensure standard float array if it was integers or objects
-            a = np.asarray(a, dtype=float)
-
-        # Handle variable b
-        if isinstance(b, (str, np.str_)):
-            clean_str = str(b).replace('[', '').replace(']', '')
-            b = np.fromstring(clean_str, sep=' ')
-        elif isinstance(b, np.ndarray) and np.issubdtype(b.dtype, np.character):
-            clean_str = ' '.join(b.astype(str).flatten()).replace('[', '').replace(']', '')
-            b = np.fromstring(clean_str, sep=' ')
-        else:
-            b = np.asarray(b, dtype=float)
+            elif isinstance(a, np.ndarray) and np.issubdtype(a.dtype, np.character):
+                # catches arrays filled with string text
+                clean_str = ' '.join(a.astype(str).flatten()).replace('[', '').replace(']', '')
+                try:
+                    a = np.fromstring(clean_str, sep=' ')
+                except:
+                    clean_string = clean_str.strip(",")  
+                    a = np.fromiter(
+                        (x for x in clean_string.split() if x != "..."), dtype=float
+                    )
+            else:
+                # Ensure standard float array if it was integers or objects
+                a = np.asarray(a, dtype=float)
 
-        norm_a = np.linalg.norm(a)
-        norm_b = np.linalg.norm(b)
-    
-        if len(a.shape) > 1 and len(b.shape) > 1 and a.shape[1] != b.shape[0]:
-            a = np.asarray(a)
-            b = np.asarray(b)
-            subset_a = a[0, :b.shape[0]]
-            subset_b = a[:subset_a.shape[0], 0]
+            norm_a = np.linalg.norm(a)
+            norm_b = np.linalg.norm(b)
+        
+            if len(a.shape) > 1 and len(b.shape) > 1 and a.shape[1] != b.shape[0]:
+                a = np.asarray(a)
+                b = np.asarray(b)
+                subset_a = a[0, :b.shape[0]]
+                subset_b = a[:subset_a.shape[0], 0]
 
-            try:
                 try:
-                    dot_product = np.dot(subset_a, subset_b)
+                    try:
+                        dot_product = np.dot(subset_a, subset_b)
+                    except:
+                        dot_product = np.dot(subset_a[0, :min(subset_a.shape[1], subset_b.shape[0])], subset_b[:min(subset_a.shape[1], subset_b.shape[0])])
                 except:
-                    dot_product = np.dot(subset_a[0, :min(subset_a.shape[1], subset_b.shape[0])], subset_b[:min(subset_a.shape[1], subset_b.shape[0])])
-            except:
+                    try:
+                        dot_product = np.dot(a.flatten(), b[:a.flatten().shape[0]])
+                    except:
+                        try:
+                            dot_product = np.dot(a[:b.shape[0]], b.flatten()[:a.shape[0]])
+                        except:
+                            print('[-] No similarity due to inhomogenous shapes and failed attempts to find subsets, returning low similarity score.')
+                            return 0.1
+        
+            else:
+                subset_a = a[:a.shape[0]]
+                subset_b = b[:subset_a.shape[0]]
+
                 try:
-                    dot_product = np.dot(a.flatten(), b[:a.flatten().shape[0]])
+                    dot_product = np.dot(subset_a, subset_b) 
                 except:
                     try:
-                        dot_product = np.dot(a[:b.shape[0]], b.flatten()[:a.shape[0]])
+                        subset_b_2 = subset_b[:subset_a.shape[1], :subset_a.shape[0]]  
+                        dot_product = np.dot(subset_a, subset_b_2)
+
                     except:
                         print('[-] No similarity due to inhomogenous shapes and failed attempts to find subsets, returning low similarity score.')
-                        return 0.1
-       
-        else:
-            subset_a = a[:a.shape[0]]
-            subset_b = b[:subset_a.shape[0]]
-
-            try:
-                dot_product = np.dot(subset_a, subset_b) 
-            except:
-                try:
-                    subset_b_2 = subset_b[:subset_a.shape[1], :subset_a.shape[0]]  
-                    dot_product = np.dot(subset_a, subset_b_2)
+    
+                        return 0.0         
 
-                except:
-                    print('[-] No similarity due to inhomogenous shapes and failed attempts to find subsets, returning low similarity score.')
-  
-                    return 0.0         
+            cosine = dot_product / (norm_a * norm_b)
+            cosine = np.clip(cosine, -1.0, 1.0)
 
-        cosine = dot_product / (norm_a * norm_b)
-        cosine = np.clip(cosine, -1.0, 1.0)
+        except Exception as e:
+            print(f'[!] Cant calculate cosine similarity: {e}')
+            cosine = 0.0
 
         return cosine  
 
     def anisotropy_measurement(self, x):
         eps = 1e-5
+
         if isinstance(x, list):
             print(f'[=] Converting list to array with shape: {len(x)}')
             x = np.array(x)
             x = x.reshape(x.shape[0], -1)  # Flatten if necessary
+
         try:
-            gradient = np.gradient(x)
-        except:
-            subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
-            gradient = np.gradient(subnet.flatten())
+            try:
+                grads = np.gradient(x)
+                # Stack gradients into a single array of vectors and find the norm of each
+                # automatically handles multi-dimensional arrays (e.g., 2D, 3D volumes)
+                stacked_grads = np.stack(grads, axis=-1)
+                norms = np.linalg.norm(stacked_grads, axis=-1)
+                
+                # Safely filter out potential NaNs or infs (common at array boundaries)
+                valid_norms = norms[np.isfinite(norms)]
+                
+                if len(valid_norms) == 0:
+                    return 0.0 # Return zero or appropriate default if no valid values exist
+                    
+                # Calculate statistics using the clean data
+                std_val = np.std(valid_norms)
+                mean_val = np.mean(valid_norms)
+                
+                anisotropy = std_val / (mean_val + eps)    
+                if np.isnan(anisotropy) or np.isinf(anisotropy):
+                    anisotropy = self.pipeline.confidence_threshold
+            except:
+                try:
+                    gradient = np.gradient(x)
+                except:
+                    subnet = x[:min(10, x.shape[0]), :min(10, x.shape[1])]
+                    gradient = np.gradient(subnet.flatten())
 
-        val = [np.linalg.norm(v) for v in gradient]
-        anisotropy = np.std(val) / np.mean(val) + eps
-        return anisotropy 
+                val = [np.linalg.norm(v) for v in gradient]
+                anisotropy = np.std(val) / np.mean(val) + eps 
+        except Exception as e:
+            print(f'[!] Cant calculate anisotropy due to: {e}')   
+            anisotropy = self.confidence_threshold
+
+        if np.isnan(anisotropy) or np.isinf(anisotropy):
+            anisotropy = self.confidence_threshold
+
+        return anisotropy
 
     def modular_prediction_saving(self, X, X2, output):
         memory_name = self.memory_name
@@ -9173,7 +9274,9 @@ class IntegratedPipeline:
         if isinstance(X, np.ndarray) and np.issubdtype(X.dtype, np.character):
             # catches arrays filled with string text
             clean_str = ' '.join(X.astype(str).flatten()).replace('[', '').replace(']', '')
-            X = np.fromstring(clean_str, sep=' ')
+            X = np.fromiter(
+                    (x for x in clean_str.split() if x != "..."), dtype=float
+                )   
 
         X = np.squeeze(X)
         if X.ndim == 1:
@@ -10739,7 +10842,7 @@ class PipelineAsyncManager:
             # Input validation
             try:
                 try:
-                    if not 'test_titles' in texts and 'label_map' in texts and 'rules' in texts:
+                    if not 'test_titles' in texts and 'label_map' in texts and 'rules' in texts and 'X' in texts and 'y' in texts:
                         for i in range(len(texts)):
                             if isinstance(texts[i], tuple):
                                 texts[i] = texts[i][0]  # Extract text from tuple if needed
@@ -10788,8 +10891,8 @@ class PipelineAsyncManager:
                             
                         result = self._predict_sync(texts, timeout)
                     else:
-                        if 'test_titles' in texts and 'label_map' in texts and 'rules' in texts:
-                            result = self._advanced_predict_sync(texts['test_titles'], texts['label_map'], texts['rules'], texts.get('agent_id', 'default'), texts.get('use_transformer', False), timeout)
+                        if 'test_titles' in texts and 'label_map' in texts and 'rules' in texts and 'X' in texts and 'y' in texts:
+                            result = self._advanced_predict_sync(texts['test_titles'], texts['label_map'], texts['rules'], texts['X'], texts['y'], texts.get('agent_id', 'default'), texts.get('use_transformer', False), timeout)
                         else:
                             if isinstance(texts, tuple):
                                 texts = texts[0]
@@ -10853,7 +10956,7 @@ class PipelineAsyncManager:
         finally:
             self._remove_task(task_id)
 
-    def _advanced_predict_sync(self, test_titles, label_map, rules, agent_id: str, use_transformer: bool=False, timeout: float = 30.0) -> Any:
+    def _advanced_predict_sync(self, test_titles, label_map, rules, X=None, y=None, agent_id: str=None, use_transformer: bool=False, timeout: float = 30.0) -> Any:
         # Internal synchronous prediction.
 
         if not self._loop or not self._loop.is_running():
@@ -10861,7 +10964,7 @@ class PipelineAsyncManager:
 
     
         future = asyncio.run_coroutine_threadsafe(
-            self.advanced_predict_async_await(test_titles, label_map, rules, use_transformer, agent_id, timeout),
+            self.advanced_predict_async_await(test_titles, label_map, rules, X=X, y=y, use_transformer=use_transformer, agent_id=agent_id, timeout=timeout),
             self._loop
         )
         
@@ -10884,7 +10987,7 @@ class PipelineAsyncManager:
         except asyncio.TimeoutError:
             raise FutureTimeoutError(f"[-] Prediction timed out after {timeout}s")
     
-    async def advanced_predict_async_await(self, test_titles: list[tuple], label_map: dict, rules: list[tuple], use_transformer: bool=False, agent_id: str=None, timeout: float = 30.0):
+    async def advanced_predict_async_await(self, test_titles: list[tuple], label_map: dict, rules: list[tuple], X: np.ndarray=None, y: np.ndarray=None, use_transformer: bool=False, agent_id: str=None, timeout: float = 30.0):
         # Async advanced prediction with await support. 
         try:
             return await asyncio.wait_for(
@@ -10895,6 +10998,7 @@ class PipelineAsyncManager:
                     test_titles=test_titles,
                     label_map=label_map,
                     rules=rules,
+                    X=X, y=y,
                     timeout=timeout
                 ),
                 timeout=timeout+5
@@ -11106,7 +11210,7 @@ class PipelineAsyncManager:
             self._save_state()
 
 
-    def advanced_batch_prediction(self, test_titles, label_map, rules, api_key, client_ip):
+    def advanced_batch_prediction(self, test_titles, label_map, rules, X=None, y=None, api_key=None, client_ip=None):
         try:
             reverse_label_map = {v: k for k, v in label_map.items()}
 
@@ -11115,29 +11219,29 @@ class PipelineAsyncManager:
             expected_labels = [text[1] for text in test_titles]  # Your ground truth
             predicted_output = []
 
-            text = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True}
+            text = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "X":X, "y":y, "use_transformer": True}
 
             if not self.pipeline.intents:
                 advanced_result = self.predict(
                 text, 
-                timeout=40,
+                timeout=120,
                 retries=None,
                 api_key=api_key,
                 client_ip=client_ip,
                 ) # regular predict to populate pipelines data
             else:
                 advanced_result = self.advanced_prediction_method(self.prediction_manager
-                , test_titles, label_map, rules, method='Transformer_included')
+                , test_titles, label_map, rules, X=X, y=y, method='Transformer_included')
 
-            print(f'[=+=] Local advanced Prediction result: {advanced_result}')
+            print(f'[=+=] Local single advanced Prediction result: {advanced_result}')
 
             print('[=] Initiating Batch prediction for multiple texts...')
             results = self.predict_batch(
                 texts=texts,
-                timeout=60,
+                timeout=120,
                 api_key=api_key)
 
-            print("📊 PREDICTION RESULTS")
+            print("========📊 PREDICTION RESULTS============")
            
             for text, expected, probs in zip(texts, expected_labels, results):
                 # probs is an array of 8 probability values
@@ -11167,6 +11271,7 @@ class PipelineAsyncManager:
                     print(f"[❌] INCORRECT LABEL (expected: {expected})")
 
                 predicted_output.append(predicted_label)
+                predicted_output.append(advanced_result)
 
             # Get stats
             print(f"[=] Stats: {self.get_stats()}")        
@@ -11198,7 +11303,7 @@ class PipelineAsyncManager:
             results.append(result)
         return results
 
-    def advanced_prediction_method(self, manager, test_titles, label_map, rules, method='Transformer_included'):
+    def advanced_prediction_method(self, manager, test_titles, label_map, rules, X=None, y=None, method='Transformer_included'):
         # starting PredictionManager for advanced prediction
         try:
             if method == 'Transformer_included':
@@ -11207,6 +11312,7 @@ class PipelineAsyncManager:
                 test_titles,  # Titles with expected labels
                 label_map,
                 rules,
+                X=X, y=y,
                 show_proba=True,
                 top_k=4,
                 use_transformer=self.pipeline.use_transformer,
@@ -11219,6 +11325,7 @@ class PipelineAsyncManager:
                 [t[0] for t in test_titles],  # Just titles
                 label_map,
                 rules,
+                X=X, y=y,
                 show_proba=True
                 )
         except Exception as e:
@@ -11286,6 +11393,8 @@ class PipelineAsyncManager:
                     test_titles=request['test_titles'],
                     label_map=request['label_map'],
                     rules=request['rules'],
+                    X=request['X'],
+                    y=request['y'],
                     timeout=self.default_timeout
                 ),
                 self._loop
@@ -11485,7 +11594,7 @@ class PipelinePredictionManager:
             reverse_map = {v: k for k, v in label_map.items()}
             num_classes = len(label_map)
 
-            if X and y is None or X is None or y is None:
+            if X is None and y is None or X is None or y is None:
                 print('[🔄] Creating automatic X samples because X is not provided manually.')
                 dataset, X = self.pipeline.data_preparation(titles, label_map)  
                 _, y, _, _ = self.pipeline.mlp_training_features(rules, dataset)                  
@@ -11766,6 +11875,7 @@ class PipelinePredictionManager:
 
         except Exception as e:
             print(f"[=] Error during prediction: {e}")
+            traceback.print_exc()
             results = []
 
         return results
@@ -11785,7 +11895,7 @@ class PipelinePredictionManager:
 
         try:
 
-            if X_raw and y is None or X_raw is None or y is None:
+            if X_raw is None and y is None or X_raw is None or y is None:
                 print('[🔄] Creating automatic X samples because X is not provided manually.')
                 datasets, X_raw = self.pipeline.data_preparation(titles, label_map)  
             else:
@@ -12006,7 +12116,7 @@ class PipelinePredictionManager:
             self.pipeline.titles = titles
             self.pipeline.labels = label_map
 
-            if X and y is None or X is None or y is None:
+            if X is None and y is None or X is None or y is None:
                 print('[🔄] Creating automatic X samples because X is not provided manually.')
                 dataset, X = self.pipeline.data_preparation(titles, label_map)  
                 _, y, _, _ = self.pipeline.mlp_training_features(rules, dataset)                  
@@ -12028,16 +12138,16 @@ class PipelinePredictionManager:
                     input_ids_list.append(np.array(ids))
                 
                 input_ids = np.array(input_ids_list)
-                
-                # Get transformer predictions with attention
-                if self.pipeline.anisotropy_measurement(input_ids) < self.pipeline.confidence_threshold:
-                    print("[⚡] Low anisotropy detected on input, relying on sequence encoding for input...")
-                    sequence_ids = self.pipeline.sequence_encoding(dataset)
-                    use_embedded = True
-                    trans_probs, attn_weights = self.pipeline.model2.forward(sequence_ids, embedded=use_embedded)
+                sequence_ids = self.pipeline.sequence_encoding(dataset)
+                if X is not None:
+                    anisotropy = self.pipeline.anisotropy_measurement(X)
                 else:
-                    print("[⚡] Anisotropy above threshold, using standard input encoding for transformer...")
-                    trans_probs, attn_weights = self.pipeline.model2.forward(input_ids, embedded=use_embedded)    
+                    anisotropy = self.pipeline.anisotropy_measurement(sequence_ids)
+
+                # 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)
 
             else:
                 print("\n[⚡] Running MLP-only predictions")
@@ -12483,12 +12593,14 @@ 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']
                 confidence = results[0]['confidence']
             except Exception as error:
                 print(f'[= ! =] Error in all prediction method: {error}')
+                traceback.print_exc()
                 results, chosen_label, confidence = None, None, 0.0
                 time.sleep(5)
 
@@ -12663,10 +12775,13 @@ class ConsecutivePeerAgent:
                     test_titles = text['test_titles']
                     label_map = text['label_map']
                     rules = text['rules']
+                    X = text['X']
+                    y = text['y']
                     result, chosen_label, confidence = self.manager.advanced_prediction_method(
                         test_titles,
                         label_map,
                         rules,
+                        X=X, y=y,
                         show_proba=False,
                         use_transformer=self.pipeline.use_transformer
                     )                    
@@ -13212,7 +13327,7 @@ class CohesiveAgentDeployment:
         # This runs in a thread pool via asyncio.to_thread
         return self.async_manager.predict(
             texts=texts,
-            timeout=40,
+            timeout=120,
             retries=None,
             api_key=api_key,
             client_ip=client_ip,
@@ -13545,7 +13660,7 @@ class CohesiveAgentDeployment:
 
             result = await asyncio.wait_for(
                 self.predict_with_peers(texts, api_key, method, disable_sync=disable_sync),
-                timeout=60.0
+                timeout=120.0
             )
             
             # Check if result is valid
@@ -13973,11 +14088,14 @@ class CohesiveAgentDeployment:
                 test_titles = texts['test_titles']
                 label_map = texts['label_map']
                 rules = texts['rules']
+                X = texts['X']
+                y = texts['y']
 
                 result, chosen_label, confidence = self.manager.advanced_prediction_method(
                     test_titles,
                     label_map,
                     rules,
+                    X=X, y=y,
                     show_proba=True,
                     use_transformer=self.pipeline.use_transformer
                 )
@@ -14227,7 +14345,7 @@ class CohesiveAgentDeployment:
  
 
 # ============ EXAMPLE: SECURE PEER-TO-PEER CLUSTER ============
-async def run_secure_agent_cluster(pipeline,test_titles, label_map, rules, agent_id, filename, title_name, label_name, manager):
+async def run_secure_agent_cluster(pipeline,test_titles, label_map, rules, X=None, y=None, agent_id=None, filename=None, title_name=None, label_name=None, manager=None):
     """
     Run multiple agents that securely communicate.
     Stops retrying once connected successfully.
@@ -14288,7 +14406,7 @@ async def run_secure_agent_cluster(pipeline,test_titles, label_map, rules, agent
         api_key = agent1.get_api_key()
         print(f"\n🔑 Using API Key: {api_key[:20]}...")
         
-        texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True, "agent_id": agent_id}
+        texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "X":X, "y":y, "use_transformer": True, "agent_id": agent_id}
 
         # Make prediction with peer ensemble
         # Peer Connection will be ensured successful during P2P 
@@ -14331,7 +14449,7 @@ async def run_secure_agent_cluster(pipeline,test_titles, label_map, rules, agent
 
 
 
-async def example_async_with_result_queue(pipeline, test_titles, label_map, rules, agent_id, filename, title_name, label_name):
+async def example_async_with_result_queue(pipeline, test_titles, label_map, rules, X=None, y=None,agent_id=None, filename=None, title_name=None, label_name=None):
     # Example using the proper result queue
     
     agent = CohesiveAgentDeployment(
@@ -14346,7 +14464,7 @@ async def example_async_with_result_queue(pipeline, test_titles, label_map, rule
     await agent.start()
     
     api_key = agent.get_api_key()
-    payloads = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True, "agent_id": agent_id}
+    payloads = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "X":X, "y":y, "use_transformer": True, "agent_id": agent_id}
     
     # Single async prediction
     print('[==] Single sync prediction: (using single text: "Opening Thesis.docx")')
@@ -14396,45 +14514,45 @@ async def example_async_with_result_queue(pipeline, test_titles, label_map, rule
 
 
 
-def initiate_cohesive_agent_deployment_test(pipeline, test_titles, label_map, rules, agent_id, filename, title_name, label_name, manager):
+def initiate_cohesive_agent_deployment_test(pipeline, test_titles, label_map, rules, X, y, agent_id, filename, title_name, label_name, manager):
     print("\n" + "="*60)
     print("🔮 = TESTING COHESIVE AGENT DEPLOYMENT WITH ASYNC MANAGER = ")
 
     print('Test 1 of Multi agent cluster')
-    asyncio.run(run_secure_agent_cluster(pipeline=pipeline, test_titles=test_titles, label_map=label_map, rules=rules, agent_id=agent_id, filename=filename, title_name=title_name, label_name=label_name, manager=manager))
+    asyncio.run(run_secure_agent_cluster(pipeline=pipeline, test_titles=test_titles, label_map=label_map, rules=rules, X=X, y=y, agent_id=agent_id, filename=filename, title_name=title_name, label_name=label_name, manager=manager))
       
     print("\n1. Basic async with result queue")
-    asyncio.run(example_async_with_result_queue(pipeline=pipeline, test_titles=test_titles, label_map=label_map, rules=rules, agent_id=agent_id, filename=filename, title_name=title_name, label_name=label_name))
+    asyncio.run(example_async_with_result_queue(pipeline=pipeline, test_titles=test_titles, label_map=label_map, rules=rules, X=X,y=y, agent_id=agent_id, filename=filename, title_name=title_name, label_name=label_name))
     
 
 # async manager setup examples
-def initiate_prediction_usage(pipeline, manager, predict_wrapper, test_titles, label_map, rules):
+def initiate_prediction_usage(pipeline, manager, predict_wrapper, test_titles, label_map, rules, X, y):
     """Basic synchronous usage."""
     # Use context manager (auto start/stop)
     api_key = 'my-ultra-safe-secret-key-for-authentication'
 
     with predict_wrapper as wrapper:
         print('[==] Initiating regular prediction')
-        texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': rules, 'use_transformer': True}
+        texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': rules, "X":X, "y":y,'use_transformer': True}
         regular_predict = wrapper.predict(
         texts=texts, 
-        timeout=40,
+        timeout=120,
         retries=None,
         api_key=api_key,
         client_ip=None)
 
         print('[==] Initiating advanced batch prediction')
-        predicted_output = wrapper.advanced_batch_prediction(test_titles, label_map, rules, api_key, client_ip=None)
+        predicted_output = wrapper.advanced_batch_prediction(test_titles, label_map, rules, X=None, y=None, api_key=api_key, client_ip=None)
 
 
-def initiate_with_retries(pipeline, manager, wrapper, test_titles, label_map, rules):
+def initiate_with_retries(pipeline, manager, wrapper, test_titles, label_map, rules, X, y):
     """Example with retry logic."""
     
     try:
         # Will retry up to 5 times
-        texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True}
+        texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "X":X, 'y':y, "use_transformer": True}
         result = wrapper.predict(texts, timeout=60, retries=None, api_key=None)
-        advanced_result, chosen_label, confidence = wrapper.advanced_prediction_method(manager, test_titles, label_map, rules, method='Transformer_included')
+        advanced_result, chosen_label, confidence = wrapper.advanced_prediction_method(manager, test_titles, label_map, rules, X=X, y=y, method='Transformer_included')
         print(f"[=] Result after retries: {result}")
         print(f"[=] Advanced Result: {chosen_label} || ({confidence:.1%})")
 
@@ -14460,7 +14578,7 @@ def initiate_graceful_shutdown(pipeline, wrapper):
     # Graceful shutdown
     wrapper.stop()
 
-def AsyncWrappertest(pipeline, prediction_manager, test_titles, label_map, rules):
+def AsyncWrappertest(pipeline, prediction_manager, test_titles, label_map, rules, X, y):
     print("\n" + "="*60)
     print("🔮 = TESTING ASYNCHRONOUS PREDICTION WRAPPER = ")
     print("="*60)
@@ -14496,8 +14614,8 @@ def AsyncWrappertest(pipeline, prediction_manager, test_titles, label_map, rules
     logging.basicConfig(level=logging.INFO)
     
     # Run examples
-    initiate_prediction_usage(pipeline, prediction_manager, wrapper, test_titles, label_map, rules)
-    initiate_with_retries(pipeline, prediction_manager, wrapper, test_titles, label_map, rules)
+    initiate_prediction_usage(pipeline, prediction_manager, wrapper, test_titles, label_map, rules, X, y)
+    initiate_with_retries(pipeline, prediction_manager, wrapper, test_titles, label_map, rules, X, y)
     initiate_graceful_shutdown(pipeline, wrapper)
 
     print("\n✅ Asynchronous prediction wrapper test completed successfully.")
@@ -14628,6 +14746,7 @@ def PermissiveTest():
     ]
 
     running = True
+    X, y = None, None
     while running:
         permission = input('|| Allow Hybrid prediction test? [Y/N]: ')
 
@@ -14637,6 +14756,7 @@ def PermissiveTest():
             [t[0] for t in test_titles],  # Just titles
             label_map,
             rules,
+            X=X, y=y,
             show_proba=True
             )
             time.sleep(5)
@@ -14671,16 +14791,16 @@ def PermissiveTest():
 
         permission_continue = input('|| Do you want to test the Asynchronous wrapper for multiple predictions? [Y/N]: ')
         if permission_continue == 'Y' or permission_continue == 'y':
-            AsyncWrappertest(pipeline, manager, test_titles, label_map, rules)
+            AsyncWrappertest(pipeline, manager, test_titles, label_map, rules, X, y)
             print('== Asynchronous wrapper Successfully tested! ==')
 
         cohesive_permission = input('|| Do you want to test the Cohesive Agent Deployment with Async Manager? [Y/N]: ')
         if cohesive_permission == 'Y' or cohesive_permission == 'y':
             if not (filename and title and label and filename != 'N'):
                 print('[=] Searching fallback filename: ManualsTraining.txt, window_title, label')
-                initiate_cohesive_agent_deployment_test(pipeline,test_titles, label_map, rules, agent_id, 'ManualsTraining.txt', 'window_title', 'label', manager)
+                initiate_cohesive_agent_deployment_test(pipeline,test_titles, label_map, rules, X, y, agent_id, 'ManualsTraining.txt', 'window_title', 'label', manager)
             else:
-                initiate_cohesive_agent_deployment_test(pipeline, test_titles, label_map, rules, agent_id, filename, title, label, manager)
+                initiate_cohesive_agent_deployment_test(pipeline, test_titles, label_map, rules, X, y, agent_id, filename, title, label, manager)
             print('== Cohesive Agent Deployment Successfully tested! ==')
 
         else:

{abstractintegratedmodule-0.4.5/AbstractIntegratedModule.egg-info → abstractintegratedmodule-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.4.5
+Version: 0.4.6
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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.4.5.
+- Development Stage: Beta, 0.4.6.
 - 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.
@@ -379,6 +379,10 @@ B. [=] Advanced Prediction without Transformer, Only Specialized MLP + LSTM usin
 
 ### Both performance Overview
 <img width="1536" height="1024" alt="WhatsApp Image 2026-05-24 at 10 27 00" src="https://github.com/user-attachments/assets/9404277f-281f-4893-8367-e494833230ea" />
+_______________________________________
+- Note: 
+   - This performance metric was calculated in older versions, With newer Transformers that has more, newer modules, The resulting cpu consumed may Increase 1.5 - 2x much more in Docker ARM64 Environment + QEMU, 
+   MLP And LSTM stays the same and still fully optimized.
 
 ## Source code of AbstractIntegratedModule 
 - Note: The source code is provided in the repository.
@@ -650,7 +654,8 @@ async_manager = PipelineAsyncManager(main_model,
 
 async_manager.start(method='Transformer_included', bootstrap_token=None) # boothstrap token is optional for better security
 
-texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': example_rules, 'use_transformer': True}
+texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': example_rules, 'X': None, 'y':None, 'use_transformer': True} # all samples needed for advanced prediction method. (X and y are optional samples)
+
 regular_predict = async_manager.predict(
    texts=texts,
    timeout=60,
@@ -660,7 +665,9 @@ regular_predict = async_manager.predict(
 # with retries: async_manager.predict(texts, timeout=60, retries=5, api_key=secret_key) # 5 times retry if failed
 
 print('[==] Initiating advanced batch prediction')
-predicted_output = async_manager.advanced_batch_prediction(test_titles, label_map, example_rules, secret_key, client_ip=None) # you can add client_ip to provide a robust authentication paired with secret_key
+         predicted_output = async_manager.advanced_batch_prediction(test_titles, label_map, example_rules, 
+         X=None, y=None, # provide your initialized X and y samples (Also Optional, can be set to None)
+         secret_key=secret_key, client_ip=None) # you can add client_ip to provide a robust authentication paired with secret_key
 # for better and faster advanced prediction, consider using advanced batch prediction like in the above example
 
 ```
@@ -766,7 +773,7 @@ try:
      api_key = agent1.get_api_key()
      print(f"\n🔑 Using API Key: {api_key[:20]}...")
 
-     texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True, "agent_id": agent_id}
+     texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, 'X': None, "y":None, "use_transformer": True, "agent_id": agent_id} # (X and y are optional samples here too)
 
      # texts dictionary must contain test_titles, label_map, and rules that you can assign,
      # agent ID can be strings, int, or floats, recommendded to make it long for better security.

{abstractintegratedmodule-0.4.5 → abstractintegratedmodule-0.4.6}/README.md

@@ -10,7 +10,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.4.5.
+- Development Stage: Beta, 0.4.6.
 - 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.
@@ -347,6 +347,10 @@ B. [=] Advanced Prediction without Transformer, Only Specialized MLP + LSTM usin
 
 ### Both performance Overview
 <img width="1536" height="1024" alt="WhatsApp Image 2026-05-24 at 10 27 00" src="https://github.com/user-attachments/assets/9404277f-281f-4893-8367-e494833230ea" />
+_______________________________________
+- Note: 
+   - This performance metric was calculated in older versions, With newer Transformers that has more, newer modules, The resulting cpu consumed may Increase 1.5 - 2x much more in Docker ARM64 Environment + QEMU, 
+   MLP And LSTM stays the same and still fully optimized.
 
 ## Source code of AbstractIntegratedModule 
 - Note: The source code is provided in the repository.
@@ -618,7 +622,8 @@ async_manager = PipelineAsyncManager(main_model,
 
 async_manager.start(method='Transformer_included', bootstrap_token=None) # boothstrap token is optional for better security
 
-texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': example_rules, 'use_transformer': True}
+texts = {'test_titles': test_titles, 'label_map': label_map, 'rules': example_rules, 'X': None, 'y':None, 'use_transformer': True} # all samples needed for advanced prediction method. (X and y are optional samples)
+
 regular_predict = async_manager.predict(
    texts=texts,
    timeout=60,
@@ -628,7 +633,9 @@ regular_predict = async_manager.predict(
 # with retries: async_manager.predict(texts, timeout=60, retries=5, api_key=secret_key) # 5 times retry if failed
 
 print('[==] Initiating advanced batch prediction')
-predicted_output = async_manager.advanced_batch_prediction(test_titles, label_map, example_rules, secret_key, client_ip=None) # you can add client_ip to provide a robust authentication paired with secret_key
+         predicted_output = async_manager.advanced_batch_prediction(test_titles, label_map, example_rules, 
+         X=None, y=None, # provide your initialized X and y samples (Also Optional, can be set to None)
+         secret_key=secret_key, client_ip=None) # you can add client_ip to provide a robust authentication paired with secret_key
 # for better and faster advanced prediction, consider using advanced batch prediction like in the above example
 
 ```
@@ -734,7 +741,7 @@ try:
      api_key = agent1.get_api_key()
      print(f"\n🔑 Using API Key: {api_key[:20]}...")
 
-     texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "use_transformer": True, "agent_id": agent_id}
+     texts = {"test_titles": test_titles, "label_map": label_map, "rules": rules, 'X': None, "y":None, "use_transformer": True, "agent_id": agent_id} # (X and y are optional samples here too)
 
      # texts dictionary must contain test_titles, label_map, and rules that you can assign,
      # agent ID can be strings, int, or floats, recommendded to make it long for better security.

{abstractintegratedmodule-0.4.5 → abstractintegratedmodule-0.4.6}/setup.py

@@ -8,7 +8,7 @@ class BinaryDistribution(Distribution):
 
 setup(
     name="AbstractIntegratedModule",
-    version="0.4.5",
+    version="0.4.6",
     description="Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",