AbstractIntegratedModule 0.9.0__tar.gz → 0.9.1__tar.gz

{abstractintegratedmodule-0.9.0 → abstractintegratedmodule-0.9.1}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.0
+Version: 0.9.1
 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.0 Official Release.
+- Development Stage: 0.9.1 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.
@@ -80,7 +80,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Transformer Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage, With Reduced Training Time.
 ______________
   - Changelog:
-     - v0.9.0:
+     - v0.9.1:
         - [=] New features: 
         - Ensemble method prediction is now secondary after conditions are met, and no longers acts as the Main prediction flow, Single pass (One Model) prediction now governs the Main prediction for long term stability and determinism in its learning capability.
         - Modifed advanced prediction to use single pass prediction as its main prediction method, ensemble prediction will be triggered when conditions are met.

{abstractintegratedmodule-0.9.0 → abstractintegratedmodule-0.9.1}/AbstractIntegratedModule.py

@@ -10177,7 +10177,11 @@ class IntegratedPipeline:
                 )
             else:
                 fresh_probs = self.model3.forward(fresh_X)
-                fresh_trans_probs, _ = self.model2.forward(fresh_ids, embedded=False)
+                try:
+                    fresh_trans_probs, _ = self.model2.forward(fresh_input_ids, embedded=False)
+                except:
+                    fresh_trans_probs, _ = self.model2.forward(fresh_input_ids, embedded=True)
+                    
                 fresh_mlp_confidence = fresh_probs.max(axis=1, keepdims=True)
                 fresh_trans_confidence = fresh_trans_probs.max(axis=1, keepdims=True)
 
@@ -10324,7 +10328,7 @@ class IntegratedPipeline:
         return result[0]
  
 
-    def _batch_hybrid_prediction(self, batch_input_ids, batch_X_raw, y_true):
+    def _batch_hybrid_prediction(self, batch_input_ids, batch_X_raw, y_true, embedded=True):
         print('[+] Initiating hybrid prediction batching...')
 
         num_classes = self._get_num_classes()
@@ -10337,6 +10341,10 @@ class IntegratedPipeline:
         fresh_probs = None                    # FIX 1 — explicit init, no UnboundLocalError
 
         needs_prediction = [i for i, p in enumerate(batch_probs) if p is None]
+        need_ensemble = (
+            len(chunk_ids) > 100 and
+            len(chunk_X) > 100 
+        )
 
         if needs_prediction:
             fresh_input_ids = batch_input_ids[needs_prediction]
@@ -10350,10 +10358,33 @@ class IntegratedPipeline:
             else:
                 fresh_y_true = np.zeros((len(needs_prediction), num_classes))
 
-            fresh_probs, details = self.ensemble.predict_ensemble(
-                fresh_input_ids, fresh_X_raw, fresh_y_true,
-                method='dynamic', embedded=False
-            )
+            if need_ensemble:
+                fresh_probs, _ = self.ensemble.predict_ensemble(
+                    fresh_input_ids, fresh_X_raw,
+                    np.zeros((len(fresh_ids), num_classes)),
+                    method='dynamic', embedded=embedded
+                )
+            else:
+                fresh_probs = self.model3.forward(fresh_X_raw)
+                try:
+                    fresh_trans_probs, _ = self.model2.forward(fresh_input_ids, embedded=False)
+                except:
+                    fresh_trans_probs, _ = self.model2.forward(fresh_input_ids, embedded=embedded)
+
+                fresh_mlp_confidence = fresh_probs.max(axis=1, keepdims=True)
+                fresh_trans_confidence = fresh_trans_probs.max(axis=1, keepdims=True)
+
+                if fresh_mlp_confidence >= fresh_trans_confidence:
+                    fresh_probs = fresh_probs.copy()
+                else:
+                    fresh_probs = fresh_trans_probs.copy()
+
+                if np.std(fresh_probs) < 0.3 or np.mean(fresh_probs) < 0.3:
+                    fresh_probs, _ = self.ensemble.predict_ensemble(
+                        fresh_input_ids, fresh_X_raw,
+                        np.zeros((len(fresh_ids), num_classes)),
+                        method='dynamic', embedded=embedded
+                    )   
 
             # validate fresh_probs shape before assignment
             fresh_probs = np.asarray(fresh_probs)
