AbstractIntegratedModule 0.9.8__tar.gz → 1.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.8
+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.8 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.8 → abstractintegratedmodule-1.0.0}/AbstractIntegratedModule.py

@@ -43,6 +43,7 @@ import psutil
 from sklearn.preprocessing import StandardScaler
 import io
 import concurrent.futures
+import struct
 
 from cryptography import x509
 from cryptography.x509.oid import NameOID
@@ -65,6 +66,7 @@ try:
         optimized_dynamic_weighted_ensemble,
         optimized_qkv_weight_grad,
         optimized_qkv_input_grad,
+        optimized_lstm_cell_backward,
     )
     _OPT_AVAILABLE = True
     print('[=] Cython acceleration loaded ✅')
@@ -240,7 +242,7 @@ class Message:
         return not self.__lt__(other)
     
     def __hash__(self):
-        """Make Message hashable (useful for sets/dicts)."""
+        """Message hashable"""
         return hash(self.id)
 
 
@@ -1926,11 +1928,19 @@ class MLP:
         self.pred_counts = pred_counts
         self.error_decay = decay
 
+        if prob is None:
+            print('[!] Probabilities is None! returning the probabilities...')
+            return prob
+
         try:
             self.pred_counts[predicted_index] += 1.0
             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:
@@ -1941,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:
@@ -2195,15 +2198,27 @@ class LSTMCell:
     # ________ backward method for Cell class __________
     def backward(self, dhs: np.ndarray, cache,
                 dh_next=None, dc_next=None, T_limit=None):
-        # T_limit avoids slicing cache list externally
+        # T_limit avoids slicing cache list externally Later.
         T = T_limit if T_limit is not None else len(cache)
         H = self.hidden_size
 
         dW     = np.zeros_like(self.W)
         db     = np.zeros_like(self.b)
-        dh     = np.zeros(H) if dh_next is None else dh_next.copy()
-        dc     = np.zeros(H) if dc_next is None else dc_next.copy()
+        dh     = np.zeros(H) if dh_next is None else np.ascontiguousarray(dh_next.copy())
+        dc     = np.zeros(H) if dc_next is None else np.ascontiguousarray(dc_next.copy())
         dx_seq = np.zeros((T, self.input_size))
+        if _OPT_AVAILABLE:
+            grads, dx_seq, dh, dc = optimized_lstm_cell_backward(
+                np.ascontiguousarray(dhs, dtype=np.float64),
+                cache,
+                np.ascontiguousarray(self.W, dtype=np.float64),
+                self.input_size,
+                self.hidden_size,
+                dh,
+                dc,
+                T
+            )
+            return grads, dx_seq, dh, dc
 
         # preallocate dz buffer once
         dz     = np.empty(4 * H)
@@ -2960,7 +2975,7 @@ class WeightedEnsemblePredictor:
                 target_class = int(np.clip(round(raw_score), 0, n_classes - 1))
                 logits[target_class] = mc_conf_last
 
-                # softmax
+                # softmax here 
                 logits -= logits.max()
                 row = np.exp(logits)
                 row /= row.sum()
@@ -3834,7 +3849,7 @@ class ExplainabilityModule:
         self.pipeline.focused_mlp.train(X, y_onehot, epochs=1000, lr=self.pipeline.mlp.lr, verbose=True)
         time.sleep(5)
 
-        self.pipeline.mlp.lr = old_lr  # Restore LR
+        self.pipeline.mlp.lr = old_lr  # Restore old LR
         
         # 4. train transformer for efficient processing later tho.
         if self.pipeline.model2:
@@ -4545,6 +4560,7 @@ class ModelStorage:
         self.setup_agent_table()
         self.setup_node_table()
         self.setup_weight_table()
+        self.setup_accurate_cache_table()
 
         self.memory_name = memory_name
 
@@ -4612,7 +4628,6 @@ class ModelStorage:
             conn.close()
 
 
-
     def setup_storage_table(self):
         try:
             try:
@@ -4663,6 +4678,7 @@ class ModelStorage:
             conn.commit()
             conn.close()
 
+
     def get_database_path(self):
         db_filename= self.db_path
         if getattr(sys, 'frozen', False):
@@ -4678,6 +4694,7 @@ class ModelStorage:
     
         return db_path
 
+
     def setup_explainable_table(self):
         try:
             try:
@@ -4856,6 +4873,83 @@ class ModelStorage:
             conn.commit()
             conn.close()
 
