AbstractIntegratedModule 1.3.1__tar.gz → 1.3.2__tar.gz

{abstractintegratedmodule-1.3.1 → abstractintegratedmodule-1.3.2}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.3.1
-Summary: Integrated Pipeline with Specialized Non-LLM AI Agent Framework for ARM64 architecture
+Version: 1.3.2
+Summary: IntegratedPipeline Specifically provide a Framework to build Stateful continual learning Machine Learning Models optimized for Edge devices (ARM64).
 Author: Micro-Novelty
 Author-email: Micro-Novelty <hernikpuspita5@gmail.com>
 License-Expression: MIT

{abstractintegratedmodule-1.3.1 → abstractintegratedmodule-1.3.2}/AbstractIntegratedModule.py

@@ -2725,11 +2725,20 @@ class Transformer(TargetMemoryMixin):
 
         # Optimized Project heads with Cython implementation.
         if _OPT_AVAILABLE:
-            B, S, D = batch_size, seq_len, d_model
-            M = D // self.n_heads 
-            Q = optimized_project_heads(x, W_q_mix, B, S, self.n_heads, D, M)
-            K = optimized_project_heads(x, W_k_mix, B, S, self.n_heads, D, M)
-            V = optimized_project_heads(x, W_v_mix, B, S, self.n_heads, D, M)
+            try:
+                x_c = np.ascontiguousarray(x, dtype=np.float64)
+                Wq_c = np.ascontiguousarray(W_q_mix, dtype=np.float64)
+                Wk_c = np.ascontiguousarray(W_k_mix, dtype=np.float64)
+                Wv_c = np.ascontiguousarray(W_v_mix, dtype=np.float64)
+
+                B, S, D = batch_size, seq_len, d_model
+                M = D // self.n_heads 
+                Q = optimized_project_heads(x, Wq_c, B, S, self.n_heads, D, M)
+                K = optimized_project_heads(x, Wk_c, B, S, self.n_heads, D, M)
+                V = optimized_project_heads(x, Wv_c, B, S, self.n_heads, D, M)
+            except Exception as e:
+                print(f'[>] Error in optimize project head: {e}')
+                continue
         
         else:
             Q = np.einsum('bsd,hdm->bhsm', x, W_q_mix)
@@ -2880,13 +2889,12 @@ class Transformer(TargetMemoryMixin):
     def forward(self, input_ids, AME=None, _update_quality_matrix=None, embedded=False, pad_token_id=0, training=True, attn_dropout=0.1, ffn_dropout=0.1):
         eps = 1e-3
         self._forward_count += 1
-
             
         # Clean up old cache entries before storing new ones
         self._clear_forward_cache(keep_essential=True, max_age_forward_passes=5) 
 
         if embedded:
-            x = self._handle_indices(input_ids, dtype=np.int64)
+            x = self._handle_indices(input_ids, dtype=np.float64)
             if x.ndim == 2:
                 x = x[np.newaxis, ...]
             batch_size, seq_len, _ = x.shape
@@ -2894,7 +2902,7 @@ class Transformer(TargetMemoryMixin):
             self.cache['input_ids'] = None
             mask = None
         else:
-            input_ids = self._handle_indices(input_ids, dtype=np.int32)
+            input_ids = self._handle_indices(input_ids, dtype=np.float32)
             if input_ids.ndim == 1:
                 input_ids = input_ids[np.newaxis, :]
 
@@ -10384,6 +10392,7 @@ class AgentDistributedInference:
         self._health_check_interval = 30  # seconds
 
         self.use_async = use_async
+        self.agent_id = id(self)
         
         # Register message handlers
         print('[=++=] Initiating message Queue')
@@ -11372,7 +11381,12 @@ class AgentDistributedInference:
         
         if not text and not test_titles:
             print('[INFO] No text or test_titles in message payload.')
-            
+        
+        if test_titles is not None and self.predict_manager is None:
+            raise RuntimeError('[>] predict manager not set; cannot run advanced prediction method')
+        if text is None and test_titles is None:
+            raise ValueError('[>] Payload has neither text or titles.')
+
         # Run the actual prediction
         print(f'[=] Initiating prediction method')
         try:
@@ -11405,8 +11419,10 @@ class AgentDistributedInference:
 
                 else:
                     print('[=] Iniatiting basic prediction...')
