AbstractIntegratedModule 1.1.0__tar.gz → 1.1.1__tar.gz

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

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

@@ -2155,6 +2155,7 @@ class MLP:
         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)))
@@ -2167,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)
@@ -13110,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):
@@ -13462,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,