+
+    def setup_accurate_cache_table(self):
+        try:
+            try:
+                db_path = self.get_database_path()            
+                conn = sqlite3.connect(db_path)
+            except:
+                conn = sqlite3.connect(self.db_path)
+
+            c = conn.cursor()
+    
+            c.execute('''CREATE TABLE IF NOT EXISTS accurate_cache_storage
+                     (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      memory_name TEXT,
+                      cache TEXT,
+                      is_active INTEGER DEFAULT 0,
+                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''') 
+        
+            conn.commit()
+            conn.close()
+            print('|| Update cached to database! ')
+
+        except Exception as e:
+            print(f'|| Cant Update Database: {e}')
+            filepath = input('|| Insert Database filepath: ')
+            if filepath:
+                conn = sqlite3.connect(filepath)
+            else:
+                print('|| Skipping Database Modification...')
+                pass
+            c = conn.cursor()
+            c.execute('''CREATE TABLE IF NOT EXISTS accurate_cache_storage
+                      (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      memory_name TEXT,
+                      cache TEXT,
+                      is_active INTEGER DEFAULT 0,
+                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''') 
+        
+        
+            conn.commit()
+            conn.close() 
+
+    def save_accurate_cache_dict(self, memory_name, payload, model_type='Pipeline'):
+        try:
+            db_path = self.get_database_path()
+            conn = sqlite3.connect(db_path)
+        except:
+            conn = sqlite3.connect(self.db_path)
+
+        c = conn.cursor()
+
+        cache = json.dumps(payload, default=str)
+
+        try:
+            c.execute("""
+                INSERT INTO accurate_cache_storage
+                (memory_name, cache, is_active)
+                VALUES (?, ?, ?)
+            """, (memory_name, cache, 1))
+        
+            c.execute("""
+                UPDATE accurate_cache_storage
+                SET is_active = 0 
+                WHERE memory_name = ? AND id != last_insert_rowid()
+            """, (memory_name,)) 
+
+            conn.commit()
+            conn.close()
+
+            print('|| Accurate cache saved!')
+
+        except Exception as e:
+            print(f'[-] Cant save accurate cache memory due to: {e}') 
+            pass      
+
+   
+
     def save_model_dict(self, memory_name, model_dict, type=None, model_type='mlp'):
         try:
             db_path = self.get_database_path()            
@@ -4928,6 +5022,8 @@ class ModelStorage:
         if isinstance(obj, (list, tuple)):
             return [self._prepare_for_serialization(item) for item in obj]
         return obj
+        
+
 
     def load_model_dict(self, memory_name):
         conn = None
@@ -5293,6 +5389,31 @@ class ModelStorage:
         return result
 
 
+    def load_accurate_cache(self, memory_name):
+        try:
+            try:
+                db_path = self.get_database_path()            
+                conn = sqlite3.connect(db_path)
+            except:
+                conn = sqlite3.connect(self.db_path)
+
+            c = conn.cursor()      
+            
+            c.execute("""
+            SELECT weights FROM accurate_cache_storage 
+            WHERE memory_name = ? AND is_active = 1
+            """, (memory_name,))               
+        
+            result = c.fetchone()
+            conn.close()
+        
+            if result:
+                return json.loads(result[0])
+        except Exception as e:
+            print(f'[!] Error handling cache dict: {e}')
+        return None
+
+
     def _load_weights(self, memory_name, type=None):
         try:
             try:
@@ -5716,6 +5837,7 @@ class ModelStorage:
             print(f'[-] Cant save model memory due to: {e}') 
             pass        
 
+
     def load_peer_request_dict(self, memory_name, agent_id):
         print(f'|| Peer request with Agent')
         try:
@@ -5860,6 +5982,17 @@ class ModelStorage:
                     exists = result is not None
                     print(f"|| Retrieved Peer Memory: {memory_name}")
 
+                elif type == 'Accurate-Cache':
+                    c = conn.cursor()
+
+                    c.execute("""
+                    SELECT 1 FROM accurate_cache_storage
+                    WHERE memory_name = ? and is_active = 1
+                    LIMIT 1""", (memory_name, ))
+
+                    result = c.fetchone()
+                    exists = result is not None
+                    print(f"|| Retrieved Accurate Fact Cache Memory for memory: {memory_name}")
                 else:
                     c = conn.cursor()
 
@@ -8844,7 +8977,7 @@ class AutoBatcherAutomation:
         self.result_events  = {}   # per-request Event 
         self.next_id        = 0
 
-        self._state_lock = threading.Lock()   # FIX 1 — guards processing flag + next_id
+        self._state_lock = threading.Lock()   # guards processing flag + next_id
 
     def add_request(self, text, callback=None):
         with self._state_lock:
@@ -8869,6 +9002,9 @@ class AutoBatcherAutomation:
         if should_start:
             self._start_processing()
 
+        result = self.get_result(request_id)
+        self.cleanup_stale()
+
         return request_id
 
     def _start_processing(self):
@@ -9014,6 +9150,8 @@ class IntegratedPipeline:
         self.shared_auth_token = shared_auth_token
         self.manager = None
 
+        self.memory_name = memory_name
+
         self.client_ssl_context = None
         self.ssl_context = None
 
@@ -9021,11 +9159,13 @@ class IntegratedPipeline:
         self.hidden = 32
         self.output_size = 1
         self.dropout_rate = 0.1
-        self.transformer_training_epochs = 100
         self.max_size = 500
         self.error_decay = 0.85
         self.performance_result = 1.0
 
+        self.mlp_training_epochs = 2000
+        self.transformer_training_epochs = 100
+
         # Main component setup
         self.standard_scaler = StandardScaler()
         self.tfidf = TfidfVectorizer(max_features=70)
