AbstractIntegratedModule 1.1.6__tar.gz → 1.1.7.5__tar.gz

{abstractintegratedmodule-1.1.6 → abstractintegratedmodule-1.1.7.5}/AbstractIntegratedModule.egg-info/PKG-INFO

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

@@ -1499,6 +1499,8 @@ class Transformer:
             print(f'[!] Transformer Training not allowed due to low AMR or invalid value, AMR: {AMR}. Skipping training.')
             return None, None
 
+
+
     def train_step(self, input_ids, epoch, y_true, lr=0.01, AME=None,
                 mode=None, embedded=False, max_norm=1.0,
                 pad_token_id=0, y_true_smooth=None):
@@ -1843,7 +1845,7 @@ class Dense:
         return self.a
 
 
-    def backward(self, da, lr, clip_value=1.0):
+    def backward(self, da, lr, perf_score, clip_value=1.0):
         eps = 1e-5
         batch_size = self.x.shape[0]
 
@@ -1866,8 +1868,8 @@ class Dense:
             dW *= scale
             db *= scale
 
-        self.W -= lr * dW
-        self.b -= lr * db
+        self.W -= (lr * dW) 
+        self.b -= (lr * db) + (1.0 + perf_score) * 1e-5  # small bias regularization
 
         return dx
         
@@ -1903,6 +1905,9 @@ class MLP:
         self.pred_counts = None
         self.error_decay = None
 
+        self.temp_AME_sample = 0
+        self.temp_anisotropy_sample = 0
+
         self.softmax = SoftmaxOutput()
       
 
@@ -2015,27 +2020,8 @@ class MLP:
         return x
 
 
-    def _calibrate_gradient(self, grad, AME, anisotropy):
-        std = np.std(grad)
-        eps = 1e-5
-        calibration = grad.copy()
-
-        if std > 0.1:
-            AEL = (1.0 - AME) * anisotropy # abstraction enviromental limit
-            PRA = (1.0 - AEL) * std # possible reflected abstraction 
-
-            calibration = grad * AEL * PRA
-            calibration /= np.sum(calibration)
-
-        calibration = np.asarray(calibration, dtype=np.float64)
-        if np.isnan(calibration).any() or np.isinf(calibration).any():
-            calibration = grad.copy()
-
-        return calibration
-
 
-
-    def continuous_predictive_correction(self, manager, prob, predicted_index):
+    def continuous_predictive_correction(self, manager, prob, predicted_index, AME=None, anisotropy=None):
         eps = 1e-5
 
         error_counts = manager.error_counts
@@ -2055,6 +2041,7 @@ class MLP:
             self.pred_counts[predicted_index] += 1.0
             n_classes = len(label_map)
 
+            performance_score = self.performance_calculation(prob, AME=AME, anisotropy=anisotropy)
             self.pred_counts = self.pred_counts[0] if isinstance(self.pred_counts[0], np.ndarray) and self.pred_counts.ndim > 1 else self.pred_counts
             if len(self.pred_counts) != n_classes:
                 self.pred_counts = np.zeros(n_classes, dtype=np.float64)
@@ -2069,13 +2056,20 @@ class MLP:
                         # error_rate=0.0 → multiplier=1.0 (no change)
                         # error_rate=0.5 → multiplier≈0.67
                         # error_rate=1.0 → multiplier≈0.5
-                        reputation    = 1.0 / (1.0 + error_rate)
+                        small_reputation    = 1.0 / (1.0 + error_rate)
+                        weighted_reputation = small_reputation * performance_score
+
+                        reputation_growth = 1.0 / (1.0 + np.exp(-performance_score))
+                        compounding_factor = weighted_reputation * reputation_growth
+
                         if isinstance(error_rate, (list, np.ndarray)):
                             if len(error_rate) != len(prob):
-                                reputation = 1.0 / (1.0 + np.mean(error_rate))
+                                weighted_reputation = 1.0 / (1.0 + np.mean(error_rate))
 
                         if c < len(prob):
-                            prob[c]  *= reputation  
+                            prob[c]  *= small_reputation
+                        if c < len(self.pred_counts):
+                            self.pred_counts[c] *= compounding_factor
                     
             prob_sum = prob.sum()
             if prob_sum > 1e-8:
@@ -2097,16 +2091,19 @@ class MLP:
 
 
     def focused_backward(self, grad, lr, AME, anisotropy):
-          
         grad = self.softmax.backward(grad)
+        perf_score = self.performance_calculation(grad, AME=AME, anisotropy=anisotropy)
+
         for layer in reversed(self.feed_layers):
-            grad = layer.backward(grad, lr)
+            grad = layer.backward(grad, lr, perf_score)
         return grad  
 
     def backward(self, grad, lr):
         grad = self.softmax.backward(grad)
+        perf_score = self.performance_calculation(grad, AME=self.temp_AME_sample, anisotropy=self.temp_anisotropy_sample)
+
         for layer in reversed(self.layers):
-            grad = layer.backward(grad, lr)
+            grad = layer.backward(grad, lr, perf_score)
         return grad
             
     def predict(self, X, y, epochs=1000, verbose=True):
@@ -2210,7 +2207,10 @@ class MLP:
 
         AME = self.AME_Encoder(X)     
         AMR = 1.0 / (1.0 + np.exp(-float(AME)))
+
         anisotropy = self.anisotropy_measurement(X)
+        self.temp_AMR_sample = AMR
+        self.temp_anisotropy_sample = anisotropy
 
         focused_fit_condition = len(self.feed_layers) > 0 and anisotropy > 0.25 and AMR > 0.25 and len(X) < max_samples_for_focused_fit
         print(f'[+] Focused fit condition: {focused_fit_condition} || Anisotropy: {self.anisotropy_measurement(X):.4f} || AME: {self.AME_Encoder(X):.4f}')
@@ -2667,7 +2667,7 @@ class LSTMEngine:
             tanh_c = np.tanh(c)
             h      = o * tanh_c
 
-            # FIX 4 — precomputed inv_keep, inplace mask application
+            # precomputed inv_keep, inplace mask application
             mask = (np.random.rand(H) > p) * inv_keep
             h   *= mask
 
@@ -4032,6 +4032,9 @@ class ExplainabilityModule:
 
     def _learn_from_feedback(self, text, correct_label, wrong_result, batch_size=2):
         eps = 1e-5
+        min_signal = 1e-3
+        lr = 0.1
+
         print(f"\n[📚] Learning: '{text}' → {correct_label}...")
         
         # 1. Convert to features
@@ -4087,35 +4090,52 @@ class ExplainabilityModule:
         old_lr = self.pipeline.mlp.lr
         self.pipeline.mlp.lr = 2 / (1.0 + AEL) # use stable learning rate that match the environment complexity for correction
         print(f"[=] Training MLP on corrected example with boosted LR: {self.pipeline.mlp.lr}...")
-
-        # Train on this single example for a few epochs
-        self.pipeline.focused_mlp.train(X, y_onehot, epochs=1000, lr=self.pipeline.mlp.lr, verbose=True, max_samples_for_focused_fit=200)
-
-        self.pipeline.mlp.lr = old_lr  # Restore old LR
         
         # 4. train transformer for efficient processing later tho.
