AbstractIntegratedModule 0.9.8__tar.gz → 0.9.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.8
+Version: 0.9.9
 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: 0.9.9 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-0.9.9}/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,6 +1928,10 @@ 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)
@@ -2195,15 +2201,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 +2978,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 +3852,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 +4563,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 +4631,6 @@ class ModelStorage:
             conn.close()
 
 
-
     def setup_storage_table(self):
         try:
             try:
@@ -4663,6 +4681,7 @@ class ModelStorage:
             conn.commit()
             conn.close()
 
+
     def get_database_path(self):
         db_filename= self.db_path
         if getattr(sys, 'frozen', False):
@@ -4678,6 +4697,7 @@ class ModelStorage:
     
         return db_path
 
+
     def setup_explainable_table(self):
         try:
             try:
@@ -4856,6 +4876,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 +5025,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 +5392,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 +5840,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 +5985,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 +8980,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 +9005,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 +9153,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 +9162,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 +11034,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 +12771,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 +12843,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 +12933,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 +12963,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 +15531,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
@@ -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)
@@ -16730,6 +16906,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 +17104,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