AbstractIntegratedModule 0.5.3__tar.gz → 0.5.5__tar.gz

{abstractintegratedmodule-0.5.3 → abstractintegratedmodule-0.5.5/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.5.3
-Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework For Non-LLM AI Agent
+Version: 0.5.5
+Summary: Library for Advanced Integrated Non-LLM AI Models - Optimized Backend Framework For Non-LLM AI Agent
 Author: Micro-Novelty
 Author-email: hernikpuspita5@gmail.com
 License: MIT
@@ -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.3.
+- Development Stage: Beta, 0.5.5.
 - 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,13 +64,16 @@ 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, With Reduced Training Time.
+   - Transformer Modules Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage, With Reduced Training Time.
 - Changelog:
-     - v0.5.3:
+     - v0.5.5:
           - [=] New features: 
-          - New cache management system for Transformers Cache
-          - Optimized Transformer Training time with less Computational overhead.
-          - Optimized Transformer attention quality computing with more newer Conditional gate for quality computing.
+          - Added Anisotropy measurement optimization in Cython to handle complex logic.
+          - Added Cython softmax for Transformer to reduce CPU consumption.
+          - Added Cython Cosine similarity to reduce ensemble prediction time needed for prediction.
+          - Added safety guards for Cosine similarity to prevent string arrays to cause further errors.
+
+      
 -----
 
 <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.3 → abstractintegratedmodule-0.5.5}/AbstractIntegratedModule.py

@@ -50,13 +50,16 @@ try:
         optimized_tanh_deriv,
         optimized_lstm_cell_forward,
         optimized_project_heads,
-        optimized_ame_encoder
+        optimized_ame_encoder,
+        optimized_anisotropy,
+        optimized_cosine_similarity,
+        optimized_softmax_2d
     )
     _OPT_AVAILABLE = True
     print('[=] Cython acceleration loaded ✅')
-except ImportError:
+except ImportError as e:
     _OPT_AVAILABLE = False
-    print('[=] Cython not available, using numpy fallback')
+    print(f'[=] Cython not available: {e}, using numpy fallback')
 
 # initial Setup logging for AgentDistributedInference and ModelStorage class logger and security logger
 logger = logging.getLogger(__name__)
@@ -383,6 +386,9 @@ class GeometricWeightShaping:
     # abstract modelling error provides the model how to better process weights when the data complexity has little geometric complexity
     def AME_Encoder(self, x):
         X = np.asarray(x)
+        if _OPT_AVAILABLE and np.asarray(X).ndim == 2:
+            return optimized_ame_encoder(np.asarray(X, dtype=np.float64))     
+
         try:
             gradient = np.gradient(x)
         except:
@@ -400,6 +406,10 @@ class GeometricWeightShaping:
     # anisotropy provides the model the standard complexity of the data geometry, allowing it to know how complex the data needs to be processed.
     def anisotropy_measurement(self, x):
         eps = 1e-5
+        if _OPT_AVAILABLE:
+            x = x.reshape(x.shape[0], -1)
+            return optimized_anisotropy(np.asarray(x, dtype=np.float64))
+
         try:
             gradient = np.gradient(x)
         except:
@@ -496,6 +506,8 @@ class Activation:
 
     @staticmethod
     def softmax(x):
+        if _OPT_AVAILABLE:
+            return optimized_softmax_2d(np.asarray(x, dtype=np.float64))           
         # numerical stability
         if x.ndim > 1:
             exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
@@ -691,6 +703,9 @@ class Transformer:
 
 
     def softmax(self, x):
+        if _OPT_AVAILABLE:
+            return optimized_softmax_2d(np.asarray(x, dtype=np.float64))    
+
         if x.ndim == 3:
             shifted = x - np.max(x, axis=-1, keepdims=True)
         else:
@@ -1166,6 +1181,7 @@ class Transformer:
 
         return grads, total_norm    
 
+
     def batch_padding_utility(self, sequences, pad_token_id=0):
         # sequences: list of 1-D np arrays of varying length
         max_len = max(len(s) for s in sequences)
@@ -1353,6 +1369,10 @@ class Transformer:
 
     def anisotropy_measurement(self, x):
         eps = 1e-5
+        if _OPT_AVAILABLE:
+            x = x.reshape(x.shape[0], -1)
+            return optimized_anisotropy(np.asarray(x, dtype=np.float64))
+
         try:
             gradient = np.gradient(x)
         except:
@@ -1637,6 +1657,8 @@ class MLP:
          
     def AME_Encoder(self, x):
         X = np.asarray(x)
+        if _OPT_AVAILABLE and np.asarray(X).ndim == 2:
+            return optimized_ame_encoder(np.asarray(X, dtype=np.float64))     
 
         if x.shape[1] == 1:
             x = x.T
@@ -1652,6 +1674,10 @@ class MLP:
 
     def anisotropy_measurement(self, x):
         eps = 1e-5