-        if self.pipeline.model2:
-            input_ids = np.array([self.pipeline.encode(text, self.pipeline.vocab)])
-            for _ in range(5):
-                self.pipeline.model2.train_step(input_ids, 0, y_onehot, lr=0.1, mode='fixed_backward')
+        sequence_inputs = self.pipeline._features_to_sequence(X, d_model=self.pipeline.transformer_d_model) 
+        should_train_transformer, _ = self.pipeline._should_train_transformer(sequence_inputs, X, min_seq_len=3, min_anisotropy=0.35, min_samples=10, ram_headroom_mb=80)   
+        if self.pipeline.model2 and self.pipeline.use_transformer and should_train_transformer:
+            transformer_features = self.pipeline.transformer_pooled_features(sequence_inputs)
+            X_features = np.concatenate([X, transformer_features], axis=-1)
+            x_conditional_anisotropy = self.anisotropy_measurement(sequence_inputs)
+            s_conditional_anisotropy = self.anisotropy_measurement(X_features)
+
+            AME_x = self.pipeline.AME_Encoder(X_raw)
+            AME_s = self.pipeline.AME_Encoder(sequence_inputs)
+            AMR_x = 1.0 / (1.0 + np.exp(-AME_x))
+            AMR_s = 1.0 / (1.0 + np.exp(-AME_s))
+
+            AMR_ratio = AMR_x / (AMR_s + min_signal)
+            AMR_ratio = AMR_x / (AMR_s + min_signal)
+            anisotropy_ratio = x_conditional_anisotropy / (s_conditional_anisotropy + min_signal)
+            dynamic_complex_environment = (anisotropy_ratio < 0.5 and 
+                                             AMR_ratio < 0.5)                                                         
+            if dynamic_complex_environment: 
+                print('[+] Dynamic Backward for Transformer Initiated')
+                mode = 'dynamic_backward'
+            else:
+                print('[=] Fixed Backward for Transformer initiated')
+                mode = 'fixed_backward'
+
+            self.pipeline.model2.train(sequence_inputs, y_onehot, epochs=self.pipeline.transformer_training_epochs, mode=mode, lr=lr, embedded=True, batch_size=2)
         
+        # Train on this single example for a few epochs
+        self.pipeline.model3.train(X_features, y_onehot, epochs=1000, lr=self.pipeline.mlp.lr, verbose=True, max_samples_for_focused_fit=200)
+        self.pipeline.model3.lr = old_lr  # Restore old LR
         # 5. Store in memory gate for fast retrieval
         self.pipeline.modular_prediction_saving(
             self.pipeline.encode(text, self.pipeline.vocab),
-            X,
+            X_features,
             correct_label
         )
-        
         # 6. Add to buffer for batch consolidation later.
-        self.feedback_buffer.append((X, y_onehot, text, correct_label))
+        self.feedback_buffer.append((X_features, y_onehot, text, correct_label))
         
         # 7. Batch train when buffer is full
         if len(self.feedback_buffer) >= self.buffer_size:
             print(f"\n[🔄] Buffer full with {len(self.feedback_buffer)} feedback examples. Starting batch training...")
             self._batch_train_from_feedback()
-        
         print(f"[✅] Learned: '{text}' → {correct_label} (model weights updated)")
-
         supervised_memory = {
             'input': text,
             'label': correct_label,
@@ -4123,19 +4143,17 @@ class ExplainabilityModule:
             'original_confidence': wrong_result['final_confidence'],
             'timestamp': datetime.now(),
             'learned': True
-
         }
 
         self.learned_from_feedback.append(supervised_memory)
         if hasattr(self.pipeline, 'memory'):
             print('[🔄] Applying correct label to pipelines memory')
             memory_key = f'supervised_memory'
-            self.pipeline.memory[memory_key] = (X, correct_label)
-
+            self.pipeline.memory[memory_key] = (X_features, correct_label)
         if len(self.learned_from_feedback) % 10 == 0:
             self.consolidate_supervised_memories(batch_size=batch_size)
 
-        return X
+        return X_features
     
     def _batch_train_from_feedback(self):
         if not self.feedback_buffer:
@@ -4166,15 +4184,11 @@ class ExplainabilityModule:
         y_batch = np.vstack(y_list)
 
         # Train MLP on batch
-        old_lr = self.pipeline.mlp.lr
-        self.pipeline.mlp.lr = old_lr * 2
-        for epoch in range(20):
-            y_pred = self.pipeline.mlp.forward(X_batch)
-            loss = Loss.categorical_crossentropy(y_batch, y_pred)
-            grad = Loss.softmax_crossentropy_derivative(y_batch, y_pred)
-            self.pipeline.mlp.backward(grad, self.pipeline.mlp.lr)
+        old_lr = self.pipeline.model3.lr
+        self.pipeline.model3.lr = old_lr * 2
+        self.pipeline.focused_mlp.train(X_batch, y_batch, epochs=1000, lr=self.pipeline.model3.lr, verbose=True, max_samples_for_focused_fit=200)
 
-        self.pipeline.mlp.lr = old_lr
+        self.pipeline.model3.lr = old_lr
         
         # Clear buffer
         self.feedback_buffer = []
