AbstractIntegratedModule 0.8.5__tar.gz → 0.8.7__tar.gz

{abstractintegratedmodule-0.8.5 → abstractintegratedmodule-0.8.7}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.8.5
+Version: 0.8.7
 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.8.5 Official Release.
+- Development Stage: 0.8.7 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,9 +80,10 @@ 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.8.5:
+     - v0.8.7:
         - [=] New features: 
-        - Added new Optimization module using Cython maths for dynamic weighted ensemble function.
+        - Added new continuos predictive correction for MLP class to reduce inflated confidence despite outputting wrong answer.
+        - Reduced the frequency of penalty based calibration in advanced prediction method to prevent the models from being too conservative.
         - Fixed P2P Vulnerabilities:
            - Empty allowed_ips in PRODUCTION/HARDENED mode now DENIES external IPs instead of allowing all
            - Startup validation warns about dangerous config combinations

{abstractintegratedmodule-0.8.5 → abstractintegratedmodule-0.8.7}/AbstractIntegratedModule.py

@@ -1716,7 +1716,11 @@ class MLP:
         self.layers2 = []
         self.lr = 0.1
         self.feed_layers = []
-    
+
+        self.error_counts = None
+        self.pred_counts = None
+        self.error_decay = None
+
         self.softmax = SoftmaxOutput()
       
 
@@ -1735,7 +1739,7 @@ class MLP:
     def forward(self, x):
         for layer in self.layers:
             x = layer.forward(x)
-            
+   
         return self.softmax.forward(x)
 
 
@@ -1757,7 +1761,40 @@ class MLP:
 
         return calibration
 
+    def continuos_predictive_correction(self, manager, prob, predicted_index):
+        eps = 1e-5
 
+        error_counts = manager.error_counts
+        pred_counts = manager.pred_counts
+        decay = manager.decay
+        label_map = manager.label_map
+
+        self.error_counts = error_counts
+        self.pred_counts = pred_counts
+        self.error_decay = decay
+
+        try:
+            self.pred_counts[predicted_index] += 1.0
+            n_classes = len(label_map)
+
+            for c in range(n_classes):
+                if 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)
+                    prob[c]     *= reputation  
+                    
+            prob_sum = prob.sum()
+            if prob_sum > 1e-8:
+                prob /= prob_sum
+
+        except Exception as e:
+            print(f'[!] Cant check and calibrate probs based on penalty due to: {e}')    
+        
+        return prob 
 
 
     def focused_backward(self, grad, lr, AME, anisotropy):
@@ -2893,7 +2930,7 @@ class WeightedEnsemblePredictor:
         AME = self.pipeline.model2.AME_Encoder(input_ids)
 
         trans_probs, attn_weights = self.pipeline.model2.forward(input_ids, AME=AME, embedded=embedded)
-        mlp_probs = self.pipeline.mlp.forward(X_mlp)
+        mlp_probs = self.pipeline.model3.forward(X_mlp)
         lstm_probs, lstm_weight_hint = self._get_lstm_probs(input_ids, X_mlp, label_bins=label_bins)
 
         established_agreement = self.query_node._establish_node_connection("PredictEnsemble")
@@ -8544,6 +8581,7 @@ class IntegratedPipeline:
         self.temperature = 1.0
         self.transformer_lr = 0.1
         self.max_seq_len = 16
+        self.error_decay = 0.85
 
         self.memory_name = memory_name
 
@@ -13517,41 +13555,51 @@ class PipelineAsyncManager:
             self._save_state()
 
 
-    def advanced_batch_prediction(self, test_titles, label_map, rules, X=None, y=None, api_key=None, client_ip=None):
+    def advanced_batch_prediction(self, test_titles, label_map, rules,
+                                X=None, y=None, api_key=None, client_ip=None):
         try:
-            attn_weights = None
-            final_idx = None
+            attn_weights     = None
+            final_idx        = None
             attn_weight_rate = None