+        if _OPT_AVAILABLE:
+            x = x.reshape(x.shape[0], -1)
+            return optimized_anisotropy(np.asarray(x, dtype=np.float64))
+
         try:
             gradient = np.gradient(x)
         except:
@@ -2771,6 +2797,10 @@ class WeightedEnsemblePredictor:
         
     def anisotropy_measurement(self, x):
         eps = 1e-5
+        if _OPT_AVAILABLE:
+            x = x.reshape(x.shape[0], -1)            
+            return optimized_anisotropy(np.asarray(x, dtype=np.float64))
+
         try:
             try:
                 grads = np.gradient(x)
@@ -3671,6 +3701,9 @@ class ExplainabilityModule:
     
     def AME_Encoder(self, x):
         X = np.asarray(x)
+        if _OPT_AVAILABLE and np.asarray(X).ndim == 2:
+            return optimized_ame_encoder(np.asarray(X, dtype=np.float64))     
+
 
         try:
             gradient = np.gradient(x, axis=-1)
@@ -8099,6 +8132,26 @@ class IntegratedPipeline:
             print('[!] Value is single scalar! returning 0.0 similarity')
             return 0.0
 
+        if isinstance(a, (str, np.str_)):
+            clean_str = str(a).replace('[', '').replace(']', '')
+            a = np.fromstring(clean_str, sep=' ')
+        if 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(']', '')
+            a = np.fromiter(
+                    (v for v in clean_str.split() if a != "..."), dtype=float
+                )   
+
+        if isinstance(b, (str, np.str_)):
+            clean_str = str(b).replace('[', '').replace(']', '')
+            b = np.fromstring(clean_str, sep=' ')
+        if isinstance(b, np.ndarray) and np.issubdtype(b.dtype, np.character):
+            # catches arrays filled with string text
+            clean_str = ' '.join(b.astype(str).flatten()).replace('[', '').replace(']', '')
+            b = np.fromiter(
+                    (v for v in clean_str.split() if b != "..."), dtype=float
+                )           
+
         if isinstance(a[0], (np.ndarray, list)):
             norm_a = np.linalg.norm(a[0])
         else:
@@ -8108,7 +8161,16 @@ class IntegratedPipeline:
             norm_b = np.linalg.norm(b[0])
         else:
             norm_b = np.linalg.norm(b)
-    
+
+        if _OPT_AVAILABLE:
+            if len(a.shape) > 1:
+                a = np.asarray(a)
+                a = a.reshape(-1)  
+            if len(b.shape) > 1:
+                b = np.asarray(b)
+                b  = b.reshape(-1)
+            return optimized_cosine_similarity(np.asarray(a, dtype=np.float64), np.asarray(b, dtype=np.float64))     
+                  
         try:
             dot_product = np.dot(a, b)
         except:
@@ -8316,12 +8378,42 @@ class IntegratedPipeline:
 
     def cosine_similarity(self, a, b):
         eps = 1e-5
+        if isinstance(a, (str, np.str_)):
+            clean_str = str(a).replace('[', '').replace(']', '')
+            a = np.fromstring(clean_str, sep=' ')
+        if 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(']', '')
+            a = np.fromiter(
+                    (v for v in clean_str.split() if a != "..."), dtype=float
+                )   
+
+        if isinstance(b, (str, np.str_)):
+            clean_str = str(b).replace('[', '').replace(']', '')
+            b = np.fromstring(clean_str, sep=' ')
+        if isinstance(b, np.ndarray) and np.issubdtype(b.dtype, np.character):
+            # catches arrays filled with string text
+            clean_str = ' '.join(b.astype(str).flatten()).replace('[', '').replace(']', '')
+            b = np.fromiter(
+                    (v for v in clean_str.split() if b != "..."), dtype=float
+                )       
+
         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]
-        
+
+        if _OPT_AVAILABLE:
+            if len(a.shape) > 1:
+                a = np.asarray(a)
+                a = a.reshape(-1)  
+            if len(b.shape) > 1:
+                b = np.asarray(b)
+                b  = b.reshape(-1)
+
+            return optimized_cosine_similarity(np.asarray(a, dtype=np.float64), np.asarray(b, dtype=np.float64))     
+
         try:
             # Handle variable b
             if isinstance(b, (str, np.str_)):
@@ -8402,12 +8494,27 @@ class IntegratedPipeline:
 
     def anisotropy_measurement(self, x):
         eps = 1e-5
+    
+        if isinstance(x, (str, np.str_)):
+            clean_str = str(x).replace('[', '').replace(']', '')
+            x = np.fromstring(clean_str, sep=' ')
+        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.fromiter(
+                    (v for v in clean_str.split() if x != "..."), dtype=float
+                )   
+
+        if _OPT_AVAILABLE:
+            x = x.reshape(-1, 1)
+            return optimized_anisotropy(np.asarray(x, dtype=np.float64))
 
         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:
             try:
                 grads = np.gradient(x)
@@ -9524,37 +9631,46 @@ class IntegratedPipeline:
         batch_size = len(target_preds)
         eps = 1e-5
 
