AbstractIntegratedModule 0.9.4__tar.gz → 0.9.5__tar.gz

{abstractintegratedmodule-0.9.4 → abstractintegratedmodule-0.9.5}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.4
+Version: 0.9.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
@@ -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: 0.9.4 Official Release.
+- Development Stage: 0.9.5 Official Release.
 - 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.

{abstractintegratedmodule-0.9.4 → abstractintegratedmodule-0.9.5}/AbstractIntegratedModule.py

@@ -586,11 +586,15 @@ class Activation:
     @staticmethod
     def softmax(x):
         if _OPT_AVAILABLE:
-            return optimized_softmax_2d(np.asarray(x, dtype=np.float64))           
+            output = optimized_softmax_2d(np.asarray(x, dtype=np.float64))    
+            return output
+
         # numerical stability
         if x.ndim > 1:
             exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
-            return exp_x / np.sum(exp_x, axis=1, keepdims=True)
+            normalized = exp_x / np.sum(exp_x, axis=1, keepdims=True)
+            return normalized
+
         else:
             exp_x = np.exp(x - np.max(x, keepdims=True))
             return exp_x / np.sum(exp_x, keepdims=True) 
@@ -598,7 +602,7 @@ class Activation:
 class Loss:
     @staticmethod
     def categorical_crossentropy(y_true, y_pred):
-        eps = 1e-9
+        eps = 1e-5
         y_true = np.asarray(y_true, dtype=np.float64)
         y_pred = np.asarray(y_pred, dtype=np.float64)
 
@@ -637,6 +641,7 @@ class Loss:
 
     @staticmethod
     def softmax_crossentropy_derivative(y_true, y_pred):
+        eps = 1e-5
         y_true = np.asarray(y_true, dtype=np.float64)
         y_pred = np.asarray(y_pred, dtype=np.float64)
 
@@ -661,6 +666,7 @@ class Loss:
             return np.zeros((1, 1))
 
         cross_ent = (y_pred - y_true) / y_true.shape[0]
+
         return cross_ent
 
 
@@ -1713,7 +1719,7 @@ class Dense:
 
         return x
 
-    def multi_modal_linear_transformation(self, x):
+    def multi_modal_linear_transformation(self, x, perf_score):
         x = self._sanitize_string_chars(x)
 
         if len(x.shape) > 1 and x.shape[1] != self.W.shape[0]:
@@ -1755,16 +1761,16 @@ class Dense:
             except:
                 subnet_B = self.b[:sub_z.shape[0]]
                 
-            z = sub_z + subnet_B      
+            z = (sub_z + subnet_B) * perf_score  
 
         return z
 
 
-    def forward(self, x):
+    def forward(self, x, perf_score):
 
         x = self._sanitize_string_chars(x)
         self.x = x
-        self.z = self.multi_modal_linear_transformation(x)
+        self.z = self.multi_modal_linear_transformation(x, perf_score)
 
         if self.activation:
             self.a = self.activation(self.z)
@@ -1797,6 +1803,7 @@ class Dense:
 class SoftmaxOutput:
     def forward(self, x):
         self.out = Activation.softmax(x)
+
         return self.out
 
     def backward(self, dL_dZ):
@@ -1831,17 +1838,47 @@ class MLP:
     def add(self, layer):
         self.layers.append(layer)
 
-    def focused_forward(self, x):
+    def focused_forward(self, x, AME=None, anisotropy=None):    
+        performance_score = self.performance_calculation(x, AME=AME, anisotropy=anisotropy) 
+
         for layer in self.feed_layers:
-            x = layer.forward(np.asarray(x, dtype=np.float64))
+            x = layer.forward(np.asarray(x, dtype=np.float64), performance_score)
             
         return self.softmax.forward(x) 
 
-    def forward(self, x):
+    def performance_calculation(self, x, AME=None, anisotropy=None):
+        eps = 1e-5
+        standard_low_error_mean = eps
+        standard_pred_quality = eps
+
+        if AME is None and anisotropy is None:
+            AME = self.AME_Encoder(x)     
+            anisotropy = self.anisotropy_measurement(x)
+
+        gate_uncertain = (AME * anisotropy) + eps / 4
+        gate_certainty = (1.0 - AME) + eps / 4
+        if self.error_counts is not None and self.pred_counts is not None:
+            standard_low_error_mean = (1.0 - np.mean(self.error_counts) + eps / 4)
+            standard_pred_quality = np.mean(self.pred_counts) + eps / 4
+
+        performance_score = (gate_uncertain + gate_certainty + 
+                               standard_low_error_mean + standard_pred_quality)
+
+        if np.isnan(performance_score) or np.isinf(performance_score):
+            performance_score = 0.5
+
+        return performance_score
+
+    def forward(self, x, AME=None, anisotropy=None):
+        eps = 1e-5
+        performance_score = self.performance_calculation(x, AME=AME, anisotropy=anisotropy)
+
         for layer in self.layers:
-            x = layer.forward(x)
-   
-        return self.softmax.forward(x)
+            x = layer.forward(x, performance_score)
+
+        output = self.softmax.forward(x)
+
+        return output
         
     def _sanitize_string_chars(self, x):
         if isinstance(x, (str, np.str_)):
@@ -2038,14 +2075,15 @@ class MLP:
 
         AME = self.AME_Encoder(X)     
         anisotropy = self.anisotropy_measurement(X)
+
         focused_fit_condition = len(self.feed_layers) > 0 and anisotropy > 0.25 and AME > 0.25
         print(f'[+] Focused fit condition: {focused_fit_condition} || Anisotropy: {self.anisotropy_measurement(X):.4f} || AME: {self.AME_Encoder(X):.4f}')
 
         for epoch in range(epochs):
             if not focused_fit_condition:
-                y_pred = self.forward(X)
+                y_pred = self.forward(X, AME=AME, anisotropy=anisotropy)
             else:
-                y_pred = self.focused_forward(X)
+                y_pred = self.focused_forward(X, AME=AME, anisotropy=anisotropy)
 
             y_pred, y_true = self.adapt_predict_shape(y_pred, y)
             loss = Loss.categorical_crossentropy(y_true, y_pred)
@@ -8815,6 +8853,7 @@ class IntegratedPipeline:
         self.transformer_training_epochs = 100
         self.max_size = 500
         self.error_decay = 0.85
+        self.performance_result = 1.0
 
         # Main component setup
         self.standard_scaler = StandardScaler()
@@ -10548,6 +10587,8 @@ class IntegratedPipeline:
                 )
             else:
                 fresh_probs = self.model3.forward(fresh_X)
+                performance_result = self.model3.performance_calculation(fresh_X)
+                self.performance_result = performance_result
 
                 try:
                     fresh_trans_probs, _ = self.model2.forward(fresh_ids, embedded=False)
@@ -14328,11 +14369,13 @@ class PipelineAsyncManager:
     def advanced_batch_prediction(self, test_titles, label_map, rules,
                                 X=None, y=None, api_key=None, client_ip=None):
         try:
+            eps = 1e-5
             attn_weights     = None
             final_idx        = None
             attn_weight_rate = None
             confidence       = None    
             chosen_label     = None
+            performance_score = self.pipeline.performance_result
 
             reverse_label_map = {v: k for k, v in label_map.items()}
             n_classes         = len(label_map)
@@ -14437,6 +14480,8 @@ class PipelineAsyncManager:
                     predicted_index, f"class_{predicted_index}"
                 )
                 pred_conf = float(probs[predicted_index])
+                if pred_conf > 0.8:
+                    pred_conf = (pred_conf + performance_score) + eps / 2 
 
                 top_3_indices = np.argsort(probs)[-3:][::-1]
                 top_3 = [
@@ -15690,6 +15735,7 @@ class PipelinePredictionManager:
             X_gen = None
             correct = 0
             sec_correct= 0
+            performance_score = self.pipeline.performance_result
 
             if label_map is None:
                 raise ValueError("[!] label_map must be provided for all prediction methods!")
@@ -16304,9 +16350,11 @@ class PipelinePredictionManager:
                         try:
                             confidence = float(final_probs[0][final_idx])   
                         except:
-                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
+                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0  
+           
                     else:
                         final_probs = target_probs.copy() 
+
             else:
                 print("\n[🎯] Using initial Regular final prediction as final decision.")
                 final_idx = final_probs[0].argmax()
@@ -16317,11 +16365,14 @@ class PipelinePredictionManager:
                 final_idx = int(final_idx)
 
                 chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+
                 try:
                     confidence = float(final_probs[0][final_idx])   
                 except:
                     confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-                   
+            
+            if confidence > 0.8:
+                confidence = (confidence + performance_score) / 2 
 
             if isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
                 if chosen_label.startswith("unknown"):
@@ -16351,7 +16402,9 @@ class PipelinePredictionManager:
                     confidence = np.mean(confidence)
                 if isinstance(sec_confidence, (np.ndarray, list)):
                     sec_confidence = np.mean(sec_confidence) 
-
+                    
+                if sec_confidence > 0.8:
+                    sec_confidence = (sec_confidence + performance_score) + eps / 2 
 
                 if 'sec_predicted' in results and results['sec_predicted'] is None and sec_chosen_label:
                     print('========== Second Prediction Initiative ==========')