-            final_idx = None
+            confidence       = None    
+            chosen_label     = None
 
             reverse_label_map = {v: k for k, v in label_map.items()}
+            n_classes         = len(label_map)
 
             if 'attn_weights' in self.pipeline.model2.cache:
                 attn_weights = self.pipeline.model2.cache['attn_weights']
             if attn_weights is not None:
                 attn_weight_growth = 1.0 / (1.0 + np.exp(-attn_weights[0]))
-                attn_weight_rate = np.std(attn_weight_growth)
+                attn_weight_rate   = float(np.std(attn_weight_growth))
 
-            # Batch predictions
-            texts = [text[0] for text in test_titles]
-            expected_labels = [text[1] for text in test_titles]  # Your ground truth
+            texts           = [text[0] for text in test_titles]
+            expected_labels = [text[1] for text in test_titles]
             predicted_output = []
 
-            text = {"test_titles": test_titles, "label_map": label_map, "rules": rules, "X":X, "y":y, "use_transformer": True}
+            text_payload = {
+                "test_titles"    : test_titles,
+                "label_map"      : label_map,
+                "rules"          : rules,
+                "X"              : X,
+                "y"              : y,
+                "use_transformer": True
+            }
 
             if not self.pipeline.intents:
-                result = self.predict(
-                text, 
-                timeout=self.pipeline.timeout,
-                retries=None,
-                api_key=api_key,
-                client_ip=client_ip,
-                ) # regular predict to populate pipelines data
+                result     = self.predict(
+                    text_payload,
+                    timeout=self.pipeline.timeout,
+                    retries=None,
+                    api_key=api_key,
+                    client_ip=client_ip,
+                )
+                confidence = None   # no confidence from this path
             else:
                 result, chosen_label, confidence = self.advanced_prediction_method(
-                    self.prediction_manager, test_titles, label_map, rules, 
-                    X=X, y=y, method='Transformer_included')
-
+                    self.prediction_manager, test_titles, label_map, rules,
+                    X=X, y=y, method='Transformer_included'
+                )
                 try:
                     if isinstance(result, list) and len(result) > 0:
                         final_idx = result[0].get('index')
@@ -13560,62 +13608,107 @@ class PipelineAsyncManager:
                 except (KeyError, IndexError):
                     final_idx = None
 
-            print(f'[=+=] Local single advanced Prediction result: {result}')
+            print(f'[=+=] Local single advanced prediction: {result}')
+            print('[=] Initiating batch prediction...')
 
-            print('[=] Initiating Batch prediction for multiple texts...')
             results = self.predict_batch(
                 texts=texts,
                 timeout=self.pipeline.timeout,
-                api_key=api_key)
+                api_key=api_key
+            )
+
+            # class reputation track: how many times each class
+            # was predicted wrong vs total predictions so far
+            # error_rate[c] ∈ [0,1] — higher = this class is unreliable recently
+            error_counts = np.zeros(n_classes, dtype=np.float64)
+            pred_counts  = np.zeros(n_classes, dtype=np.float64)
+            decay        = self.pipeline.error_decay   # how fast old errors fade — tunable
 
             print("========📊 PREDICTION RESULTS============")
-           
-            for text, expected, probs in zip(texts, expected_labels, results):
-                calibrated_probs = probs.copy()
-                if confidence is not None and attn_weight_rate is not None and final_idx:
-                    if final_idx <= len(probs):
-                        try:
-                            calibrated_index = probs[final_idx] + (1.0 - attn_weight_rate) * confidence 
-                            calibrated_probs[final_idx] = calibrated_index
-                        except IndexError:
-                            calibrated_probs = probs + (1.0 - attn_weight_rate) * confidence 
+
+            for idx, (text, expected, probs) in enumerate(
+                zip(texts, expected_labels, results)
+            ):
+                probs = np.asarray(probs, dtype=np.float64).copy()
+
+                # ── calibrate with single-prediction context ──────────────
+                if (confidence is not None and
+                    attn_weight_rate is not None and
+                    final_idx is not None):
+
+                    if 0 <= final_idx < len(probs):
+                        boost = (1.0 - attn_weight_rate) * confidence
+                        probs[final_idx] = min(probs[final_idx] + boost, 0.95)
                     else:
-                        try:
-                            calibrated_probs = probs + (1.0 - attn_weight_rate) * confidence 
-                        except:
-                            calibrated_probs = calibrated_probs.copy()
+                        boost = (1.0 - attn_weight_rate) * confidence
+                        probs = np.clip(probs + boost, 0.0, 0.95)
+
+                # ── apply class reputation penalty ────────────────────────
+                # ounded reputation-based penalty
+                # classes with high recent error rate get their probs dampened
+                for c in range(n_classes):
+                    if pred_counts[c] > 0:
+                        error_rate    = error_counts[c] / (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)
+                        probs[c]     *= reputation
+
+                # renormalize after reputation dampening
+                prob_sum = probs.sum()
+                if prob_sum > 1e-8:
+                    probs /= prob_sum
+
+                predicted_index = int(np.argmax(probs))
+                predicted_label = reverse_label_map.get(
+                    predicted_index, f"class_{predicted_index}"
+                )
+                pred_conf = float(probs[predicted_index])
+
+                top_3_indices = np.argsort(probs)[-3:][::-1]
+                top_3 = [
+                    (reverse_label_map.get(int(i), f"class_{i}"), float(probs[i]))
+                    for i in top_3_indices
+                ]
 
-                predicted_index = np.argmax(calibrated_probs)  # Get index with highest probability
-                predicted_label = reverse_label_map.get(predicted_index, f"class_{predicted_index}")
-                confidence = calibrated_probs[predicted_index]
-                
-                # Get top 3 predictions for more insight
-                top_3_indices = np.argsort(calibrated_probs)[-3:][::-1]
-                top_3 = [(reverse_label_map.get(idx, f"class_{idx}"), calibrated_probs[idx]) for idx in top_3_indices]
-                
                 print(f"\n📌 Input: '{text}'")
                 print(f"   [=] Expected: {expected}")
-                print(f"   🎯 Predicted: {predicted_label} ({confidence:.1%})")
-                
-                # Show top 3 possibilities
+                print(f"   🎯 Predicted: {predicted_label} ({pred_conf:.1%})")
                 print(f"   🔍 Top possibilities:")
                 for label, conf in top_3:
                     bar = '█' * int(conf * 20)
                     print(f"[•]   {label:<25} {bar} {conf:.1%}")
-                
-                # Match expected vs predicted
+
                 print('===== COMPARISON MATCHING =====')
-                if predicted_label == expected:
-                    print(f"[✅] CORRECT LABEL!")
+                is_correct = predicted_label == expected
+
+                # update class reputation — decay old counts first..
+                error_counts *= decay
+                pred_counts  *= decay
+
+                pred_counts[predicted_index] += 1.0
+                if not is_correct:
+                    print(f"[❌] INCORRECT (expected: {expected})")
+                    error_counts[predicted_index] += 1.0
                 else:
-                    print(f"[❌] INCORRECT LABEL (expected: {expected})")
+                    print(f"[✅] CORRECT!")
 
-                predicted_output.append(f'{text} -> {predicted_label} With {confidence:.1%} Confidence')
+                predicted_output.append(
+                    f'{text} -> {predicted_label} With {pred_conf:.1%} Confidence'
+                )
 
-            # Get stats
+            # batch accuracy summary
+            correct = sum(
+                1 for text, exp in zip(texts, expected_labels)
+                for po in [predicted_output]
+                if f'-> {exp}' in po
+            )
+            print(f"\n[=] Batch complete")
             print(f"[=] Stats: {self.get_stats()}")
-            print('[=] Returning predicted output as list.')        
-            return predicted_output 
+            print('[=] Returning predicted output.')
+            return predicted_output
 
         except Exception as e:
             print(f'[=] Error in advanced batch prediction: {e}')
