AbstractIntegratedModule 0.4.1__tar.gz → 0.4.3__tar.gz

{abstractintegratedmodule-0.4.1 → abstractintegratedmodule-0.4.3/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.4.1
+Version: 0.4.3
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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: Beta, 0.4.1.
+- Development Stage: Beta, 0.4.3.
 - 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.
@@ -63,10 +63,11 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - P2P Works efficiently in ARM64 Docker + QEMU, No conflicting socket and all prediction works efficiently.
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
    - LSTM is Optimized efficiently for scarce data with AWE method.
+   - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />
-[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
+
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.4.1 → abstractintegratedmodule-0.4.3}/AbstractIntegratedModule.py

@@ -2151,7 +2151,7 @@ class LSTMEngine:
 class WeightedEnsemblePredictor:
     def __init__(self, pipeline, distribution, memory_name):
         self.pipeline = pipeline
-        self.storage = ModelStorage(memory_name, db_path='activity_log.db')
+        self.storage = ModelStorage(pipeline, memory_name, db_path='activity_log.db')
         self.inference = distribution
         self.query_node = QueryNode(pipeline, memory_name, self.storage)
 
@@ -3593,13 +3593,15 @@ class ExplainabilityModule:
 
 # Model storage module that handles saving and loading of trained models, their versions, and associated metadata to a database for persistence and future retrieval.
 class ModelStorage:
-    def __init__(self, memory_name, db_path='activity_log.db'):
+    def __init__(self, pipeline, memory_name, db_path='activity_log.db'):
+        self.pipeline = pipeline
         self.db_path = db_path
 
         self.setup_storage_table()
         self.setup_explainable_table()
         self.setup_agent_table()
         self.setup_node_table()
+        self.setup_weight_table()
 
         self.memory_name = memory_name
 
@@ -3868,6 +3870,51 @@ class ModelStorage:
             conn.close()
 
 
+    def setup_weight_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 weight_storage
+                     (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      memory_name TEXT,
+                      model_type TEXT,
+                      weights TEXT,
+                      is_active INTEGER DEFAULT 0,
+                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''') 
+        
+            conn.commit()
+            conn.close()
+            print('|| Update Agent Saved 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 agent_attn_storage
+                     (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      memory_name TEXT,
+                      model_type TEXT,
+                      model_attn_data TEXT,
+                      model_target_pred TEXT,
+                      agent_id TEXT,
+                      is_active INTEGER DEFAULT 0,
+                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''')
+        
+        
+            conn.commit()
+            conn.close()
+
     def save_model_dict(self, memory_name, model_dict, type=None, model_type='mlp'):
         try:
             db_path = self.get_database_path()            
@@ -4059,24 +4106,24 @@ class ModelStorage:
         
         # Verify result is a dictionary before calling .items()
         if verbose and result is not None:
-            print(f"Retrieved memory: {name}")
+            print(f"[=] Retrieved memory: {name}")
             
             # ✅ SAFE: Check if result is a dict before iterating
             if isinstance(result, dict):
                 for key, value in result.items():
                     self._print_memory_value(key, value)
             else:
-                print(f"  Result is not a dict: {type(result)}")
-                print(f"  Result length: {len(result) if hasattr(result, '__len__') else 'N/A'}")
+                print(f"[!] Result is not a dict: {type(result)}")
+                print(f"[!] Result length: {len(result) if hasattr(result, '__len__') else 'N/A'}")
         
         # Handle TwoPass verbose output
         if verbose and data2 is not None and result2 is not None:
-            print(f"Retrieved secondary memory: {name}_secondary")
+            print(f"[=] Retrieved secondary memory: {name}_secondary")
             if isinstance(result2, dict):
                 for key, value in result2.items():
                     self._print_memory_value(key, value)
             else:
-                print(f"  Secondary result is not a dict: {type(result2)}")
+                print(f"[!] Secondary result is not a dict: {type(result2)}")
         
         # ✅ ALWAYS return consistent types
         if data2 is not None:
@@ -4106,6 +4153,7 @@ class ModelStorage:
         else:
             print(f"  {key}: {type(value)}")
 
+
     def memory_retrieval(self, memory_name=None, type_func=None, verbose=False):  
         name = memory_name
 
@@ -4130,6 +4178,44 @@ class ModelStorage:
 
         return result
 
+
+    def _load_weights(self, memory_name, type=None):
+        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 weight_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 Weight dict: {e}')
+        return None
+
+
+    def weight_retrieval(self, memory_name=None, type=None, verbose=False):  
+        name = memory_name
+
+        data = self._load_weights(memory_name, type=type)
+        if data is None:
+            print(f"[-] No Saved Weight found: {name}")
+            return None
+
+        result = self._convertables_utility(name, data, None, type_func='firstpass', verbose=verbose)
+
+        return result       
+
     def _load_node_dict(self, memory_name):
         try:
             try:
@@ -4185,8 +4271,81 @@ class ModelStorage:
 
         except Exception as e:
             print(f'[-] Cant save Node memory due to: {e}')
-            pass        
+            pass  
+
+
+    def save_weights(self, memory_name, model_type=None):
+        """Save weights to database."""
+        try:
+            db_path = self.get_database_path()
+            conn = sqlite3.connect(db_path)
+        except:
+            conn = sqlite3.connect(self.db_path)
+
+        c = conn.cursor()
+
+        weights = {
+            'lstm_W'  : self.pipeline.network_model.cell.W.tolist(),
+            'lstm_b'  : self.pipeline.network_model.cell.b.tolist(),
+            'Wy' : self.pipeline.network_model.Wy.tolist() if self.pipeline.network_model.Wy is not None else None,
+            'by' : self.pipeline.network_model.by.tolist(),
+            'residual_mean': self.pipeline.lstm_engine.residual_mean,
+            'residual_std' : self.pipeline.lstm_engine.residual_std,
+            'quantiles'    : {str(k): list(v) 
+                            for k, v in self.pipeline.lstm_engine.quantiles.items()} 
+                            if self.pipeline.lstm_engine.quantiles else {},
+            'n_samples'    : self.pipeline.lstm_engine.n_samples,
+            'saved_at'     : datetime.now().isoformat(),
+        }
+        
+        weight_json = json.dumps(weights, default=str)
+        try:
+            c.execute("""
+                INSERT INTO weight_storage 
+                (memory_name, model_type, weights, is_active)
+                VALUES (?, ?, ?, ?)
+            """, (memory_name, model_type, weight_json, 1))
+        
+            c.execute("""
+                UPDATE weight_storage 
+                SET is_active = 0 
+                WHERE memory_name = ? AND id != last_insert_rowid()
+            """, (memory_name,)) 
+
+            conn.commit()
+            conn.close()
+
+            print('[||] Weights dictionary saved!')
 
+        except Exception as e:
+            print(f'[-] Cant save Weights due to: {e}')
+            pass          
+       
+    def load_weights(self, memory_name):
+        """Load weights from database. Returns True if found."""
+        result = self.weight_retrieval(memory_name)
+    
+        if not result:
+            print(f'[=] No saved weights for {memory_name}')
+            return False
+
+        try:
+            weights = result
+            self.pipeline.network_model.cell.W  = np.array(weights['lstm_W'])
+            self.pipeline.network_model.cell.b  = np.array(weights['lstm_b'])
+            self.pipeline.network_model.Wy      = np.array(weights['Wy']) if weights['Wy'] else None
+            self.pipeline.network_model.by      = np.array(weights['by'])
+            self.pipeline.lstm_engine.residual_mean = weights.get('residual_mean', 0.0)
+            self.pipeline.lstm_engine.residual_std  = weights.get('residual_std',  1.0)
+            self.pipeline.lstm_engine.n_samples     = weights.get('n_samples', self.pipeline.lstm_engine.n_samples)
+            self.pipeline.lstm_engine.quantiles     = {float(k): tuple(v) 
+                                for k, v in weights.get('quantiles', {}).items()}
+        
+            print(f'[=] All Weights loaded for {memory_name} '
+                f'(saved at {weights.get("saved_at", "unknown")})')
+        except Exception as e:
+            print(f'[!] Cant load any Weights due to: {e}')
+            traceback.print_exc()
 
 
     def load_transformer_dict(self, memory_name):
@@ -6271,7 +6430,7 @@ class AgentDistributedInference:
                     probs = self.handle_peer_uncertainty(probs, target_preds, self_attn_weights, attn_weights, input_ids)
                 else:
                     try:
-                        probs = self.process_peer_request(target_preds, self_attn_weights, attn_weights)
+                        probs = self.process_peer_request(probs, target_preds, self_attn_weights, input_ids)
     
                     except Exception as e:
                        print(f"[-] Error processing request: {e}, returning regular probs")
@@ -6403,7 +6562,7 @@ class AgentDistributedInference:
 
     def process_peer_request(self, probs, target_preds, attn_weights, input_ids):
         try:
-            response_probs = self.pipeline.pipeline._calibrate_probs(probs, target_preds, attn_weights, input_ids)
+            response_probs = self.pipeline._calibrate_probs(probs, target_preds, attn_weights, input_ids)
             return response_probs
         except Exception as e:
             print(f"[-] Error in peer request_processing: {e}")
@@ -7087,19 +7246,19 @@ class IntegratedPipeline:
         # Main component setup
         self.standard_scaler = StandardScaler()
         self.tfidf = TfidfVectorizer(max_features=70)
-        self.storage = ModelStorage(memory_name, db_path='activity_log.db')
-        self.distribution = AgentDistributedInference(self, self.storage, memory_name, port=self.port, use_async=use_async, secret_key=self.secret_key, ssl_cert_file=ssl_cert_file, ssl_key_file=ssl_key_file, shared_auth_token=self.shared_auth_token, predict_manager=self.manager)        
-        self.ensemble = WeightedEnsemblePredictor(self, self.distribution, memory_name)        
-        self.session_automation = CrossSessionAutomation(self)
-        self.batcher = AutoBatcherAutomation(self)
-        self.query_node = QueryNode(self, memory_name, self.storage)
-
         # LSTM __init__ setup
         self.network_model = LSTMNetwork(self, input_size=self.input_size, hidden_size=self.hidden, output_size=self.output_size)
         self.scrapper_model = LSTMEngine(self, self.network_model, dropout=self.dropout_rate, n_samples=50)        
         self.lstm_engine = None
         self.lstm_n_samples = 0
 
+        self.storage = ModelStorage(self, memory_name, db_path='activity_log.db')
+        self.distribution = AgentDistributedInference(self, self.storage, memory_name, port=self.port, use_async=use_async, secret_key=self.secret_key, ssl_cert_file=ssl_cert_file, ssl_key_file=ssl_key_file, shared_auth_token=self.shared_auth_token, predict_manager=self.manager)        
+        self.ensemble = WeightedEnsemblePredictor(self, self.distribution, memory_name)        
+        self.session_automation = CrossSessionAutomation(self)
+        self.batcher = AutoBatcherAutomation(self)
+        self.query_node = QueryNode(self, memory_name, self.storage)
+
         self._agent_mode = os.environ.get('AGENT_MODE', 'single')
         self._agent_port = int(os.environ.get('AGENT_PORT', 5555))
         self._use_async = os.environ.get('USE_ASYNC_QUEUE', 'true').lower() == 'true'
@@ -9296,13 +9455,19 @@ class IntegratedPipeline:
             self.initialize_fitting(X_raw_generation)            
             X = self.shape_adaptation(hybrid_X, input_dim)
                 
-            self.lstm_setup_inference(X, y)   
+            self.lstm_setup_inference(X, y) 
             self.initialize_model_(X, input_dim, n_classes)
             self.model3.train(X, y, epochs=1000, lr=0.1)
 
+            if self.lstm_engine:
+                self.storage.save_weights(self.memory_name, model_type='Pipeline') 
+
             print('🎉 All Model Trained!')
         else:
             print(f'[=] No suitable condition for training!')
+            print('[=] Saving Weights for prediction')
+            self.storage.load_weights(self.memory_name)
+
             pass
 
 
@@ -11905,6 +12070,15 @@ class PipelinePredictionManager:
                 print('[=] label_bins cache found!')
                 label_bins = self.pipeline.cache['label_bins']
                 lstm_probs, _ = self.pipeline.ensemble._get_lstm_probs(input_ids, X, label_bins=label_bins)      
+            else:
+                lstm_probs = None
+
+            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
@@ -11927,15 +12101,16 @@ class PipelinePredictionManager:
                 mlp_confidence = mlp_probs[i][mlp_class_idx]
                 mlp_label = reverse_map.get(mlp_class_idx, f"unknown_{mlp_class_idx}")
 
-                target_confidence = mlp_confidence
-                target_probs = mlp_probs
-                target_pred_indices = mlp_pred_indices
-                target_class_idx = mlp_class_idx
+                if lstm_probs is not None:
+                    lstm_pred_indices = np.argmax(lstm_probs, axis=1)
+                    lstm_class_idx = lstm_pred_indices[i]              
+                    lstm_confidence = lstm_probs[i][lstm_class_idx]
+                else:
+                    lstm_confidence = None
+
+                target_class_idx = target_pred_indices[i]
+                target_confidence = target_probs[i][target_class_idx]
             
-                if float(mlp_confidence) < self.pipeline.confidence_threshold:
-                    target_class_idx = target_pred_indices[i]
-                    target_confidence = target_probs[i][target_class_idx]
-                
                 # Transformer prediction and blending
                 if trans_probs is not None:
                     trans_probs_i = trans_probs[i]
@@ -11945,14 +12120,6 @@ class PipelinePredictionManager:
                     else:
                         trans_confidence = trans_probs_i[trans_class_idx]
 
-                    if lstm_probs is not None:
-                        lstm_probs_i = lstm_probs[i]
-                        lstm_class_idx = np.argmax(lstm_probs_i)
-                        if isinstance(lstm_probs_i, float):
-                            lstm_confidence = target_confidence
-                        else:
-                            lstm_confidence = lstm_probs_i[lstm_class_idx]
-
                     trans_label = reverse_map.get(trans_class_idx, f"unknown_{trans_class_idx}")
 
                     calibration = self.pipeline._calibrate_probs(target_probs, target_pred_indices, attn_weights, input_ids)
@@ -12002,7 +12169,10 @@ class PipelinePredictionManager:
                     'index': int(final_class_idx),
                     'mlp_prediction': mlp_label,
                     'mlp_confidence': float(mlp_confidence),
-                    'models_agree': bool(agreement)
+                    'models_agree': bool(agreement),
+                    'sec_predicted': None,
+                    'sec_confidence': 0.0,
+                    'sec_index': None,
                 }
                 
                 if trans_label is not None:
@@ -12062,8 +12232,6 @@ class PipelinePredictionManager:
             if float(results[0]['confidence']) < self.pipeline.confidence_threshold:
                 verbose = True
             
-            self.display_hybrid_results(results, top_k, verbose=verbose)
-    
             chosen_label = results[0]['predicted'] if results else None
             confidence = results[0]['confidence'] if results else None
             if isinstance(chosen_label, int) or isinstance(chosen_label, np.integer):
@@ -12083,6 +12251,41 @@ class PipelinePredictionManager:
                 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_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}")               
+                    final_idx = int(final_idx)  
+
+                    chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+                    try:
+                        print(final_probs)
+                        confidence = float(final_probs[final_idx])   
+                    except:
+                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
+                        
+                elif self.pipeline.autonomous and need_peer_condition and attn_weights is not None:
+                    if agreement is None:
+                        agreement = False
+
+                    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
+
+                    if final_idx > len(reverse_map):
+                        final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                        print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
+                    final_idx = int(final_idx)  
+
+                    chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+                    try:
+                        confidence = float(final_probs[final_idx])   
+                    except:
+                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
+
 
                 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:
@@ -12222,11 +12425,56 @@ class PipelinePredictionManager:
             else:
                 print(f"\n[🎯] Final chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")  
 
