AbstractIntegratedModule 1.0.9__tar.gz → 1.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.9
+Version: 1.1.1
 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.1}/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,10 +2150,12 @@ 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)
         focused_fit_condition = False
+        parameters = sum(w.size for w in self.layers[0].W) + sum(b.size for b in self.layers[0].b)
 
         AME = self.AME_Encoder(X)     
         AMR = 1.0 / (1.0 + np.exp(-float(AME)))
@@ -2160,7 +2168,7 @@ class MLP:
         if training_not_allowed:
             print(f'[!] MLP Training not allowed due to unsuitable data characteristics. Anisotropy: {anisotropy:.4f}, AME: {AME:.4f}')
         else:
-            print('[+] MLP Training started...')
+            print(f'[+] MLP Training started with: {parameters} Parameters.')
             for epoch in range(epochs):
                 if not focused_fit_condition:
                     y_pred = self.forward(X, AME=AME, anisotropy=anisotropy)
@@ -2168,6 +2176,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:
@@ -13102,41 +13111,65 @@ class IntegratedPipeline:
         return unsuitable_training
 
     def sequence_encoding(self, datasets=None, label_map=None, max_len=32):
+        if not datasets:
+            raise Warning('[!] Dataset is None or empty! Make sure you provide a dataset or create it automatically.')
+
+        if not self.model2:
+            intents = [d[1] for d in datasets]
+            intent_to_id = {intent: i for i, intent in enumerate(sorted(set(intents)))}
+            num_classes = self._get_num_classes(label_map=label_map)
+            self.model2 = Transformer(
+                vocab_size=len(self.vocab),
+                d_model=self.transformer_d_model,
+                n_heads=self.transformer_heads,
+                num_classes=num_classes
+            )
+
+        self._sync_vocab_to_embedding()   # once, not per-item
+
+        vocab_size = self.model2.token_embedding.shape[0]   # for bounds guard
+
         input_sequences = []
+        for item in datasets:
+            text = item[0] if isinstance(item, tuple) else item
 
-        if datasets:
-            for item in datasets:
-                if not self.model2:
-                    intents = [d[1] for d in datasets]
-                    intent_to_id = {intent:i for i, intent in enumerate(sorted(set(intents)))}
-                    num_classes = self._get_num_classes(label_map=label_map)                
-                    self.model2 = Transformer(
-                        vocab_size=len(self.vocab),
-                        d_model=self.transformer_d_model,
-                        n_heads=self.transformer_heads,
-                        num_classes=num_classes
-                    ) 
-                    
-                self._sync_vocab_to_embedding()
-                text = item[0] if isinstance(item, tuple) else item
+            token_ids = self.encode(text, self.vocab, max_len=max_len)
+            token_ids = np.asarray(token_ids)
 
-                token_ids = self.encode(text, self.vocab, max_len=max_len)
-                token_embs = self.model2.token_embedding[token_ids]         # (max_len, d_model)
-                pos_embs = self.model2.pos_embedding[:max_len]              # (max_len, d_model)
+            # bounds guard before indexing, with informative context
+            out_of_bounds = (token_ids < 0) | (token_ids >= vocab_size)
+            if out_of_bounds.any():
+                n_bad = out_of_bounds.sum()
+                print(f'[⚠️] sequence_encoding: {n_bad} token id(s) out of '
+                    f'range [0, {vocab_size}) for text="{str(text)[:50]}" '
+                    f'— clamping to valid range. This usually means vocab '
+                    f'grew after model2 was constructed; consider rebuilding '
+                    f'model2 or resizing token_embedding.')
+                token_ids = np.clip(token_ids, 0, vocab_size - 1)
+
+            token_embs = self.model2.token_embedding[token_ids]
+            pos_embs   = self.model2.pos_embedding[:max_len]
+
+            sequence_input = token_embs + pos_embs
+            input_sequences.append(sequence_input)
+
+        return np.stack(input_sequences)
 
-                sequence_input = token_embs + pos_embs
-                input_sequences.append(sequence_input)
-            return np.stack(input_sequences)  # shape: (batch, max_len, d_model)
-        else:
-            raise Warning('[!] Dataset is None! make sure you provide a dataset or create it Automatically!')
-            
-            return None
 
     def transformer_pooled_features(self, sequence_inputs):
-        # mean/max/std pooling over sequence dimension
+        """Mean/max/std pooling over the sequence dimension."""
+        sequence_inputs = np.asarray(sequence_inputs)
+
+        # guard degenerate single-timestep input, where std=0
+        # everywhere is mathematically correct.
+        if sequence_inputs.shape[1] == 1:
+            print('[=] transformer_pooled_features: single-timestep input, '
+                'std_pool will be all zeros (no variance across T=1)')
+
         mean_pool = np.mean(sequence_inputs, axis=1)
-        max_pool = np.max(sequence_inputs, axis=1)
-        std_pool = np.std(sequence_inputs, axis=1)
+        max_pool  = np.max(sequence_inputs, axis=1)
+        std_pool  = np.std(sequence_inputs, axis=1)
+
         return np.concatenate([mean_pool, max_pool, std_pool], axis=-1)
 
     def _features_to_sequence(self, X_provided, d_model=None, min_seq_len=2):
@@ -13242,6 +13275,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 +13361,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 +13434,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')
@@ -13401,6 +13487,16 @@ class IntegratedPipeline:
             else:
                 self.vocab_size = 1
 
+            onehot_validation = self._validate_onehot(y)
+            if onehot_validation:
+                if n_classes != len(label_map):
+                    n_classes = len(label_map)
+                if n_classes > np.max(y):
+                    y = np.eye(n_classes)[np.asarray(y)]
+                else:
+                    print('[⚠️] Warning: Y onehot encoding fails, Returning Y samples as is, This may cause Exploding Gradient in MLP Training!')
+                    y = y.copy()
+
             if self.model2 is None:
                 self.model2 = Transformer(
                     vocab_size=self.vocab_size,
@@ -13408,11 +13504,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 +17240,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 +17366,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)