AbstractIntegratedModule 1.0.8__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.8
+Version: 1.1.0
 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.1.0}/AbstractIntegratedModule.py

@@ -869,10 +869,10 @@ class Transformer:
         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)
+        
         else:
             Q = np.einsum('bsd,hdm->bhsm', x, W_q_mix)
             K = np.einsum('bsd,hdm->bhsm', x, W_k_mix)
@@ -1854,9 +1854,15 @@ class Dense:
         db = np.sum(dz, axis=0, keepdims=True) / batch_size
         dx = np.dot(dz, self.W.T)
 
-        # gradient clipping — clipped by value
-        np.clip(dW, -clip_value, clip_value, out=dW)
-        np.clip(db, -clip_value, clip_value, out=db)
+        # global norm clipping.
+        # Preserves gradient DIRECTION, only scales magnitude down when
+        # the total norm exceeds clip_value — avoided the frozen-equilibrium
+        # pattern that per-element clipping can produce.
+        total_norm = np.sqrt(np.sum(dW ** 2) + np.sum(db ** 2))
+        if total_norm > clip_value:
+            scale = clip_value / (total_norm + eps)
+            dW *= scale
+            db *= scale
 
         self.W -= lr * dW
         self.b -= lr * db
@@ -2144,6 +2150,7 @@ class MLP:
             print(f'[!] Cant adapt shape of Y sample arrays due to: {e}')
             return y_pred, y_true
 
+    
     def train(self, X, y, epochs=1000, lr=0.01, verbose=True, max_samples_for_focused_fit=500):
         X = self._sanitize_string_chars(X)
         y = self._sanitize_string_chars(y)
@@ -2168,6 +2175,7 @@ class MLP:
                     y_pred = self.focused_forward(X, AME=AME, anisotropy=anisotropy)
 
                 y_pred, y_true = self.adapt_predict_shape(y_pred, y)
+                
                 loss = Loss.categorical_crossentropy(y_true, y_pred)
                 grad = Loss.softmax_crossentropy_derivative(y_true, y_pred)
                 if focused_fit_condition:
@@ -11589,7 +11597,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 +11608,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]
+        try:
+            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)
+                transformer_pred, fresh_probs, attn_weights = self.model2.predict(fresh_input_ids)
+                mlp_pred = self.mlp.forward(fresh_X)
 
-            # 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)
+                # 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)
 
-            for i, idx in enumerate(needs_prediction):
+                for i, idx in enumerate(needs_prediction):
 
-                # validate indices in range before use
-                mlp_cls   = int(mlp_pred_indices[i])
-                trans_cls = int(trans_pred_indices[i])
+                    # validate indices in range before use
+                    mlp_cls   = int(mlp_pred_indices[i])
+                    trans_cls = int(trans_pred_indices[i])
 
-                mlp_cls   = mlp_cls   if 0 <= mlp_cls   < num_classes else 0
-                trans_cls = trans_cls if 0 <= trans_cls < num_classes else 0
-
-                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 +11862,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 +11928,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:
@@ -13229,6 +13250,59 @@ class IntegratedPipeline:
             x = np.fromiter((v for v in clean_str.split() if v not in skip_values), dtype=float)
 
         return x