@@ -13891,7 +13984,14 @@ class PipelinePredictionManager:
             self.titles, self.y_raw, self.label_map = self.load_labels_from_csv(label_csv, target_title, label)
         except Exception as e:
             print(f"Error loading labels: {e}")
-            self.titles, self.y_raw, self.label_map = [], [], {}
+            self.titles, self.y_raw, self.label_map = None, None, None
+
+        if self.label_map is not None:   
+            self.error_counts = np.zeros(len(self.label_map), dtype=np.float64)
+            self.pred_counts  = np.zeros(len(self.label_map), dtype=np.float64)
+            self.decay        = self.pipeline.error_decay   # how fast old errors fade — tunable
+        else:
+            raise Warning('[!] Label map is None, consider adding label map!')
 
         print(f"✅ Loaded {len(self.titles)} labeled examples")
 
@@ -13907,8 +14007,6 @@ class PipelinePredictionManager:
         4. User home directory
         5. Common data folders (Downloads, Documents, Desktop)
         """
-        import os
-        import sys
 
         # build candidate paths
         candidates = []
@@ -14638,9 +14736,10 @@ 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)
-            target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
+                target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
+                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)  
+            
             target_pred_indices = np.argmax(target_probs, axis=1)    
 
             if self.pipeline.cache and 'label_bins' in self.pipeline.cache:
@@ -14653,13 +14752,6 @@ class PipelinePredictionManager:
             results = []
             attention_data = [] if return_attention else None
 
-            target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
-            target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
-            target_pred_indices = np.argmax(target_probs, axis=1)          
-
-            results = []
-            attention_data = [] if return_attention else None
-
             for i, title in enumerate(titles):
                 # Parse input
                 if isinstance(title, tuple):
@@ -14726,7 +14818,8 @@ class PipelinePredictionManager:
                         final_probs = mlp_weight * target_probs[i][:len(calibration)] + trans_weight * calibration[i][:len(calibration)] + lstm_weight * calibration[i][:len(calibration)]
                     else:
                         final_probs = mlp_weight * target_probs[i][:len(calibration)] + trans_weight * calibration[i][:len(calibration)]
-
+                        
+                    final_probs = self.calibration_penalized_check(final_probs, target_class_idx)
                     final_class_idx = target_class_idx
                     try:
                         final_confidence = final_probs[final_class_idx]
@@ -14740,6 +14833,8 @@ class PipelinePredictionManager:
                     agreement = mlp_class_idx == trans_class_idx
                 else:
                     final_probs = mlp_probs[i]
+                    final_probs = self.calibration_penalized_check(final_probs, mlp_class_idx)
+
                     final_class_idx = mlp_class_idx
                     final_confidence = mlp_confidence[0] if isinstance(mlp_confidence, np.ndarray) else mlp_confidence
                     if isinstance(final_confidence, np.ndarray) or isinstance(final_confidence, list):
@@ -14843,7 +14938,8 @@ class PipelinePredictionManager:
                 print("\n[⚠️] Disagreement detected between MLP and Transformer predictions. Using calibrated probabilities for final decision.")
                 if not self.pipeline.autonomous and need_peer_condition:
                     print('|| Uncertain advanced prediction, requesting peer assistance if allowed...')
-                    final_probs = self.pipeline._handle_distributed_connections(final_probs, attn_weights, input_ids, agreement)   
+                    final_probs = self.pipeline._handle_distributed_connections(final_probs, attn_weights, input_ids, agreement) 
+
                     final_idx = final_probs[0].argmax()
                     original_idx = final_idx
 
@@ -14865,8 +14961,9 @@ class PipelinePredictionManager:
 
                     print('[||] Iniating local peer output search in database for best output...')
                     final_probs = self.pipeline.distribution._handle_peer_agent_request(final_probs, attn_weights, input_ids, type='DevicePeer', agreement=agreement)
+
                     final_idx = final_probs[0].argmax()
-                    original_idx = final_idx
+                    original_idx = final_idx              
 
                     if final_idx > len(reverse_map):
                         final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
@@ -14884,9 +14981,10 @@ class PipelinePredictionManager:
                     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)
+
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx
-
+                        
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                             print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
@@ -14894,9 +14992,9 @@ class PipelinePredictionManager:
                     else:
                         print('[🎯] Stable confidence established, But both Models doesnt Agree, Re-evaluating...')   
                         final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset)
+
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx
-
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                             print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
@@ -14912,6 +15010,7 @@ class PipelinePredictionManager:
                         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)
+
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx 
 
@@ -14928,7 +15027,7 @@ class PipelinePredictionManager:
                     else:
                         input_forward = sequence_ids if sequence_ids is not None else input_ids
                         final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
-
+                        
                         original_idx = final_idx 
 
                         if final_idx > len(reverse_map):
@@ -15010,7 +15109,8 @@ class PipelinePredictionManager:
                     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 isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
                 if chosen_label.startswith("unknown"):
                     chosen_label = 'Unknown'
@@ -15084,7 +15184,7 @@ class PipelinePredictionManager:
             'X_samples': X,
             'input_ids': input_ids
         }         
-        correct, sec_correct = self.display_hybrid_results(payload, results, top_k, verbose=True)
+        correct, sec_correct = self.display_hybrid_results(payload, final_class_idx, results, top_k, verbose=True)
         if sec_chosen_label and sec_correct > correct:
             print(f'[⚡] Second Prediction: {sec_chosen_label} has higher accuracies, relying on: {sec_chosen_label} as final label.')
             chosen_label = sec_chosen_label # overrides previous chosen label if accuracy is higher
@@ -15097,18 +15197,48 @@ class PipelinePredictionManager:
         self.pipeline.cache.clear()
 
         return results, chosen_label, confidence
+
+
+    def calibration_penalized_check(self, final_probs, predicted_index):
+        # update class reputation.
+        try:
+            decay = self.pipeline.error_decay
+            self.error_counts *= decay
+            self.pred_counts  *= decay
+
+            self.pred_counts[predicted_index] += 1.0
+            n_classes = len(self.label_map)
+
+            for c in range(n_classes):
+                if 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)
+                    final_probs[c]     *= reputation  
+                    
+            prob_sum = final_probs.sum()
+            if prob_sum > 1e-8:
+                final_probs /= prob_sum
+
+        except Exception as e:
+            print(f'[!] Cant check and calibrate probs based on penalty due to: {e}')    
         
+        return final_probs 
+
         
-    def display_hybrid_results(self, payload, results, top_k=3, verbose=False):
+    def display_hybrid_results(self, payload, predicted_index, results, top_k=3, verbose=False):
         print("\n" + "="*80)
         print("[🎯] == PREDICTION RESULTS == ")
         print("="*80)
-        
+
         correct = 0
         sec_correct = 0
         total_with_expected = 0
         X_samples, input_ids = payload['X_samples'], payload['input_ids']   
-
+        
         for idx, result in enumerate(results):
             print(f"\n{idx+1}. 📌 '{result['title']}'")
             
@@ -15116,6 +15246,7 @@ class PipelinePredictionManager:
                 total_with_expected += 1
                 status = ": ✅" if result['predicted'] == result['expected'] else ": ❌"
                 print(f"[=] First Expectation: {result['expected']} || Model Answer: {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}")    
@@ -15126,6 +15257,8 @@ class PipelinePredictionManager:
                             source='automatic_verified')
 
                         sec_correct += 1
+                    else:
+                        self.error_counts[predicted_index] += 1.0
 
                 if result['predicted'] == result['expected']:
                     if result['sec_index'] is None:
@@ -15137,6 +15270,9 @@ class PipelinePredictionManager:
                         source='automatic_verified')      
 
                     correct += 1
+                else:
+                    self.error_counts[predicted_index] += 1.0
+    
             
             # Agreement indicator
             agree_symbol = "✓" if result.get('models_agree', True) else "⚠️"