AbstractIntegratedModule 0.9.3__tar.gz → 0.9.4__tar.gz

{abstractintegratedmodule-0.9.3 → abstractintegratedmodule-0.9.4}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.3
+Version: 0.9.4
 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.3 Official Release.
+- Development Stage: 0.9.4 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.
@@ -79,14 +79,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
    - Transformer Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage, With Reduced Training Time.
 ______________
-  - Changelog:
-     - v0.9.3:
-        - [=] New features: 
-        - titles and rules is now Optional in all prediction methods, given if X and y samples are provided during prediction.
-        - added guards for saving samples to check for ellipsis object.
-        - Both Asynchronous Prediction and P2P doesnt rely on titles and rules, given if X and y samples are provided.
-        - refined Transformer and MLP training methods.
-        - Added new method to generate supported samples from the Provided X samples that matched Transformer token embedding
+  
 ____________
 <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" />
 

{abstractintegratedmodule-0.9.3 → abstractintegratedmodule-0.9.4}/AbstractIntegratedModule.py

@@ -62,7 +62,9 @@ try:
         optimized_anisotropy,
         optimized_cosine_similarity,
         optimized_softmax_2d,
-        optimized_dynamic_weighted_ensemble
+        optimized_dynamic_weighted_ensemble,
+        optimized_qkv_weight_grad,
+        optimized_qkv_input_grad,
     )
     _OPT_AVAILABLE = True
     print('[=] Cython acceleration loaded ✅')
@@ -141,7 +143,8 @@ class AsyncRequest:
     @property
     def age(self) -> float:
         return time.time() - self.created_at
-    
+
+
     @property
     def is_expired(self, timeout: int = 30) -> bool:
         return self.age > timeout
@@ -169,16 +172,28 @@ class Message:
     max_retries: int = 3
     timeout: float = 30.0
     created_at: float = field(default_factory=time.time)
-    
+    trust: float = 1.0    
+
     @property
     def age(self) -> float:
         """Age of message in seconds."""
         return time.time() - self.created_at
-    
+
+    @property
+    def proper_trust(self) -> bool:
+        return self.trust > 0.3
+
+    @property
+    def degrade_trust(self) -> bool:
+        self.trust = self.trust - 0.1 
+
     @property
     def is_expired(self) -> bool:
         """Check if message has expired."""
-        return self.age > self.timeout
+        expired = self.age > self.timeout
+        if expired:
+            self.degrade_trust()
+        return expired
     
     # ============ COMPARISON METHODS FOR PRIORITY QUEUE ============
     
@@ -1212,24 +1227,31 @@ class Transformer:
 
         x = self.cache['x_attn_input']
 
-        d_W_q = np.einsum('bsd, bhsm->hdm', x, d_Q)
-        d_W_k = np.einsum('bsd, bhsm->hdm', x, d_K)
-        d_W_v = np.einsum('bsd, bhsm->hdm', x, d_V)
+        if _OPT_AVAILABLE:
+            B, S = x.shape[0], x.shape[1]
+            H, M = self.n_heads, self.d_model // self.n_heads
+
+            d_W_q = optimized_qkv_weight_grad(x, d_Q, B, S, H, self.d_model, M)
+            d_W_k = optimized_qkv_weight_grad(x, d_K, B, S, H, self.d_model, M)
+            d_W_v = optimized_qkv_weight_grad(x, d_V, B, S, H, self.d_model, M)
+
+            d_x_q = optimized_qkv_input_grad(d_Q, self.W_q, B, S, H, self.d_model, M)
+            d_x_k = optimized_qkv_input_grad(d_K, self.W_k, B, S, H, self.d_model, M)
+            d_x_v = optimized_qkv_input_grad(d_V, self.W_v, B, S, H, self.d_model, M)  
+        else:          
+            d_W_q = np.einsum('bsd, bhsm->hdm', x, d_Q)
+            d_W_k = np.einsum('bsd, bhsm->hdm', x, d_K)
+            d_W_v = np.einsum('bsd, bhsm->hdm', x, d_V)
 
