AbstractIntegratedModule 1.0.9__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.9
+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.9 → 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:
@@ -13242,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,
@@ -13275,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
@@ -13348,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')
@@ -13408,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) 
@@ -17144,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
@@ -17258,9 +17331,7 @@ 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.model3.predict_proba(X)