@@ -4460,6 +4474,8 @@ class ExplainabilityModule:
     
     def _get_final_output(self, mlp_pred, mlp_conf, trans_pred, trans_conf, attn_weights):
         eps = 1e-5
+        consensus_conf = 0.0 
+
         if isinstance(mlp_conf, np.ndarray):
             mlp_conf = np.clip(np.mean(mlp_conf), 0, 1)
         if isinstance(trans_conf, np.ndarray):
@@ -4467,7 +4483,7 @@ class ExplainabilityModule:
 
         if mlp_pred == trans_pred:
             final_pred = mlp_pred
-            final_conf = max(mlp_conf, trans_conf)
+            consensus_conf = max(mlp_conf, trans_conf)
         else:
             sliced_attention_weight = attn_weights[0]
             if isinstance(sliced_attention_weight, np.ndarray):
@@ -4499,11 +4515,11 @@ class ExplainabilityModule:
             print('[=] Note: Very little Consistency meaning Transformer attention quality is Healthy and focused')
 
         if isinstance(consensus_conf, np.ndarray):
-            consensus_conf = 1.0 / (1.0 + np.exp(-final_conf))
+            consensus_conf = 1.0 / (1.0 + np.exp(-consensus_conf))
             # Apply a sigmoid transformation to ensure the confidence is between 0 and 1
 
         # averaged all confidences to get the final confidence.
-        final_conf = mlp_conf + trans_conf + final_conf / 3
+        final_conf = mlp_conf + trans_conf + consensus_conf / 3
         if np.isnan(final_conf).any() or np.isinf(final_conf).any():
             final_conf = self.pipeline.confidence_threshold
 
@@ -9664,7 +9680,7 @@ class IntegratedPipeline:
         self.external_peer_enabled = False
         self.autonomous = False 
         self.show_explainability_details = True    
-        self.froze_learning = False 
+        self.freeze_learning = False 
         self._cache_save_count = None
         self._prob_save_count = None
 
@@ -13018,6 +13034,7 @@ class IntegratedPipeline:
         return cached_X, cached_Y
 
 
