AbstractIntegratedModule 1.0.8__tar.gz → 1.0.9__tar.gz

{abstractintegratedmodule-1.0.8 → abstractintegratedmodule-1.0.9}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.8
+Version: 1.0.9
 Summary: Integrated Pipeline with Specialized Non-LLM AI Agent Framework for ARM64 architecture
 Author: Micro-Novelty
 Author-email: Micro-Novelty <hernikpuspita5@gmail.com>

{abstractintegratedmodule-1.0.8 → abstractintegratedmodule-1.0.9}/AbstractIntegratedModule.py

@@ -11589,7 +11589,6 @@ class IntegratedPipeline:
         batch_probs = [None] * batch_size
         fresh_probs = None   # explicit init, no UnboundLocalError
 
-        
         for i in range(batch_size):
             probs = self.model_probability_gate(
                 batch_input_ids[i:i+1],
@@ -11601,92 +11600,96 @@ class IntegratedPipeline:
 
         needs_prediction = [i for i, p in enumerate(batch_probs) if p is None]
 
-        if needs_prediction:
-            fresh_input_ids = batch_input_ids[needs_prediction]
-            fresh_X         = batch_X[needs_prediction]
-
-            transformer_pred, fresh_probs, attn_weights = self.model2.predict(fresh_input_ids)
-            mlp_pred = self.mlp.forward(fresh_X)
+        try:
+            if needs_prediction:
+                fresh_input_ids = batch_input_ids[needs_prediction]
+                fresh_X         = batch_X[needs_prediction]
 
-            # coerce indices to int 
-            mlp_pred_indices   = np.argmax(mlp_pred,   axis=1).astype(int)
-            trans_pred_indices = np.argmax(fresh_probs, axis=1).astype(int)
+                transformer_pred, fresh_probs, attn_weights = self.model2.predict(fresh_input_ids)
+                mlp_pred = self.mlp.forward(fresh_X)
 
-            for i, idx in enumerate(needs_prediction):
+                # coerce indices to int 
+                mlp_pred_indices   = np.argmax(mlp_pred,   axis=1).astype(int)
+                trans_pred_indices = np.argmax(fresh_probs, axis=1).astype(int)
 
-                # validate indices in range before use
-                mlp_cls   = int(mlp_pred_indices[i])
-                trans_cls = int(trans_pred_indices[i])
+                for i, idx in enumerate(needs_prediction):
 
-                mlp_cls   = mlp_cls   if 0 <= mlp_cls   < num_classes else 0
-                trans_cls = trans_cls if 0 <= trans_cls < num_classes else 0
+                    # validate indices in range before use
+                    mlp_cls   = int(mlp_pred_indices[i])
+                    trans_cls = int(trans_pred_indices[i])
 
-                if mlp_cls != trans_cls:
-                    calibrated = self._calibrate_probs(
-                        fresh_probs[i:i+1],
-                        [mlp_cls],
-                        attn_weights[i:i+1] if attn_weights is not None else None,
-                        fresh_input_ids[i:i+1]
-                    )
-                    # validate calibrated output shape
-                    row = np.asarray(calibrated[0])
-                    if row.shape[0] != num_classes:
-                        aligned = np.zeros(num_classes)
-                        aligned[:min(row.shape[0], num_classes)] = row[:num_classes]
-                        row = aligned
-                    batch_probs[idx] = row
+                    mlp_cls   = mlp_cls   if 0 <= mlp_cls   < num_classes else 0
+                    trans_cls = trans_cls if 0 <= trans_cls < num_classes else 0
 
-                else:
-                    # models agree — boost confidence on agreed class
-                    probs_i        = fresh_probs[i].copy()
-                    probs_i[trans_cls] = min(probs_i[trans_cls] * 1.2, 0.95)
-                    row_sum        = probs_i.sum()
-                    probs_i       /= row_sum if row_sum > 1e-8 else 1.0
-                    batch_probs[idx] = probs_i
-
-                # instance-level save counter, not local idx_total
-                if getattr(self, '_prob_save_count', 0) < 2:
-                    self.modular_probability_saving(
-                        fresh_input_ids[i:i+1],
-                        fresh_X[i:i+1],
-                        np.array([batch_probs[idx]])
-                    )
-                    self._prob_save_count = getattr(self, '_prob_save_count', 0) + 1
+                    if mlp_cls != trans_cls:
+                        calibrated = self._calibrate_probs(
+                            fresh_probs[i:i+1],
+                            [mlp_cls],
+                            attn_weights[i:i+1] if attn_weights is not None else None,
+                            fresh_input_ids[i:i+1]
+                        )
+                        # validate calibrated output shape
+                        row = np.asarray(calibrated[0])
+                        if row.shape[0] != num_classes:
+                            aligned = np.zeros(num_classes)
+                            aligned[:min(row.shape[0], num_classes)] = row[:num_classes]
+                            row = aligned
+                        batch_probs[idx] = row
 
-        else:
-            raise Warning('[!] Data is None before batching!')
+                    else:
+                        # models agree — boost confidence on agreed class
+                        probs_i        = fresh_probs[i].copy() if i < len(fresh_probs) else fresh_probs[0]
+                        probs_i[trans_cls] = min(probs_i[trans_cls] * 1.2, 0.95)
+                        row_sum        = probs_i.sum()
+                        probs_i       /= row_sum if row_sum > 1e-8 else 1.0
+                        batch_probs[idx] = probs_i
+
+                    # instance-level save counter, not local idx_total
+                    if getattr(self, '_prob_save_count', 0) < 2:
+                        self.modular_probability_saving(
+                            fresh_input_ids[i:i+1],
+                            fresh_X[i:i+1],
+                            np.array([batch_probs[idx]])
+                        )
+                        self._prob_save_count = getattr(self, '_prob_save_count', 0) + 1
 
-        # safe final assembly with consistent shape
-        valid_probs = []
-        for i, p in enumerate(batch_probs):
-            if p is None:
-                valid_probs.append(zero_row.copy())
-            elif isinstance(p, list):
-                arr = np.array(p, dtype=np.float64)
-                if arr.shape[0] != num_classes:
-                    aligned = np.zeros(num_classes)
-                    aligned[:min(arr.shape[0], num_classes)] = arr[:num_classes]
-                    arr = aligned
-                valid_probs.append(arr)
-            elif isinstance(p, np.ndarray):
-                if p.shape[0] != num_classes:
-                    aligned = np.zeros(num_classes)
-                    aligned[:min(p.shape[0], num_classes)] = p[:num_classes]
-                    p = aligned
-                valid_probs.append(p)
             else:
-                if output_memory is not None:
-                    print('[=] Unexpected Sample type in batch probability, Using previous memory to fill gaps in Samples Ambiguity')
-                    valid_probs.append(output_memory)
-                else:
-                    print(f'[⚠️] Unexpected Sample type in batch_probs[{i}]: {type(p)} — using zeros to fill in valid probability')
+                raise Warning('[!] Data is None before batching!')
+
+            # safe final assembly with consistent shape
+            valid_probs = []
+            for i, p in enumerate(batch_probs):
+                if p is None:
                     valid_probs.append(zero_row.copy())
-                
-        try:
-            return np.stack(valid_probs)
-        except ValueError as e:
-            print(f'[⚠️] Stack failed: {e} — shapes: {[p.shape for p in valid_probs]}')
-            return valid_probs
+                elif isinstance(p, list):
+                    arr = np.array(p, dtype=np.float64)
+                    if arr.shape[0] != num_classes:
+                        aligned = np.zeros(num_classes)
+                        aligned[:min(arr.shape[0], num_classes)] = arr[:num_classes]
+                        arr = aligned
+                    valid_probs.append(arr)
+                elif isinstance(p, np.ndarray):
+                    if p.shape[0] != num_classes:
+                        aligned = np.zeros(num_classes)
+                        aligned[:min(p.shape[0], num_classes)] = p[:num_classes]
+                        p = aligned
+                    valid_probs.append(p)
+                else:
+                    if output_memory is not None:
+                        print('[=] Unexpected Sample type in batch probability, Using previous memory to fill gaps in Samples Ambiguity')
+                        valid_probs.append(output_memory)
+                    else:
+                        print(f'[⚠️] Unexpected Sample type in batch_probs[{i}]: {type(p)} — using zeros to fill in valid probability')
+                        valid_probs.append(zero_row.copy())
+                    
+            try:
+                return np.stack(valid_probs)
+            except ValueError as e:
+                print(f'[⚠️] Stack failed: {e} — shapes: {[p.shape for p in valid_probs]}')
+                return valid_probs
+        except Exception as e:
+            print(f'[⚠️] Error occured in probabilities batching: {e}')
+            return None
 
 
     def hybrid_prediction(self, rules, input_ids, dataset, X=None, y=None, use_embedded=True):
@@ -11851,6 +11854,13 @@ class IntegratedPipeline:
             self.temporary_id.append(self.agent_id)
             id_history = self.temporary_id
 
+        if input_ids is None and X is not None:
+            logits = self.model3.forward(X)
+            return self.model3._softmax(logits)
+
+        if input_ids is None and X is None:
+            raise Warning('[!] X and input indices are None! cannot proceed with Batching probabilities!')
+
         if self.use_transformer:
             is_batch = len(input_ids.shape) == 2 and input_ids.shape[0] > 1
         else:
@@ -11910,8 +11920,11 @@ class IntegratedPipeline:
                 self.peer_assistance_threshold -= 0.2               
                 print('[+] Both Models agree, Normalizing prediction with confidence boost...')
                 for i, target in enumerate(mlp_pred_indices):
-                    probs[i, target] = min(probs[i, target] * 1.2, 0.95)
-                    probs[i] /= probs[i].sum()
+                    if i < len(probs):
+                        probs[i, target] = min(probs[i, target] * 1.2, 0.95)
+                        probs[i] /= probs[i].sum()
+                    else:
+                        probs /= probs.sum()
 
                     
             if not agreement and probs_memory is not None:
@@ -16252,10 +16265,12 @@ class PipelinePredictionManager:
 
             # Forward pass through MLP
             if hasattr(self.pipeline.mlp, 'predict_proba'):
-                mlp_probs = self.pipeline.mlp.predict_proba(X_tfidf)
+                if X_tfidf is None:
+                    X_tfidf = X
+                mlp_probs = self.pipeline.model3.predict_proba(X)
             else:
                 # Fallback if predict_proba not available
-                logits = self.pipeline.mlp.forward(X_tfidf)
+                logits = self.pipeline.model3.forward(X)
                 mlp_probs = self.pipeline._softmax(logits)
                 
             # Validate all MLP predictions at once
@@ -16560,7 +16575,7 @@ class PipelinePredictionManager:
             else:
                 input_datasets = self.pipeline._features_to_sequence(X)
 
-            pred_probs = self.pipeline.predict_proba(input_datasets, X_raw, type='Hybrid')[0]
+            pred_probs = self.pipeline.predict_proba(input_datasets, X_raw, type='Hybrid', embedded=True)[0]
             try:
                 pred_result = self.pipeline.hybrid_prediction(rules, input_datasets, datasets, X=X, y=y, use_embedded=True)
             except:
@@ -16658,9 +16673,16 @@ class PipelinePredictionManager:
                     confidence = final_probs[i, class_idx]
                 else:
                     if isinstance(final_probs[i], (list, np.ndarray)):
-                        confidence = final_probs[i][class_idx]
+                        if i < len(final_probs):
+                            confidence = final_probs[i][class_idx]
+                        else:
+                            confidence = np.mean(final_probs[class_idx])
                     else:
-                        confidence = float(final_probs[i])  # Single value
+                        if i < len(final_probs):
+                            confidence = float(final_probs[i])  # Single value
+                        else:
+                            confidence = float(np.mean(final_probs))
+
                         
                 if confidence > best_confidence:
                     best_idx = i
@@ -17197,7 +17219,7 @@ class PipelinePredictionManager:
                     AME = self.pipeline.model2.AME_Encoder(input_ids) 
 
                     trans_probs, attn_weights = self.pipeline.model2.forward(input_ids, AME=AME, embedded=use_embedded)
-                    
+            
             else:
                 print("\n[⚡] Running MLP-only predictions")
                 print("[⚡] Note: Transformer not available, so Transformer results will be replaced with MLP results.")
@@ -17241,7 +17263,7 @@ class PipelinePredictionManager:
 
             # MLP forward pass  
             if hasattr(self.pipeline.mlp, 'predict_proba'):
-                mlp_probs = self.pipeline.mlp.predict_proba(X)
+                mlp_probs = self.pipeline.model3.predict_proba(X)
             else:
                 logits = self.pipeline.mlp.forward(X)
                 mlp_probs = self.pipeline._softmax(logits)
@@ -17257,7 +17279,7 @@ class PipelinePredictionManager:
                 # Replace invalid indices with argmax within valid range
                 for i in range(len(mlp_pred_indices)):
                     valid_probs = mlp_probs[i][:num_classes] if num_classes > 0 else mlp_probs[i]
-                    if len(valid_probs) > 0:
+                    if len(valid_probs) > 0 and i < len(mlp_pred_indices):
                         mlp_pred_indices[i] = int(np.argmax(valid_probs))
                     else:
                         mlp_pred_indices[i] = 0  # Default to first class