-        d_x_q = np.einsum('bhsm, hdm->bsd', d_Q, self.W_q)
-        d_x_k = np.einsum('bhsm, hdm->bsd', d_K, self.W_k)
-        d_x_v = np.einsum('bhsm, hdm->bsd', d_V, self.W_v)
+            d_x_q = np.einsum('bhsm, hdm->bsd', d_Q, self.W_q)
+            d_x_k = np.einsum('bhsm, hdm->bsd', d_K, self.W_k)
+            d_x_v = np.einsum('bhsm, hdm->bsd', d_V, self.W_v)
 
         d_x_attn_input = d_x_q + d_x_k + d_x_v
         d_x_total = d_x_attn_input + d_residual
 
         input_ids = self.cache.get('input_ids')
 
-        if input_ids is not None:
-            flat_ids = input_ids.flatten()          # (B*T,)
-            flat_grads = d_x_total.reshape(-1, self.d_model) / self.cache['seq_len']
-            np.add.at(self.token_embedding, flat_ids, -lr * flat_grads)
-
         # Update weights
         grads = {
                 'output': d_Wo,
@@ -1333,6 +1355,9 @@ class Transformer:
         y_true_smoothed_list = []        
         d_model = self.d_model
 
+        input_ids_list = self._sanitize_string_chars(input_ids_list)
+        y_true_list = self._sanitize_string_chars(y_true_list)
+
         # W_o geometric init — unchanged
         if not self.encoded:
             self.shaping = GeometricWeightShaping(d_model, d_model)
@@ -1494,8 +1519,19 @@ class Transformer:
         acc   = float(np.mean(preds == true))
 
         return loss, acc
+        
+    def _sanitize_string_chars(self, x):
+        if isinstance(x, (str, np.str_)):
+            clean_str = str(x).replace('[', '').replace(']', '').replace('...', '').strip()
+            x = np.fromstring(clean_str, sep=' ')
 
+        if isinstance(x, np.ndarray) and np.issubdtype(x.dtype, np.character):
+            # catches arrays filled with string text
+            clean_str = ' '.join(x.astype(str).flatten()).replace('[', '').replace(']', '')
+            skip_values = {"...", "NaN", "null"}
+            x = np.fromiter((v for v in clean_str.split() if v not in skip_values), dtype=float)
 
+        return x
 
     def predict(self, input_ids, embedded=False):
         if not embedded and input_ids.ndim == 1:
@@ -1509,6 +1545,8 @@ class Transformer:
 
 
     def AME_Encoder(self, x):
+        x = self._sanitize_string_chars(x)
+
         # Optimized AME_Encoder for Transformer
         x = np.asarray(x)        
         if _OPT_AVAILABLE and np.asarray(x).ndim == 2:
@@ -1527,6 +1565,8 @@ class Transformer:
 
     def anisotropy_measurement(self, x):
         eps = 1e-5
+
+        x = self._sanitize_string_chars(x)
         if _OPT_AVAILABLE:
             x = np.asarray(x)            
             x = x.reshape(x.shape[0], -1)
@@ -1576,7 +1616,7 @@ class Transformer:
 
         # AME inline — avoids second np.gradient call in AME_Encoder
         # gradient is already a list of arrays, one per dimension
-        # stack into single array for vectorized norm — ARM64 NEON friendly
+        # stacked into single array for vectorized norm — ARM64 NEON friendly
         if AME is None:
             grad_stack  = np.stack([g.ravel() for g in gradient])  # (ndim, N)
             grad_norms  = np.linalg.norm(grad_stack, axis=1)       # (ndim,) — one NEON call
@@ -1674,8 +1714,8 @@ class Dense:
         return x
 
     def multi_modal_linear_transformation(self, x):
-
         x = self._sanitize_string_chars(x)
+
         if len(x.shape) > 1 and x.shape[1] != self.W.shape[0]:
             V1, V2 = x.shape[0], x.shape[1]            
             try:
@@ -1721,6 +1761,8 @@ class Dense:
 
 
     def forward(self, x):
+
+        x = self._sanitize_string_chars(x)
         self.x = x
         self.z = self.multi_modal_linear_transformation(x)
 
@@ -1800,6 +1842,19 @@ class MLP:
             x = layer.forward(x)
    
         return self.softmax.forward(x)
+        
+    def _sanitize_string_chars(self, x):
+        if isinstance(x, (str, np.str_)):
+            clean_str = str(x).replace('[', '').replace(']', '').replace('...', '').strip()
+            x = np.fromstring(clean_str, sep=' ')
+
+        if isinstance(x, np.ndarray) and np.issubdtype(x.dtype, np.character):
+            # catches arrays filled with string text
+            clean_str = ' '.join(x.astype(str).flatten()).replace('[', '').replace(']', '')
+            skip_values = {"...", "NaN", "null"}
+            x = np.fromiter((v for v in clean_str.split() if v not in skip_values), dtype=float)
+
+        return x
 
 
     def _calibrate_gradient(self, grad, AME, anisotropy):
@@ -1978,6 +2033,9 @@ class MLP:
             return y_pred, y_true
 
     def train(self, X, y, epochs=1000, lr=0.01, verbose=True):
+        X = self._sanitize_string_chars(X)
+        y = self._sanitize_string_chars(y)
+
         AME = self.AME_Encoder(X)     
         anisotropy = self.anisotropy_measurement(X)
         focused_fit_condition = len(self.feed_layers) > 0 and anisotropy > 0.25 and AME > 0.25
@@ -5812,88 +5870,85 @@ class ModelStorage:
 
 
 class AsyncMessageQueue:
-    # async message queue handler.
-    
-    def __init__(self, max_size=1000, dead_letter_queue_size=100):
-        self.queue = asyncio.PriorityQueue(maxsize=max_size)
+    def __init__(self, max_size=1000, dead_letter_queue_size=100,
+                latency_smoothing=0.2):   
+        self.queue   = asyncio.PriorityQueue(maxsize=max_size)
         self.pending: Dict[str, asyncio.Future] = {}
         self.results: Dict[str, Any] = {}
         self.handlers: Dict[str, Callable] = {}
         self.dead_letter_queue: deque = deque(maxlen=dead_letter_queue_size)
         self._running = False
+
         self._worker_task: Optional[asyncio.Task] = None
-        self._loop: Optional[asyncio.AbstractEventLoop] = None   
-        self._counter_lock = asyncio.Lock() 
-        self._start_lock = asyncio.Lock()            
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._start_lock = asyncio.Lock()   
+
         self._counter = 0
+        self.alpha    = latency_smoothing   #EMA weight
+
         self._stats = {
             'messages_processed': 0,
-            'messages_failed': 0,
-            'messages_retried': 0,
-            'messages_expired': 0,
-            'avg_latency': 0.0
+            'messages_failed'   : 0,
+            'messages_retried'  : 0,
+            'messages_expired'  : 0,
+            'avg_latency'       : 0.0,
+            'messages_untrusted': 0
         }
-        
+
     def register_handler(self, message_type: str, handler: Callable):
-        # Register a handler for specific message type
         self.handlers[message_type] = handler
-      
         logger.info(f"[=] Registered handler for {message_type}")
-    
+
+
     async def _ensure_started(self):
-        """Start the worker if not already running"""
+        """Single entry point for starting the worker """
         if self._running:
             return
-        
+
         async with self._start_lock:
             if self._running:
                 return
-            
-            self._running = True
+            self._running     = True
             self._worker_task = asyncio.create_task(self._worker())
+
             logger.info("[=] Async message queue worker started")
-            
-            # Give worker a moment to initialize
             await asyncio.sleep(0.1)
-            
             if self._worker_task.done():
                 exc = self._worker_task.exception()
                 if exc:
                     logger.error(f"[=] Worker failed: {exc}")
+                    self._running = False   
                     raise exc
-    
+
 
     async def publish(self, message: Message) -> Any:
-        # Publish a message and wait for response.
-        # Generate unique counter
         await self._ensure_started()
 
-        async with self._counter_lock:
-            self._counter += 1
-            counter = self._counter
+        # plain increment, no lock needed (no await in critical section)
+        self._counter += 1
+        counter = self._counter
         
+        if self._stats['avg_latency'] > 0.25:
+            message.trust - 0.1
+
         if message.is_expired:
             logger.warning(f"[-] Message {message.id} already expired")
             raise TimeoutError(f"[-] Message {message.id} already expired")
             
+
+        if not message.proper_trust:
+            raise Warning(f"[!] Message is not properly Trusted!")
+
         future = asyncio.Future()
         self.pending[message.id] = future
-        logger.info(f"[=] Publishing message, ID: {message.id} of type {message.type} with priority {message.priority.name}")
+        logger.debug(f"[=] Publishing message {message.id} type={message.type} "
+                     f"priority={message.priority.name}")
 
-        print('=== Queue Status ===')
-        logger.info(f"[QueueStatus] Queue size before put: {self.queue.qsize()}")
-        logger.info(f"[QueueStatus] Queue maxsize: {self.queue.maxsize}")
-        logger.info(f"[QueueStatus] Queue full: {self.queue.full()}")
-        logger.info(f"[QueueStatus] Worker running: {self._worker_task is not None and not self._worker_task.done()}")
-                
-        # Use priority queue (lower number = higher priority)
+        # 3-tuple, matches _worker's unpack exactly as is.
         await self.queue.put((message.priority.value, counter, message))
-        logger.debug(f"[=] Message {message.id} enqueued, waiting for response...")
-        
+
         try:
-            logger.debug(f"[=] Awaiting response for message {message.id} with timeout {message.timeout}s")
             result = await asyncio.wait_for(future, timeout=message.timeout)
-            logger.debug(f"[=] Received response for message {message.id}: {result}")
             return result
         except asyncio.TimeoutError:
             self.pending.pop(message.id, None)
@@ -5902,66 +5957,95 @@ class AsyncMessageQueue:
             raise
         except Exception as e:
             self.pending.pop(message.id, None)
-            logger.error(f"[-] Error occurred while processing message {message.id}: {e}")
+            logger.error(f"[-] Error processing message {message.id}: {e}")
             raise
-    
+
     async def publish_async(self, message: Message, callback: Optional[Callable] = None):
-        # Publish without waiting (fire and forget).
+        """Fire and forget, uses consistent 3-tuple format."""
+        await self._ensure_started()
         message.callback = callback
-        await self.queue.put((message.priority.value, message))
-    
+
+        self._counter += 1
+        counter = self._counter
+        await self.queue.put((message.priority.value, counter, message))
+
     async def _worker(self):
-        # Background worker processing messages.
         while self._running:
             try:
-                priority, counter, message = await asyncio.wait_for(self.queue.get(), timeout=1.0)
-                logger.info(f"[=] Worker picked up message {message.id} (counter: {counter}, priority: {priority})") 
+                priority, counter, message = await asyncio.wait_for(
+                    self.queue.get(), timeout=1.0
+                )
+                logger.debug(f"[=] Worker picked up {message.id} "
+                            f"(counter={counter}, priority={priority})")
 
                 start_time = time.time()
-                
+
                 if message.is_expired:
                     self._stats['messages_expired'] += 1
-                    logger.warning(f"[-] Dropping expired message {message.id}")
                     self._handle_orphaned_message(message)
                     continue
-                
+
+                if not message.proper_trust:
+                    self._stats['messages_untrusted'] += 1
+
+                    # treat as orphan
+                    self._handle_orphaned_message(message)
+                    continue                    
+
                 if message.type in self.handlers:
                     try:
-                        # Execute handler
                         if asyncio.iscoroutinefunction(self.handlers[message.type]):
                             result = await self.handlers[message.type](message)
                         else:
                             result = self.handlers[message.type](message)
-                        
-                        # Calculate latency
+
                         latency = time.time() - start_time
                         self._update_stats(latency, success=True)
-                        
-                        # Handle response
+
+                        # pop from pending on success, was leaking before
                         if message.id in self.pending:
-                            self.pending[message.id].set_result(result)
+                            future = self.pending.pop(message.id)
+                            if not future.done():
+                                future.set_result(result)
                         elif message.callback:
                             message.callback(result)
-                            
+
                     except Exception as e:
                         self._stats['messages_failed'] += 1
-                        logger.error(f"[-] Handler failed for {message.type}: {e}\n{traceback.format_exc()}")
-                        
+                        logger.error(f"[-] Handler failed for {message.type}: {e}\n"
+                                    f"{traceback.format_exc()}")
+
                         if message.retry_count < message.max_retries:
                             message.retry_count += 1
                             self._stats['messages_retried'] += 1
-                            logger.info(f"[-] Retrying message {message.id} (attempt {message.retry_count})")
-                            await self.queue.put((message.priority.value, message))
+                            # consistent 3-tuple on retry too
+                            self._counter += 1
+                            retry_counter = self._counter
+                            await self.queue.put(
+                                (message.priority.value, retry_counter, message)
+                            )
                         else:
                             self._dead_letter_message(message, e)
+                            # popped here.
                             if message.id in self.pending:
-                                self.pending[message.id].set_exception(e)
+                                future = self.pending.pop(message.id)
+                                if not future.done():
+                                    future.set_exception(e)
                             elif message.callback:
                                 message.callback(e)
                 else:
                     logger.warning(f"[-] No handler for message type: {message.type}")
-                    self._dead_letter_message(message, Exception(f"No handler for {message.type}"))
-                    
+                    self._dead_letter_message(
+                        message, Exception(f"[!] No handler for {message.type}")
+                    )
+                    # pop here too, unhandled message type leaked before
+                    if message.id in self.pending:
+                        future = self.pending.pop(message.id)
+                        if not future.done():
+                            future.set_exception(
+                                Exception(f"No handler for {message.type}")
+                            )
+
             except asyncio.TimeoutError:
                 continue
             except asyncio.CancelledError:
@@ -5970,62 +6054,60 @@ class AsyncMessageQueue:
             except Exception as e:
                 logger.error(f"[-] Worker error: {e}\n{traceback.format_exc()}")
                 await asyncio.sleep(0.1)
-    
+
+
     def _update_stats(self, latency: float, success: bool):
-        # Update queue statistics
         self._stats['messages_processed'] += 1
         if not success:
             self._stats['messages_failed'] += 1
-        
-        # Update moving average
-        alpha = 0.1  # Smoothing factor
-        self._stats['avg_latency'] = alpha * latency + (1 - alpha) * self._stats['avg_latency']
-    
+
+        alpha = self.alpha
+        self._stats['avg_latency'] = (
+            alpha * latency + (1 - alpha) * self._stats['avg_latency']
+        )
+
+
     def _dead_letter_message(self, message: Message, error: Exception):
-        # Send failed message to dead letter queue
         self.dead_letter_queue.append({
-            'message': message,
-            'error': str(error),
-            'timestamp': datetime.now(),
+            'message'    : message,
+            'error'      : str(error),
+            'timestamp'  : datetime.now(),
             'retry_count': message.retry_count
         })
-        logger.error(f"[=] Message {message.id} sent to DLQ after {message.retry_count} retries")
-    
+        logger.error(f"[=] Message {message.id} sent to DLQ after "
+                    f"{message.retry_count} retries")
+
     def _handle_orphaned_message(self, message: Message):
-        # Handle orphaned messages (no pending future, no callback).
         logger.warning(f"[=] Orphaned message {message.id} of type {message.type}")
-        # Could store for manual inspection
         self.dead_letter_queue.append({
-            'message': message,
-            'error': 'Orphaned message - no handler or callback',
+            'message'  : message,
+            'error'    : 'Orphaned message - expired before processing',
             'timestamp': datetime.now()
         })
-    
+        # orphaned messages with pending futures also leaked before
+        if message.id in self.pending:
+            future = self.pending.pop(message.id)
+            if not future.done():
+                future.set_exception(TimeoutError(f"Message {message.id} expired"))
+
     def get_stats(self) -> Dict:
-        # Get queue statistics.
         return {
             **self._stats,
             'pending_count': len(self.pending),
-            'queue_size': self.queue.qsize(),
-            'dlq_size': len(self.dead_letter_queue),
-            'is_running': self._running
+            'queue_size'   : self.queue.qsize(),
+            'dlq_size'     : len(self.dead_letter_queue),
+            'is_running'   : self._running
         }
-    
 
-    
     async def start(self):
-        # Start the async worker (async version).
-        if self._running:
-            logger.warning("[=] Queue already running")
-            return
-        
-        self._running = True
-        self._worker_task = asyncio.create_task(self._worker())
-        logger.info("[=] Async message queue started")
-          
+        """delegates to _ensure_started, single code path."""
+        try:
+            await self._ensure_started()
+        except Exception as e:
+            print(f'[!] Workers failed to start: {e}')
+
     
     async def stop(self, timeout: float = 5.0):
-        # Stop the message queue worker gracefully.
         logger.info("[=] Stopping message queue...")
         self._running = False
         if self._worker_task:
@@ -6034,16 +6116,24 @@ class AsyncMessageQueue:
             except asyncio.TimeoutError:
                 self._worker_task.cancel()
                 logger.warning("[=] Worker task did not stop gracefully")
+
+        # clean up any still-pending futures on shutdown
+        for msg_id, future in list(self.pending.items()):
+            if not future.done():
+                future.set_exception(RuntimeError("Queue stopped"))
+        self.pending.clear()
+
         logger.info("[=] Async message queue stopped")
-    
+
     def get_dead_letter_queue(self) -> List[Dict]:
-        # Get copy of dead letter queue for inspection.
-        return list(self.dead_letter_queue)
+        if self.dead_letter_queue is not None:
+            return list(self.dead_letter_queue)
+        else:
+            return []
 
 
 class ThreadedMessageQueue:
     # Thread-based message queue for synchronous code
-    
     def __init__(self, max_size=1000, worker_threads=4):
         self.queue = queue.Queue(maxsize=max_size)
         self.results = {}
@@ -6077,9 +6167,9 @@ class ThreadedMessageQueue:
         start_time = time.time()
         while not result_container['ready'] and (time.time() - start_time) < timeout:
             time.sleep(0.01)
-        
+
         if not result_container['ready']:
-            raise TimeoutError(f"Message {message.id} timed out")
+            raise TimeoutError(f"[!] Message {message.id} timed out")
         
         if result_container['error']:
             raise result_container['error']
@@ -8023,13 +8113,17 @@ class AgentDistributedInference:
 
 
     def process_peer_request(self, probs, target_preds, attn_weights, input_ids):
-        try:
-            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}")
-            traceback.print_exc()
+        if probs is not None and target_preds is not None and attn_weights is not None and input_ids is not None:
+            try:
+                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}")
+                return probs
+        else:
+            print('[=] Cannot process peer request due to incomplete Missing samples, returning regular probs!')
             return probs
+        
             
 
     # ============ REQUEST HANDLERS ============
@@ -10309,6 +10403,8 @@ class IntegratedPipeline:
         except (TypeError, ValueError):
             return default
 
+
+
     def _batch_prediction_core(self, batch_input_ids: np.ndarray, batch_X: np.ndarray, 
                                 batch_size: Any = None, show_progress: bool = True) -> np.ndarray:
         """
@@ -10418,7 +10514,7 @@ class IntegratedPipeline:
                 batch_probs[start_idx:end_idx] = 0
         
         if show_progress:
-            print(f"\r✅ Batch complete: {n_samples} samples processed                    ")
+            print(f"\r✅ Batch complete: {n_samples} samples processed")
         
         return batch_probs if batch_probs is not None else np.array([])
 
@@ -16343,8 +16439,8 @@ 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(prob):
-                            prob[c]  *= reputation  
+                        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
@@ -16357,8 +16453,8 @@ 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(prob):
-                            prob[c]  *= reputation
+                        if c < len(final_probs):
+                            final_probs[c]  *= reputation
 
                     
             prob_sum = final_probs.sum()