+
     def _get_last_scalar(self, arr):
         """
         Extract the scalar value from the LAST timestep, robust to
@@ -13248,6 +13265,7 @@ class IntegratedPipeline:
         self.cache['lstm_result'] = result
         self.cache['label_bins'] = label_bins
 
+
     # necessary functions to reduce wasteful training in similar scarce environment
     def training_necessary_condition(self, input_ids, x):
         eps = 1e-5
@@ -13279,7 +13297,7 @@ class IntegratedPipeline:
         # (not too high that it shows unstability, not too low that it shows rigidity), high anisotropy correlates to a much complex non linearity that the model will have a hard time adjusting
         # Too high AAC means the model is likely to be in a regime where training could lead to overfitting or divergence due to insufficient modelling capacity relative to the complexity of the data, especially if the confidence score is also low, indicating that the model is not currently confident in its predictions and may not benefit from further training on this data.
         unsuitable_tolerance = probs is not None and cached or AAC > 0.75
-        unsuitable_conditions = anisotropy > 0.85 or final_conf > confidence_threshold or self.froze_learning
+        unsuitable_conditions = anisotropy > 0.85 or final_conf > confidence_threshold or self.freeze_learning
         unsuitable_peer_request = probs is not None and self.peer_assistance_threshold > self.confidence_threshold
 
         self.unsuitable_tolerance = unsuitable_tolerance
@@ -13302,7 +13320,6 @@ class IntegratedPipeline:
             raise Warning('[!] Dataset is None or empty! Make sure you provide a dataset or create it automatically.')
 
         if not self.model2:
-            print(datasets)
             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)
@@ -13375,6 +13392,7 @@ class IntegratedPipeline:
                                 .replace('...', '').replace(',', ' ').strip())
             skip = {"nan", "null", "none", "inf", "-inf", "infinity", ""}
             vals = []
+
             for tok in clean_str.split():
                 if tok.lower() in skip:
                     vals.append(0.0)
@@ -13685,9 +13703,6 @@ class IntegratedPipeline:
                     print(f'[= ! =] High zero-row ratio ({weak_ratio:.0%}), refitting on current batch')
                     self.tfidf.fit(X_raw_generation)
                     X_raw_features = self.tfidf.transform(X_raw_generation).toarray()  
-
-            transformer_features = self.transformer_pooled_features(sequence_inputs)
-            X_raw_features = np.concatenate([X_raw_features, transformer_features], axis=-1)
             
             zero_rows = np.where(X_raw_features.sum(axis=1) == 0)[0]
             if len(zero_rows) > 0:
@@ -13695,6 +13710,7 @@ class IntegratedPipeline:
                 for i in zero_rows:
                     text = X_raw[i] if isinstance(X_raw[i], str) else str(X_raw[i])
                     checksum = int(hashlib.md5(text.encode()).hexdigest(), 16)
+
                     # distribute checksum signal across feature dims
                     rng = np.random.default_rng(checksum)
                     X_raw_features[i] = rng.uniform(0.01, 0.1, size=X_raw_features.shape[1])  
@@ -13755,14 +13771,17 @@ class IntegratedPipeline:
                     n_heads=self.transformer_heads,
                     num_classes=n_classes
                 )
-
-            should_train_transformer, reason = self._should_train_transformer(sequence_inputs, X_raw, min_seq_len=3, min_anisotropy=0.35, min_samples=10, ram_headroom_mb=max_ram_used)   
+                
+            should_train_transformer, reason = self._should_train_transformer(sequence_inputs, X_raw, min_seq_len=3, min_anisotropy=0.35, min_samples=10, ram_headroom_mb=max_ram_used)                  
             if self.use_transformer and should_train_transformer:
                 print(f'[=] Transformer Training allowed, Reason: {reason}')
                 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)      
 
+            if should_train_transformer:      
+                transformer_features = self.transformer_pooled_features(sequence_inputs)
+                hybrid_X = np.concatenate([hybrid_X, transformer_features], axis=-1)  
+
+            X = self.shape_adaptation(hybrid_X, input_dim)      
             self.initialize_model_(X, input_dim, n_classes)
             if not unsuitable:
                 self.model3.train(X, y, epochs=self.mlp_training_epochs, lr=self.mlp_lr, max_samples_for_focused_fit=max_samples_for_focused_fit)
@@ -16843,28 +16862,6 @@ class PipelinePredictionManager:
                     accuracy = correct_count / len(results)
                     print(f"\n📊 Accuracy: {correct_count}/{len(results)} = {accuracy:.1%}")
 
-                try:
-                    joblib.dump(self.pipeline, 'modular_agent.pkl')
-                    print('💾  Model saved!')
-                except Exception as e:
-                    print(f'|| Failed to joblib dump file! : {e}, User Manual filepath suggestion needed...')
-
-                    try:
-                        permission = input('|| Insert Filepath? [Y/N]: ')
-                        if permission == 'Y':
-                            suggested_path = input('|| Filepath suggestion: ')
-                            if suggested_path:
-                                self.pipeline.safe_pickle_save_with_feedback(self.pipeline, suggested_path)
-                                print('💾  Model saved!')                
-                            else:
-                                print('|| Failed to dump Your model! ')
-                                pass
-                        else:
-                            print('|| Failed to dump Your model! ')
-                            pass  
-                    except EOFError as e:
-                        print('[!] EOF Error from reading a line!')
-
             verbose = False
             if float(results[0]['confidence']) < self.pipeline.confidence_threshold:
                 verbose = True
@@ -17499,6 +17496,7 @@ class PipelinePredictionManager:
 
         return need_ensemble
 
+
     def _check_for_transformer_sequences(self, sequence_inputs, min_seq_len=3, 
                                 min_samples=10,  min_AME=0.5, min_anisotropy=0.5):
         score = 0
@@ -17819,7 +17817,7 @@ class PipelinePredictionManager:
                     target_probs = mlp_probs.copy()
            
                 target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
-                target_probs = self.pipeline.model3.continuous_predictive_correction(self, target_probs, mlp_pred_indices)  
+                target_probs = self.pipeline.model3.continuous_predictive_correction(self, target_probs, mlp_pred_indices, AME=AME, anisotropy=anisotropy)  
             
             target_pred_indices = np.argmax(target_probs, axis=1)