+        
+    def _validate_onehot(self, y_true, context="train()"):
+        """
+        Robust one-hot validation for y_true, going beyond a simple .any() check.
+        Catches: out-of-range values, negative values, non-binary floats,
+        rows that don't sum to 1, and all-zero rows — each with a distinct,
+        actionable error message instead of a generic failure.
+        """
+        y_true = np.asarray(y_true, dtype=np.float64)
+
+        if y_true.ndim == 1:
+            y_true = y_true[np.newaxis, :]
+
+        issues = []
+
+        # 1. Values outside [0, 1] — catches your [5,3,1,4,3,2] case directly
+        out_of_range = (y_true < 0) | (y_true > 1)
+        if out_of_range.any():
+            bad_rows = np.where(out_of_range.any(axis=1))[0]
+            issues.append(
+                f"values outside [0,1] at rows {bad_rows.tolist()[:5]} "
+                f"(sample values: {y_true[bad_rows[0]].tolist() if len(bad_rows) else []}) "
+                f"— looks like raw label indices, not one-hot"
+            )
+
+        # 2. Non-binary values (e.g. soft labels or corrupted floats like 0.5, 0.999999)
+        #    Only check this if values ARE in [0,1] — no point double-reporting.
+        in_range = ~out_of_range
+        non_binary = in_range & (~np.isclose(y_true, 0, atol=1e-6)) & (~np.isclose(y_true, 1, atol=1e-6))
+        if non_binary.any():
+            bad_rows = np.where(non_binary.any(axis=1))[0]
+            issues.append(
+                f"non-binary values at rows {bad_rows.tolist()[:5]} "
+                f"(sample values: {y_true[bad_rows[0]].tolist() if len(bad_rows) else []}) "
+                f"— expected exactly 0 or 1 per class slot"
+            )
+
+        # 3. Row sums must be exactly 1 (each sample has exactly one true class)
+        row_sums = y_true.sum(axis=1)
+        bad_sum_rows = np.where(~np.isclose(row_sums, 1.0, atol=1e-3))[0]
+        if len(bad_sum_rows) > 0:
+            issues.append(
+                f"rows not summing to 1 at indices {bad_sum_rows.tolist()[:5]} "
+                f"(sums: {row_sums[bad_sum_rows[:5]].tolist()}) "
+                f"— either multi-label rows, all-zero rows, or raw indices"
+            )
+
+        if issues:
+            print(f"[WARNING] [{context}] y_true failed one-hot validation, one-hot encoding y sample...")
+            return True
+
+        return False
+
 
     def transformer_utilities(self, X_provided= None, X_raw=None, y_true=None, rules=None, 
                               datasets=None, label_map=None, batch_size=2, min_signal=1e-3,
@@ -13262,7 +13336,7 @@ class IntegratedPipeline:
         if X_provided is None:
             sequence_inputs = self.sequence_encoding(datasets, label_map=label_map)
         else:
-            sequence_inputs = self._features_to_sequence(X_provided)
+            sequence_inputs = self._features_to_sequence(X_provided, d_model=self.transformer_d_model)
 
         unsuitable_training = self.training_necessary_condition(sequence_inputs, X_raw)
         lr = self.model2.transformer_lr if self.model2 else self.transformer_lr
@@ -13335,7 +13409,7 @@ class IntegratedPipeline:
             weak_rows = np.where(row_sums < min_signal)[0]
             weak_ratio = len(weak_rows) / len(X_raw_features)
 
-            print(f'[!] Zero ratio in samples: {weak_ratio * 100}')
+            print(f'[!] Zero ratio in samples: {weak_ratio * 100}%')
             if weak_ratio > 0.3:  # more than 30% zero rows means vocab mismatch
                 if isinstance(X_raw_generation[0], str):
                     print(f'[= ! =] High zero-row ratio ({weak_ratio:.0%}), refitting on current batch')
@@ -13395,11 +13469,11 @@ class IntegratedPipeline:
                     n_heads=self.transformer_heads,
                     num_classes=n_classes
                 )
+                
             if self.use_transformer:
                 self.model2.train(sequence_inputs, y_true, epochs=self.transformer_training_epochs, mode=mode, lr=lr, embedded=True, batch_size=batch_size)
-                     
-            X = self.shape_adaptation(hybrid_X, input_dim)
-           
+                       
+            X = self.shape_adaptation(hybrid_X, input_dim)         
             self.initialize_model_(X, input_dim, n_classes)
             self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=self.mlp_lr, max_samples_for_focused_fit=max_samples_for_focused_fit)
             self.lstm_setup_inference(X, y, input_ids=sequence_inputs) 
@@ -16252,10 +16326,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 +16636,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 +16734,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
@@ -17122,6 +17205,18 @@ class PipelinePredictionManager:
                 X_train, X_val, y_train, y_val = self._prepare_train_val_split(
                     X, y, min_val_per_class=5, min_frac=0.1, max_frac=0.3
                 )
+                
+                onehot_validation = self.pipeline._validate_onehot(y_train)
+                if onehot_validation:
+                    if num_classes != len(label_map):
+                        num_classes = len(label_map)
+                    if num_classes > np.max(y_train):
+                        y_train = np.eye(num_classes)[np.asarray(y_train)]
+                        y_val = np.eye(num_classes)[np.asarray(y_val)]
+                    else:
+                        print('[⚠️] Warning: Y onehot encoding fails, Returning y samples as is, This may cause Exploding Gradient in MLP Training!')
+                        y_train = y_train
+                        y_val = y_val
 
                 X_mean = X_train.mean(axis=0)
                 X_std = X_train.std(axis=0) + 1e-8
@@ -17197,7 +17292,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.")
@@ -17236,12 +17331,10 @@ class PipelinePredictionManager:
                     X = X_gen
                 if X is not None and len(X) > 0:
                     X = np.asarray(X)
-                if X_val is not None and len(X_val) > 0:
-                    X = np.asarray(X_val)
-
+                
             # 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 +17350,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