@@ -10891,7 +11031,11 @@ class IntegratedPipeline:
   
     def predict_async(self, text, callback=None):
         try:
-            return self.batcher.add_request(text, callback)
+            id_req = self.batcher.add_request(text, callback)
+            result = self.batcher.get_result(id_req, timeout=10)
+            self.batcher.cleanup_stale()
+            return id_req
+
         except Exception as e:
             print(f'[=] error in automatic batcher: {e}')
             return None
@@ -12624,7 +12768,7 @@ class IntegratedPipeline:
                 
             self.lstm_setup_inference(X, y) 
             self.initialize_model_(X, input_dim, n_classes)
-            self.model3.train(X, y, epochs=1000, lr=0.1)
+            self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=0.1)
 
             if self.lstm_engine:
                 self.storage.save_weights(self.memory_name, model_type='Pipeline') 
@@ -12696,11 +12840,17 @@ class IntegratedPipeline:
 class AccurateAnswerCache:
     def __init__(self, pipeline, similarity_threshold=0.85, max_size=500):
         self.pipeline = pipeline
+        self.memory_name = self.pipeline.memory_name
         self.similarity_threshold = similarity_threshold
         self.max_size = max_size
         self.max_threshold = 0.7
 
-        self.cache = {}
+        self.memory_exist = self.pipeline.storage.memory_exists(self.memory_name, type='Accurate-cache')
+        if self.memory_exist:
+            self.cache = self.pipeline.storage.load_accurate_cache(self.memory_name)
+        else:
+            self.cache = {}
+
         self.exact_hash_index = {}   # O(1) exact match lookup
 
     def _flatten_indices(self, input_ids):
@@ -12780,9 +12930,14 @@ class AccurateAnswerCache:
                 self._evict_lru()
 
             print(f'[💎] Verified answer cached: {prediction} (source={source})')
+
+            if self.cache[key]['source'] != 'automatic_verified' and not source.startswith('automatic'):
+                self.pipeline.storage.save_accurate_cache_dict(self.memory_name, self.cache)
+            
         except Exception as e:
             print(f'[!] Failed to add samples and answer to Answer cache due to: {e}')
 
+
     def lookup(self, x_mlp, input_ids=None):
         try:
             confidence_threshold = self.pipeline.confidence_threshold
@@ -12805,7 +12960,21 @@ class AccurateAnswerCache:
                 if ids_hash in self.exact_hash_index:
                     key   = self.exact_hash_index[ids_hash]
                     entry = self.cache.get(key)
-                    if entry:
+                    if isinstance(entry, dict) and entry['source'] != 'automatic_verified' and not entry['source'].startswith('automatic'):
+                          
+                        entry['hit_count'] += 1
+                        entry['last_hit']   = datetime.now().isoformat()
+                        return {
+                            'prediction' : entry['prediction'],
+                            'confidence' : entry['confidence'],
+                            'index'      : entry['index'],
+                            'similarity' : 1.0,
+                            'source'     : entry['source'],
+                            'hit_count'  : entry['hit_count'],
+                            'match_type' : 'exact_ids'
+                        }  
+
+                    if entry is not None and isinstance(entry, dict):
                         entry['hit_count'] += 1
                         entry['last_hit']   = datetime.now().isoformat()
                         return {
@@ -15359,6 +15528,7 @@ class PipelinePredictionManager:
             use_embedded = False
             attn_weights = None
             trans_probs = None
+            mlp_probs = None
 
             print(f"\n[🚀] Regular Prediction Initiated...")
             self.pipeline.titles = titles
@@ -15395,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
@@ -15590,6 +15763,9 @@ class PipelinePredictionManager:
                 n_samples = mlp_probs.shape[0]
 
                 lstm_pred_indices = np.argmax(lstm_probs, axis=1) if lstm_probs is not None else None
+                if mlp_probs is None:
+                    logits = self.pipeline.mlp.forward(X) if X is not None else X_tfidf
+                    mlp_probs = self.pipeline._softmax(logits)
 
                 target_probs = self.calibration_penalized_check(mlp_probs, mlp_pred_indices)
                 target_pred_indices = np.argmax(target_probs, axis=1)
@@ -15997,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
@@ -16128,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,
@@ -16621,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)
                 
@@ -16654,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])   
@@ -16730,6 +16954,9 @@ class PipelinePredictionManager:
                         except:
                             confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
                     else:
+                        if final_probs is None:
+                            final_probs = mlp_probs
+
                         final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
 
                         final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
@@ -16925,6 +17152,10 @@ class PipelinePredictionManager:
         self.error_counts *= decay
         self.pred_counts  *= decay
 
+        if final_probs is None:
+            print('[!] Warning final probabilities is None! returning the probabilities...')
+            return final_probs
+
         try:
 
             self.pred_counts[predicted_index] += 1.0
@@ -16932,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:
@@ -16941,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
@@ -16983,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']   
 
@@ -17006,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:
@@ -17020,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%})")