-        for i in range(batch_size):
-            mlp_target = target_preds[i]
+        try:
+            for i in range(batch_size):
+                mlp_target = target_preds[i]
 
-            if attn_weights is None:
-                anisotropy = self.anisotropy_measurement(mlp_target)     
-            else:
-                anisotropy = self.anisotropy_measurement(attn_weights[i])
-            if attn_weights is not None and i < len(attn_weights):
-                attn = attn_weights[i]
-    
-                score_quality = np.std(attn) if attn.size > 0 else self.confidence_threshold
-                abstract_score = self.confidence_threshold + score_quality * anisotropy
+                if attn_weights is None:
+                    anisotropy = self.anisotropy_measurement(mlp_target)     
+                else:
+                    try:
+                        anisotropy = self.anisotropy_measurement(attn_weights[i])
+                    except:
+                        anisotropy = self.anisotropy_measurement(attn_weights)
+
+                if attn_weights is not None and i < len(attn_weights):
+                    attn = attn_weights[i]
+        
+                    score_quality = np.std(attn) if attn.size > 0 else self.confidence_threshold
+                    abstract_score = self.confidence_threshold + score_quality * anisotropy
 
-            else:
-                if attn_weights is not None:
-                    score_quality = 1.0 / (1.0 + np.exp(-attn_weights[i]))
                 else:
-                    score_quality = 1.0 / (1.0 + np.exp(-mlp_target))
+                    if attn_weights is not None:
+                        score_quality = 1.0 / (1.0 + np.exp(-attn_weights[i]))
+                    else:
+                        score_quality = 1.0 / (1.0 + np.exp(-mlp_target))
 
-                abstract_score = (1.0 - score_quality) + eps
+                    abstract_score = (1.0 - score_quality) + eps
 
-            self.temperature = (1.0 - abstract_score) + score_quality * anisotropy
-            if isinstance(self.temperature, np.ndarray):
-                self.temperature = np.clip(np.mean(self.temperature), 1e-5, 5.0)
+                self.temperature = (1.0 - abstract_score) + score_quality * anisotropy
+                if isinstance(self.temperature, np.ndarray):
+                    self.temperature = np.clip(np.mean(self.temperature), 1e-5, 5.0)
 
-            try:
-                calibrated[i, mlp_target] = min(calibrated[i, mlp_target] * (1.5 * (1.0 - abstract_score)), 0.95)
-            except:
-                return calibrated
+                try:
+                    calibrated[i, mlp_target] = min(calibrated[i, mlp_target] * (1.5 * (1.0 - abstract_score)), 0.95)
+                except:
+                    return calibrated
+
+                calibrated[i] /= calibrated[i].sum()
+        except Exception as e:
+            print(f'[!] cant calibrate probability due to: {e}, returning regular probability.')
+            calibrated = calibrated.copy()
 
-            calibrated[i] /= calibrated[i].sum()
         return calibrated
     
     def _softmax(self, x):
@@ -9778,6 +9894,8 @@ class IntegratedPipeline:
             X = np.fromiter(
                     (x for x in clean_str.split() if x != "..."), dtype=float
                 )   
+        if _OPT_AVAILABLE and np.asarray(X).ndim == 2:
+            return optimized_ame_encoder(np.asarray(X, dtype=np.float64))     
 
         X = np.squeeze(X)
         if X.ndim == 1:
@@ -13131,6 +13249,10 @@ class PipelinePredictionManager:
         if self.pipeline.autonomous and sec_confidence > self.pipeline.confidence_threshold:
             print(f'[⚡] Autonomous Prediction used second predicted label: {sec_chosen_label}')
             chosen_label = sec_chosen_label
+        
+        # delete pipelines cache
+        print('[🔍] Pipelines Cache Cleaned!')
+        self.pipeline.cache.clear()
 
         return results, chosen_label, confidence
         
@@ -13150,14 +13272,15 @@ class PipelinePredictionManager:
             if result.get('expected'):
                 total_with_expected += 1
                 status = ": ✅" if result['predicted'] == result['expected'] else ": ❌"
-                sec_status = ": ✅" if result['sec_predicted'] == result['expected'] else ": ❌"
                 print(f"[=] First Expectation: {result['expected']} || Model Answer: {status}")
-                print(f"[=] Second Expectation: {result['expected']} || Model Answer: {sec_status}")    
+                if 'sec_predicted' in result:
+                    sec_status = ": ✅" if result['sec_predicted'] == result['expected'] else ": ❌"                
+                    print(f"[=] Second Expectation: {result['expected']} || Model Answer: {sec_status}")    
+                    if result['sec_predicted'] == result['expected']:
+                        sec_correct += 1
 
                 if result['predicted'] == result['expected']:
                     correct += 1
-                if result['sec_predicted'] == result['expected']:
-                    sec_correct += 1
             
             # Agreement indicator
             agree_symbol = "✓" if result.get('models_agree', True) else "⚠️"