@@ -10536,9 +10567,15 @@ class IntegratedPipeline:
 
     def hybrid_prediction(self, rules, input_ids, dataset):
         X, y, _, _ = self.feature_generation(rules, dataset) 
+        if isinstance(input_ids, list):
+            try:
+                input_ids = np.asarray(input_ids)
+            except Exception as e:
+                input_ids = self._safe_to_2d_float(input_ids)
+                
         if len(input_ids.shape) == 2 and input_ids.shape[0] > 1:
             # this is batch mode version
-            return self._batch_hybrid_prediction(input_ids, X, y)
+            return self._batch_hybrid_prediction(input_ids, X, y, embedded=embedded)
 
         probs = self.model_memory_gate(input_ids, X)
 
@@ -14599,8 +14636,11 @@ class PipelinePredictionManager:
             # Only recalibrate if models disagreed AND we have valid results
             if results and not results[0].get('models_agree', True):
                 print("\n[⚠️] Disagreement detected between MLP and Transformer predictions. Using calibrated probabilities for final decision.")
-                calibrated_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size)
-                
+                try:
+                    calibrated_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size, embedded=True)
+                except:
+                    calibrated_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size, embedded=False)
+
                 if calibrated_probs is not None and len(calibrated_probs) > 0:
                     final_idx = int(np.argmax(calibrated_probs[:num_classes]))
                     if final_idx > len(reverse_map):
@@ -14909,6 +14949,7 @@ class PipelinePredictionManager:
                 print("\n[⚡] Running MLP-only predictions")
                 print("[⚡] Note: Transformer not available, so Transformer results will be replaced with MLP results.")
                 anisotropy = self.pipeline.anisotropy_measurement(X) if X is not None else self.pipeline.confidence_threshold
+                
                 AME = self.pipeline.model2.AME_Encoder(X) if X is not None else self.pipeline.confidence_threshold
 
             if X is None or len(X) == 0 or isinstance(X, int) or (isinstance(X, np.ndarray) and X.size == 0):
@@ -14975,7 +15016,11 @@ class PipelinePredictionManager:
                     print(f'[!] Similarity: {cached['similarity']} is low, Cannot pick label due to low certainty, Initiating advanced prediction...')
             else:
                 print('[=] No verified output from cache available that matched samples, starting advanced prediction...')
-                target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
+                try:
+                    target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
+                except:
+                    target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=False)
+                    
                 target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
                 target_probs = self.pipeline.model3.continuos_predictive_correction(self, target_probs, mlp_pred_indices)  
             
@@ -15265,7 +15310,10 @@ class PipelinePredictionManager:
                 elif not results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold:
                     if final_confidence is not None and confidence < self.pipeline.confidence_threshold:
                         print("\n[⚠️] Low confidence detected, but both models don't agree. Using calibrated probabilities for final decision to ensure robustness.")
-                        final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset)
+                        try:
+                            final_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size, embedded=True)
+                        except:
+                            final_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size, embedded=False)
 
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx
@@ -15276,7 +15324,10 @@ class PipelinePredictionManager:
                         final_idx = int(final_idx)  
                     else:
                         print('[🎯] Stable confidence established, But both Models doesnt Agree, Re-evaluating...')   
-                        final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset)
+                        try:
+                            final_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size, embedded=True)
+                        except:
+                            final_probs = self.pipeline.hybrid_prediction(input_ids, X, batch_size=batch_size, embedded=False)
 
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx
@@ -15294,7 +15345,10 @@ class PipelinePredictionManager:
                     if self.pipeline.use_transformer and need_ensemble_method:
                         print("\n[⚠️] Uncertain confidence and disagreement detected. Using ensemble method for final decision.")
                         input_forward = sequence_ids if sequence_ids is not None else input_ids
-                        final_probs, details = self.pipeline.ensemble.predict_ensemble(input_forward, X, y, method='dynamic', embedded=True)
+                        try:
+                            final_probs, details = self.pipeline.ensemble.predict_ensemble(input_forward, X, y, method='dynamic', embedded=True)
+                        except:
+                            final_probs, details = self.pipeline.ensemble.predict_ensemble(input_forward, X, y, method='dynamic', embedded=False)
 
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx 
@@ -15310,7 +15364,10 @@ class PipelinePredictionManager:
                         except:
                             confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
                     else:
-                        final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
+                        try:
+                            final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
+                        except:
+                            final_probs = target_probs
                         final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
                         
                         original_idx = final_idx