+            try:
+                consecutive_probs = self.pipeline.distribution._handle_peer_agent_request(target_probs, attn_weights, input_ids, type='DevicePeer', agreement=agreement)
+                sec_final_idx = consecutive_probs[0].argmax()
+
+                if sec_final_idx > len(reverse_map):
+                    sec_final_idx = int(np.argmax(consecutive_probs[:len(reverse_map)-1]))
+                    print(f"[⚠️] Clamping {sec_final_idx} → {sec_final_idx}")                    
+                sec_final_idx = int(sec_final_idx)
+
+                sec_chosen_label = reverse_map.get(sec_final_idx, f"unknown_{sec_final_idx}")
+                try:
+                    sec_confidence = float(consecutive_probs[0][sec_final_idx])   
+                except:
+                    sec_confidence = float(consecutive_probs[0][len(reverse_map)-1]) if isinstance(consecutive_probs[0], (float, int)) else self.pipeline.confidence_threshold         
+
+                print('========== Second Prediction Initiative ==========')
+                print(f'[⚡] My Second Prediction: {sec_chosen_label}') 
+                print(f'[⚡] Confidence: {sec_confidence:.1%}')  
+
+                results[0]['sec_predicted'] = sec_chosen_label
+                results[0]['sec_confidence'] = sec_confidence
+                results[0]['sec_index'] = sec_final_idx
+
+                if confidence > results[0]['confidence']:
+                    results[0]['predicted'] = chosen_label
+                    results[0]['confidence'] = confidence
+                    results[0]['index'] = final_idx
+            except Exception as e:
+                print(f'[!] Error initiating second prediction in Advaned prediction method: {e} ')
+
+                results[0]['sec_predicted'] = chosen_label
+                results[0]['sec_confidence'] = confidence
+                results[0]['sec_index'] = final_idx
+
+                time.sleep(5)
+
         except Exception as e:
-            print(f"[-] Error in advanced prediction method: {e}")
-            traceback.print_exc()
+            print(f"[= ! =] Error in advanced prediction method: {e}")
             results, chosen_label, confidence = None, None, 0.0
-        
+            time.sleep(5)
+
+        print('[=] Displaying Results....')     
+        correct, sec_correct = self.display_hybrid_results(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
+        if self.pipeline.autonomous and sec_confidence > self.pipeline.confidence_threshold:
+            print(f'[⚡] Autonomous Prediction used second predicted label: {sec_chosen_label}')
+            chosen_label = sec_chosen_label
+
         return results, chosen_label, confidence
         
         
@@ -12236,6 +12484,7 @@ class PipelinePredictionManager:
         print("="*80)
         
         correct = 0
+        sec_correct = 0
         total_with_expected = 0
         
         for idx, result in enumerate(results):
@@ -12243,10 +12492,15 @@ class PipelinePredictionManager:
             
             if result.get('expected'):
                 total_with_expected += 1
-                status = "[✅]" if result['predicted'] == result['expected'] else "❌"
-                print(f"[=] Expected: {result['expected']} {status}")
+                status = ": ✅" if result['predicted'] == result['expected'] else ": ❌"
+                sec_status = ": ✅" if result['sec_predicted'] == result['expected'] else ": ❌"
+                print(f"[=] First Expectation: {result['expected']} || Model Answer: {status}")
+                print(f"[=] Second Expectation: {result['expected']} || Model Answer: {sec_status}")    
+
                 if result['predicted'] == result['expected']:
                     correct += 1
+                if result['sec_predicted'] == result['expected']:
+                    sec_correct += 1
             
             # Agreement indicator
             agree_symbol = "✓" if result.get('models_agree', True) else "⚠️"
@@ -12269,6 +12523,7 @@ class PipelinePredictionManager:
             accuracy = correct / total_with_expected
             print(f"\n📊 Accuracy: {correct}/{total_with_expected} = {accuracy:.1%}")
 
+        return correct, sec_correct
 
 class ConsecutivePeerAgent:
     """

{abstractintegratedmodule-0.4.1/AbstractIntegratedModule.egg-info → abstractintegratedmodule-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.4.1
+Version: 0.4.3
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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: Beta, 0.4.1.
+- Development Stage: Beta, 0.4.3.
 - 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.
@@ -63,10 +63,11 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - P2P Works efficiently in ARM64 Docker + QEMU, No conflicting socket and all prediction works efficiently.
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
    - LSTM is Optimized efficiently for scarce data with AWE method.
+   - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />
-[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
+
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.4.1 → abstractintegratedmodule-0.4.3}/README.md

@@ -10,7 +10,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: Beta, 0.4.1.
+- Development Stage: Beta, 0.4.3.
 - 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.
@@ -31,10 +31,11 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - P2P Works efficiently in ARM64 Docker + QEMU, No conflicting socket and all prediction works efficiently.
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
    - LSTM is Optimized efficiently for scarce data with AWE method.
+   - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />
-[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
+
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.4.1 → abstractintegratedmodule-0.4.3}/setup.py

@@ -8,7 +8,7 @@ class BinaryDistribution(Distribution):
 
 setup(
     name="AbstractIntegratedModule",
-    version="0.4.1",
+    version="0.4.3",
     description="Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",