-                    result = await asyncio.to_thread(self.pipeline.predict_single, text)
-            
+                    result = await asyncio.to_thread(self.pipeline.predict_text, text)
+                    if not isinstance(result, dict):
+                        raise TypeError(f"[>] Predict single returned {type(result).__name__}: {result!r}")
+
                     return {
                         'type': self.MSG_TYPES['PREDICT_RESPONSE'],
                         'prediction': result.get('prediction'),
@@ -11418,7 +11434,7 @@ class AgentDistributedInference:
             else:
 
                 print('[=] Basic prediction method')
-                result = await asyncio.to_thread(self.pipeline.predict_single, text)
+                result = await asyncio.to_thread(self.pipeline.predict_text, text)
                 
                 return {
                     'type': self.MSG_TYPES['PREDICT_RESPONSE'],
@@ -11799,7 +11815,7 @@ class AgentDistributedInference:
             msg_len = int.from_bytes(data_len, 'big')
             if msg_len > self.max_message_size:
                 print('[=] message size exceeds maximum to be handled')
-                self.log_security_event('message_too_large', {'size': msg_len})
+                self._log_security_event('message_too_large', {'size': msg_len})
                 return None
 
             data = b''
@@ -13736,6 +13752,17 @@ class IntegratedPipeline:
         self.tfidf.fit_transform(text).toarray()
         vocab_size = len(self.tfidf.get_feature_names_out())
         self.vocab_size = vocab_size
+
+    def predict_text(self, text):
+        probs = np.asarray(self.predict_single(text), dtype=np.float64).ravel()
+        idx = int(np.argmax(probs))
+        label_map = getattr(self.manager, 'label_map')
+        reverse = {v: k for k, v in label_map.items()}
+        return {
+            'prediction': reverse.get(idx, f'class_{idx}'),
+            'confidence': float(probs[idx]),
+            'probabilities': probs.tolist(),
+        }
         
 
     def initialize_model_encoding(self, X, y_raw):
@@ -14856,40 +14883,37 @@ class IntegratedPipeline:
             return None
 
     def prediction_batch(self, texts):
-        self.initialize_fitting(texts)
+        """Returns an ndarray of shape (len(texts), num_classes) with probabilities."""
+        # normalise input
+        if texts is None:
+            return np.zeros((0, self._get_num_classes() or 1))
+        if isinstance(texts, (str, np.str_)):
+            texts = [texts]
+        texts = [t[0] if isinstance(t, tuple) else t for t in texts]
+        texts = ['' if t is None else str(t) for t in texts]
         if not texts:
-            return []
-        
-        # Prepare batch inputs
+            return np.zeros((0, self._get_num_classes() or 1))
 
-        input_ids_list = []
-        X_raw_list = []
+        if self.model3 is None:
+            raise RuntimeError('[>] MLP model is not initialized/trained; cannot predict')
 
-        for text in texts:
-            # Prepare transformer input
-            input_ids = np.array([self.encode(text, self.vocab)])
-            input_ids_list.append(input_ids)
-            
-            # Prepare MLP input
-            if not hasattr(self, 'tfidf') or self.tfidf is None:
-                self.initialize_fitting([text])
-            X_raw = self.tfidf.transform([text]).toarray()
-            X_raw_list.append(X_raw)
-        
-        # Stack into batches
-        batch_input_ids = np.vstack(input_ids_list)  # (batch_size, seq_len)
-        batch_X_raw = np.vstack(X_raw_list) # (batch_size, features)
-
-        if self.labels is None and self.titles is None:
-            _, y_true = self.input_encoding(list(zip(texts, texts)))  # No-value labels for y_true
-        else:
-            dataset, _ = self.data_preparation(self.titles, self.labels)
-            y_true = self.input_encoding(dataset)
-        
-        # Run batch prediction through your existing logic
-        return self._batch_prediction_core(batch_input_ids, batch_X_raw, y_true)
+        # MLP features: same hashing vectorizer as training, never refit on request text
+        _, X_raw = self.data_preparation(texts)
+        X_raw = np.asarray(X_raw, dtype=np.float64)
+
+        first = self.model3.layers[0] if self.model3.layers else None
+        input_dim = getattr(first, 'input_size', None)
+        if input_dim and X_raw.shape[1] != input_dim:
+            X_raw = self.shape_adaptation(X_raw, input_dim)
 
+        # transformer token ids 
+        if not self.vocab:
+            self.text_encoder(texts)
+        ids = np.array([self.encode(t, self.vocab) for t in texts], dtype=np.int64)
+        if self.model2 is not None and hasattr(self.model2, 'token_embedding'):
+            ids = np.clip(ids, 0, self.model2.token_embedding.shape[0] - 1)
 
+        return self._batch_prediction_core(ids, X_raw, batch_size=None, show_progress=False)
 
     def _batch_model_memory_gate(self, batch_input_ids, batch_X_raw):
         batch_probs = [None] * len(batch_input_ids)
@@ -15080,10 +15104,8 @@ class IntegratedPipeline:
                 fresh_mlp_confidence = fresh_probs.max(axis=1, keepdims=True)
                 fresh_trans_confidence = fresh_trans_probs.max(axis=1, keepdims=True)
 
-                if fresh_mlp_confidence >= fresh_trans_confidence:
-                    fresh_probs = fresh_probs.copy()
-                else:
-                    fresh_probs = fresh_trans_probs.copy()
+                use_mlp = (fresh_mlp_confidence >= fresh_trans_confidence)
+                fresh_probs = np.where(use_mlp, fresh_probs, fresh_trans_probs)
 
                 if np.std(fresh_probs) < 0.3 or np.mean(fresh_probs) < 0.3:
                     fresh_probs = self.predict_proba(
@@ -15215,18 +15237,20 @@ class IntegratedPipeline:
             return None
     
 
-    def predict_single(self, text):
+    def predict_single(self, text, timeout=250):
         result = [None]
+        done = threading.Event()
         
         def callback(r):
             result[0] = r
+            done.set()
         
         self.predict_async(text, callback)
-        
+        if not done.wait(timeout):
+            raise TimeoutError('[>] Single async prediction timed out.')
         # Wait for result
-        while result[0] is None:
-            time.sleep(0.001)
-        
+        if isinstance(result[0], BaseException):
+            raise result[0]
         return result[0]
  
 
@@ -15276,10 +15300,8 @@ class IntegratedPipeline:
                 fresh_mlp_confidence = fresh_probs.max(axis=1, keepdims=True)
                 fresh_trans_confidence = fresh_trans_probs.max(axis=1, keepdims=True)
 
-                if fresh_mlp_confidence >= fresh_trans_confidence:
-                    fresh_probs = fresh_probs.copy()
-                else:
-                    fresh_probs = fresh_trans_probs.copy()
+                use_mlp = (fresh_mlp_confidence >= fresh_trans_confidence)
+                fresh_probs = np.where(use_mlp, fresh_probs, fresh_trans_probs)
 
                 if np.std(fresh_probs) < 0.3 or np.mean(fresh_probs) < 0.3:
                     fresh_probs, _ = self.ensemble.predict_ensemble(
@@ -19360,6 +19382,9 @@ class PipelineAsyncManager:
         self.max_workers = max_workers
         self.default_timeout = task_timeout
         self.max_retries = max_retries
+
+        self.pipeline.manager = self.prediction_manager
+        self.pipeline.distribution.predict_manager = self.prediction_manager
         
         self.security_level = security_level
         self.config = self._get_config_for_level(security_level) or SecurityConfig()
@@ -24282,7 +24307,7 @@ class PipelinePredictionManager:
         total_with_expected = 0
         X_samples, input_ids = payload['X_samples'], payload['input_ids']   
 
-        if len(self.error_counts) < 1:
+        if self.error_counts is None or len(self.error_counts) < 1:
             self.error_counts = np.zeros(len(self.label_map), dtype=np.float32)
 
         for idx, result in enumerate(results):
@@ -24473,7 +24498,7 @@ class ConsecutivePeerAgent:
                 print(f'[ConsecutivePeerAgent] Received a message!')
             except (json.JSONDecodeError, UnicodeDecodeError) as e:
                 logger.warning(f'[=] Invalid JSON from peer: {e}')
-                self._log_security_event('invalid_json', {})
+                self.pipeline.distribution._log_security_event('invalid_json', {})
                 return None
 
             message = self._decode_arrays_from_wire(message)
@@ -24902,6 +24927,9 @@ class CohesiveAgentDeployment:
             target_title=target_title,
             label=label_name
         )
+        self.pipeline.manager = self.manager
+        self.pipeline.distribution.predict_manager = self.manager
+
         if self.manager.config is None and predict_manager is not None:
             self.manager.config = predict_manager.config