AbstractIntegratedModule 0.9.9__tar.gz → 1.0.0__tar.gz

{abstractintegratedmodule-0.9.9 → abstractintegratedmodule-1.0.0}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.9
+Version: 1.0.0
 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.9 Official Release.
+- Development Stage: 1.0.0 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.9 → abstractintegratedmodule-1.0.0}/AbstractIntegratedModule.py

@@ -1937,6 +1937,10 @@ class MLP:
             n_classes = len(label_map)
 
             self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
+            if len(self.pred_counts) != n_classes:
+                self.pred_counts = np.zeros(n_classes, dtype=np.float64)
+                self.pred_counts[predicted_index] += 1.0
+                self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
 
             for c in range(n_classes):
                 if len(self.pred_counts) < c:
@@ -1947,19 +1951,12 @@ class MLP:
                         # error_rate=0.5 → multiplier≈0.67
                         # error_rate=1.0 → multiplier≈0.5
                         reputation    = 1.0 / (1.0 + error_rate)
-                        if c < len(prob):
-                            prob[c]  *= reputation  
-                else:
-                    self.pred_counts = np.zeros(n_classes, dtype=np.float64)
-                    self.pred_counts[predicted_index] += 1.0
-                    self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
+                        if isinstance(error_rate, (list, np.ndarray)):
+                            if len(error_rate) != len(prob):
+                                reputation = 1.0 / (1.0 + np.mean(error_rate))
 
-                    if isinstance(self.pred_counts[c], (int, float)) and self.pred_counts[c] > 0:
-                        error_rate    = self.error_counts[c] / (self.pred_counts[c] + 1e-8)
-                    
-                        reputation    = 1.0 / (1.0 + error_rate)
                         if c < len(prob):
-                            prob[c]  *= reputation
+                            prob[c]  *= reputation  
                     
             prob_sum = prob.sum()
             if prob_sum > 1e-8:
@@ -5987,7 +5984,7 @@ class ModelStorage:
 
                 elif type == 'Accurate-Cache':
                     c = conn.cursor()
