AbstractIntegratedModule 0.6.0__tar.gz → 0.6.2__tar.gz

{abstractintegratedmodule-0.6.0 → abstractintegratedmodule-0.6.2/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.6.0
+Version: 0.6.2
 Summary: Library for Advanced Integrated Non-LLM AI Models - Optimized Backend Framework For Non-LLM AI Agent
 Author: Micro-Novelty
 Author-email: hernikpuspita5@gmail.com
@@ -42,7 +42,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
 #### Note: The README here you are reading is a direct copy from my README Repository, to download the necessary files, you can visit my Repository with the provided link above.
 
 ### Library Short Description:
-- Development Stage: 0.6.0 Official Release.
+- Development Stage: 0.6.2 Official Release.
 - Maintainer: Micro-Novelty.
 - library Source-Code is Open-sourced on github.
 - Purpose: Specifically Designed for providing Non-LLM AI Agent Framework for edge Devices, Optimized for ARM64 architecture.
@@ -67,14 +67,10 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
    - Transformer Modules Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage, With Reduced Training Time.
 - Changelog:
-     - v0.6.0:
+     - v0.6.2:
           - [=] New features: 
-          - Added Anisotropy measurement optimization in Cython to handle complex logic.
-          - Added Cython softmax for Transformer to reduce CPU consumption.
-          - Added Cython Cosine similarity to reduce ensemble prediction time needed for prediction.
-          - Added safety guards for Cosine similarity to prevent string arrays to cause further errors.
-          - Refined csv load labels function to accept path dir, so users can finnaly find their Training labels without much restrictions and errors.
-
+          - Ensure proper shape handling before shape alignment in Transformer Training.
+          - Fixed Silent bugs that can cause single scalar to bypass shape conditions gate in training step for Transformer.
       
 -----
 

{abstractintegratedmodule-0.6.0 → abstractintegratedmodule-0.6.2}/AbstractIntegratedModule.py

@@ -1226,8 +1226,6 @@ class Transformer:
 
         AME = self.AME_Encoder(input_ids_list)
 
-
-
         # precompute LR schedule once
         lr_schedule = [
             self.learning_rate_warm_up(e, epochs, lr, schedule)
@@ -1237,24 +1235,36 @@ class Transformer:
         print(f"[==] Starting comprehensive training for {epochs} epochs with mode: {mode}, learning rate: {lr}, schedule: {schedule}")
 
         for y in y_true_list:
-            y_arr = np.asarray(y)
-            if y_arr.ndim == 1:
-                y_arr = y_arr[np.newaxis, :]
+            y_arr = np.asarray(y, dtype=np.float64)
+
+            # normalize to exactly 2D before smoothing
+            if y_arr.ndim == 0:
+                y_arr = y_arr.reshape(1, 1)
+            elif y_arr.ndim == 1:
+                y_arr = y_arr.reshape(1, -1)
+            elif y_arr.ndim > 2:
+                y_arr = y_arr.reshape(-1, y_arr.shape[-1])
+
             smoothed = self.smoothing_labels_utility(y_arr, smoothing=0.1)
-            # guarantee 2D output
-            while smoothed.ndim > 2:
-                smoothed = smoothed.squeeze(0)
+
+            # guarantee 2D output regardless of what smoothing returns
+            smoothed = np.asarray(smoothed, dtype=np.float64)
+            if smoothed.ndim == 0:
+                smoothed = smoothed.reshape(1, 1)
+            elif smoothed.ndim == 1:
+                smoothed = smoothed.reshape(1, -1)
+            elif smoothed.ndim > 2:
+                smoothed = smoothed.reshape(-1, smoothed.shape[-1])
+
             y_true_smoothed_list.append(smoothed)
 
         for epoch in range(epochs):
             epoch_losses = []
             epoch_accs   = []
-
-            # FIX 2 — lookup instead of compute
+        
             current_lr = lr_schedule[epoch]
             self.alpha = min(1.0, epoch / 100)
 
-            # FIX 1 — pass precomputed smooth labels
             for input_ids, y_true, y_true_smooth in zip(
                 input_ids_list, y_true_list, y_true_smoothed_list
             ):
@@ -1283,10 +1293,9 @@ class Transformer:
 
         return losses, accs
 
-
     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):   
+                pad_token_id=0, y_true_smooth=None):
 
         y_true = np.asarray(y_true)
         if len(y_true.shape) < 2:
@@ -1304,25 +1313,41 @@ class Transformer:
             ffn_dropout=self.ffn_dropout_rate
         )
 
-        # only compute if not precomputed
+        # comprehensive shape normalization before any use
         if y_true_smooth is not None:
-            y_true_smooth = np.asarray(y_true_smooth)
-            # squeeze out any extra leading dimensions
+            y_true_smooth = np.asarray(y_true_smooth, dtype=np.float64)
+
+            # handle 0-d scalar — expand to (1, 1)
+            if y_true_smooth.ndim == 0:
+                print(f'[!] y_true_smooth was scalar ({float(y_true_smooth):.4f}) — recomputing')
+                y_true_smooth = self.smoothing_labels_utility(y_true, smoothing=0.1)
+
+            # squeeze extra leading dims safely
             while y_true_smooth.ndim > 2:
                 y_true_smooth = y_true_smooth.squeeze(0)
+
             # ensure at least 2D
             if y_true_smooth.ndim == 1:
                 y_true_smooth = y_true_smooth[np.newaxis, :]
 
-        # shape alignment 
-        if y_true_smooth.shape[0] and y_true_smooth.shape[1] != probs.shape[1]:
+            # final sanity — if still not 2D something is deeply wrong
+            if y_true_smooth.ndim != 2:
+                print(f'[!] y_true_smooth shape {y_true_smooth.shape} unrecoverable — recomputing')
+                y_true_smooth = self.smoothing_labels_utility(y_true, smoothing=0.1)
+
+        else:
+            # compute fresh
+            y_true_smooth = self.smoothing_labels_utility(y_true, smoothing=0.1)
+
+        # shape alignment, y_true_smooth guaranteed 2D
+        if y_true_smooth.shape[1] != probs.shape[1]:
             if y_true_smooth.shape[1] > probs.shape[1]:
                 y_true_smooth = y_true_smooth[:, :probs.shape[1]]
                 y_true        = y_true[:, :probs.shape[1]]
             else:
-                pad = probs.shape[1] - y_true_smooth.shape[1]
-                y_true_smooth = np.pad(y_true_smooth, ((0,0),(0,pad)))
-                y_true        = np.pad(y_true,        ((0,0),(0,pad)))
+                pad           = probs.shape[1] - y_true_smooth.shape[1]
+                y_true_smooth = np.pad(y_true_smooth, ((0, 0), (0, pad)))
+                y_true        = np.pad(y_true,        ((0, 0), (0, pad)))
 
         loss     = -np.mean(np.sum(y_true_smooth * np.log(probs + 1e-8), axis=1))
         d_logits = (probs - y_true_smooth) / y_true_smooth.shape[0]
@@ -1334,11 +1359,11 @@ class Transformer:
 
         preds = np.argmax(probs, axis=1)
         true  = np.argmax(y_true, axis=1)
-        acc   = np.mean(preds == true)
+        acc   = float(np.mean(preds == true))
 
         return loss, acc
 
-    
+
 
     def predict(self, input_ids, embedded=False):
         if not embedded and input_ids.ndim == 1:
@@ -12969,7 +12994,7 @@ class PipelinePredictionManager:
                     calibration_weighting = calibration[target_class_idx] if target_class_idx < len(calibration) else 0.0
                         
                     # Weighted blend: calibration_weighting * calibrated + (1-weight) * mlp
-                    if lstm_weight is not None:
+                    if lstm_confidence is not None and lstm_weight is not None:
                         final_probs = mlp_weight * target_probs[i][:len(calibration)] + trans_weight * calibration[i][:len(calibration)] + lstm_weight * calibration[i][:len(calibration)]
                     else:
                         final_probs = mlp_weight * target_probs[i][:len(calibration)] + trans_weight * calibration[i][:len(calibration)]