-                    
+
                     c.execute("""
                     SELECT 1 FROM accurate_cache_storage
                     WHERE memory_name = ? and is_active = 1
@@ -15568,6 +15565,9 @@ class PipelinePredictionManager:
             if self.pipeline.cache and 'label_bins' in self.pipeline.cache:
                 print('[=] label_bins cache found!')
                 label_bins = self.pipeline.cache['label_bins']
+                if X_gen is None:
+                    X_gen = X
+
                 lstm_probs, _ = self.pipeline.ensemble._get_lstm_probs(input_ids, X_gen, label_bins=label_bins)      
             else:
                 lstm_probs = None
@@ -16173,21 +16173,38 @@ class PipelinePredictionManager:
         is_valid_index = 0 <= mlp_class_idx < num_classes
 
         if not is_valid_index:
-            return {
-                'predicted'  : None,
-                'confidence' : 0.0,
-                'mlp_class'  : None,
-                'is_valid'   : False,
-                'error'      : f'class_index_out_of_range(idx={mlp_class_idx}, num_classes={num_classes})'
-            }
-
-        mlp_confidence = float(mlp_probs[i][mlp_class_idx])
+            try:
+                mlp_class_idx = int(np.argmax(mlp_probs[:len(reverse_map)-1]))
+                mlp_confidence = float(mlp_probs[:len(reverse_map)-1][mlp_class_idx]) 
+                mlp_label      = reverse_map.get(mlp_class_idx, f"unknown_{mlp_class_idx}")
+                return {
+                    'predicted'  : mlp_label,
+                    'confidence' : mlp_confidence,
+                    'mlp_class'  : mlp_class_idx,
+                    'index'      : mlp_class_idx,
+                    'models_agree': models_agree,
+                    'final_probs' : mlp_probs[:len(reverse_map)-1],
+                    'is_valid'   : True,
+                }
+            except:
+                return {
+                    'predicted'  : None,
+                    'confidence' : 0.0,
+                    'mlp_class'  : 0,
+                    'index'      : 0,
+                    'models_agree': False,
+                    'final_probs' : mlp_probs,
+                    'is_valid'   : False,
+                    'error'      : f'class_index_out_of_range(idx={mlp_class_idx}, num_classes={num_classes})'
+                }               
+
+        mlp_confidence = float(mlp_probs[i][mlp_class_idx]) 
         mlp_label      = reverse_map.get(mlp_class_idx, f"unknown_{mlp_class_idx}")
 
         # ── LSTM ────────────────────────────────────────────
         # lstm_pred_indices passed in precomputed, not recomputed per-sample
         if lstm_probs is not None and lstm_pred_indices is not None:
-            lstm_class_idx  = int(lstm_pred_indices[i])
+            lstm_class_idx  = int(lstm_pred_indices[i]) 
             lstm_confidence = float(lstm_probs[i][lstm_class_idx])
         else:
             # explicit default so lstm_class_idx is always defined, even if LSTM is not used
@@ -16304,7 +16321,7 @@ class PipelinePredictionManager:
         return {
             'is_valid'          : True,
             'predicted'         : reverse_map.get(final_class_idx, f"unknown_{final_class_idx}"),
-            'predicted_idx'     : final_class_idx,
+            'index'             : final_class_idx,
             'confidence'        : float(final_confidence),
             'mlp_class'         : mlp_class_idx,
             'mlp_prediction'    : mlp_label,
@@ -16797,9 +16814,37 @@ class PipelinePredictionManager:
             verbose = False
             if float(results[0]['confidence']) < self.pipeline.confidence_threshold:
                 verbose = True
-            
-            chosen_label = results[0]['predicted'] if results else None
-            confidence = results[0]['confidence'] if results else None
+
+            chosen_label = results[0].get('predicted') if results else None
+            confidence = results[0].get('confidence') if results else 0.0
+            if chosen_label is None:
+                for i in range(num_classes):
+                    mlp_class_idx = int(mlp_pred_indices[i])
+                    is_valid_index = 0 <= mlp_class_idx < num_classes
+
+                    if mlp_class_idx > len(reverse_map) or not is_valid_index:
+                        mlp_class_idx = int(np.argmax(mlp_probs[:len(reverse_map)-1]))
+                        print(f"[⚠️] Clamping index {mlp_class_idx} → {mlp_class_idx}")  
+
+                    if is_valid_index:
+                        mlp_confidence = float(mlp_probs[i][mlp_class_idx]) 
+                    else:
+                        mlp_confidence = float(mlp_probs[:len(reverse_map)-1][mlp_class_idx]) 
+                        
+                    mlp_label      = reverse_map.get(mlp_class_idx, f"unknown_{mlp_class_idx}")
+                    results.append({
+                        'predicted'  : mlp_label,
+                        'confidence' : mlp_confidence,
+                        'mlp_class'  : mlp_class_idx,
+                        'index'      : mlp_class_idx,
+                        'models_agree': False,
+                        'final_probs' : mlp_probs,
+                        'is_valid'   : True,
+                    })
+                
+                chosen_label = results[0].get('predicted') if results else None
+                confidence = results[0].get('confidence') if results else None
+
             if isinstance(chosen_label, int) or isinstance(chosen_label, np.integer):
                 chosen_label = str(chosen_label)
                 
@@ -16830,6 +16875,9 @@ class PipelinePredictionManager:
                     final_idx = int(final_idx)  
 
                     chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+                    if chosen_label.startswith('unknown'):
+                        final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+
                     try:
                         print(final_probs)
                         confidence = float(final_probs[final_idx])   
@@ -17115,6 +17163,11 @@ class PipelinePredictionManager:
 
             self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
 
+            if len(self.pred_counts) != n_classes:
+                self.pred_counts = np.zeros(n_classes, dtype=np.float64)
+                self.pred_counts[predicted_index] += 1.0
+                self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
+
             for c in range(n_classes):
                 if len(self.pred_counts) < c:
                     if isinstance(self.pred_counts[c], (int, float)) and self.pred_counts[c] > 0:
@@ -17124,24 +17177,13 @@ class PipelinePredictionManager:
                         # error_rate=0.5 → multiplier≈0.67
                         # error_rate=1.0 → multiplier≈0.5
                         reputation    = 1.0 / (1.0 + error_rate)
-                        if c < len(final_probs):
-                            final_probs[c]  *= reputation  
-                else:
-                    self.pred_counts = np.zeros(n_classes, dtype=np.float64)
-                    self.pred_counts[predicted_index] += 1.0
-                    self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
+                        if isinstance(error_rate, (list, np.ndarray)):
+                            if len(error_rate) != len(final_probs):
+                                reputation = 1.0 / (1.0 + np.mean(error_rate))
 
-                    if isinstance(self.pred_counts[c], (int, float)) and self.pred_counts[c] > 0:
-                        error_rate    = self.error_counts[c] / (self.pred_counts[c] + 1e-8)
-                        # sigmoid-shaped dampening — never goes negative
-                        # error_rate=0.0 → multiplier=1.0 (no change)
-                        # error_rate=0.5 → multiplier≈0.67
-                        # error_rate=1.0 → multiplier≈0.5
-                        reputation    = 1.0 / (1.0 + error_rate)
                         if c < len(final_probs):
-                            final_probs[c]  *= reputation
-
-                    
+                            final_probs[c]  *= reputation  
+         
             prob_sum = final_probs.sum()
             if prob_sum > 1e-8:
                 final_probs /= prob_sum
@@ -17166,6 +17208,7 @@ class PipelinePredictionManager:
 
         correct = 0
         sec_correct = 0
+        error = 0
         total_with_expected = 0
         X_samples, input_ids = payload['X_samples'], payload['input_ids']   
 
@@ -17189,8 +17232,9 @@ class PipelinePredictionManager:
 
                         sec_correct += 1
                     else:
-                        if isinstance(self.error_counts[predicted_index], (int, float)):
-                            self.error_counts[predicted_index] += 1.0
+                        error += 1
+                        if isinstance(self.error_counts[result.get('index')], (int, float)):
+                            self.error_counts[result.get('index')] += 1.0
 
                 if result['predicted'] == result['expected']:
                     if result['sec_index'] is None:
@@ -17203,10 +17247,10 @@ class PipelinePredictionManager:
 
                     correct += 1
                 else:
-                    if isinstance(self.error_counts[predicted_index], (int, float)):
-                        self.error_counts[predicted_index] += 1.0
+                    error += 1
+                    if isinstance(self.error_counts[result.get('index')], (int, float)):
+                        self.error_counts[result.get('index')] += 1.0
     
-            
             # Agreement indicator
             agree_symbol = "✓" if result.get('models_agree', True) else "⚠️"
             print(f"[=] {agree_symbol} FINAL: {result['predicted']} ({result['confidence']:.1%})")