AbstractIntegratedModule 0.6.1__tar.gz → 0.6.3__tar.gz

{abstractintegratedmodule-0.6.1 → abstractintegratedmodule-0.6.3/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.6.1
+Version: 0.6.3
 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.1 Official Release.
+- Development Stage: 0.6.3 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,11 +67,11 @@ 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.1:
+     - v0.6.3:
           - [=] New features: 
-          - 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.
-          - Fixed bug in advanced prediction block that caused lstm weights to be set None.
+          - 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.
+          - Ensure Robustness in LSTM Training step to prevent division by zero.
       
 -----
 

{abstractintegratedmodule-0.6.1 → abstractintegratedmodule-0.6.3}/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:
@@ -2019,6 +2044,8 @@ class LSTMEngine:
 
     # ── MC dropout forward ────────────────────
     def _mc_forward(self, x_seq: np.ndarray) -> np.ndarray:
+
+        eps = 1e-5
         T            = x_seq.shape[0]
         H            = self.model.cell.hidden_size
         expected_input = self.model.cell.input_size
@@ -2040,7 +2067,7 @@ class LSTMEngine:
         preds = np.empty(T)                   # preallocate output
 
         # precompute dropout scale factor
-        inv_keep = 1.0 / (1.0 - p)
+        inv_keep = 1.0 / (1.0 - p) + eps
 
         for t in range(T):
             x = x_seq[t]
@@ -2228,12 +2255,16 @@ class LSTMEngine:
     # LSTM training loop with confidence layers integrated into the loss and validation monitoring.
     def fit_stm(self, X, Y, epochs=50, hidden=32, lr=5e-3, seq_len=20, print_every=5):
         print("[= =] Training LSTM with confidence layers (MC dropout + gate uncertainty + prediction intervals)")
-   
+
+        eps = 1e-3
         model   = self.model
         AME = self.pipeline.AME_Encoder(X)
         AMR = 1.0 / (1.0 + np.exp(-AME))
 
         n_train = int((1.0 - AMR) * len(X))
+        if np.isnan(n_train) or np.isinf(n_train) or n_train <= eps:
+            n_train = self.pipeline.confidence_threshold + eps
+            
         X_tr, Y_tr = X[:n_train], Y[:n_train]
         X_te, Y_te = X[n_train:], Y[n_train:]
 
@@ -2245,7 +2276,7 @@ class LSTMEngine:
             for j in idx:
                 loss, _ = model.train_step(X_tr[j], Y_tr[j], lr=lr, AMR=AMR)
                 epoch_loss += loss
-            epoch_loss /= n_train
+            epoch_loss /= n_train + eps
 
             if epoch % print_every == 0 or epoch == 1:
                 # validation
@@ -2263,7 +2294,10 @@ class LSTMEngine:
                     Y_te = Y_te[:preds.shape[0], :preds.shape[1]]
                     preds = preds[:Y_te.shape[0], :Y_te.shape[1]]   
 
-                    val_loss += AMR * np.mean((preds - Y_te[j]) ** 2)
+                    val_loss += AMR * np.mean((preds - Y_te[j]) ** 2) 
+                    # calculates how much value loss when multiplied by model error rate 
+                    # to gain how much the model can greatly applied its losses efficiently vs the possible error rate during prediction.
+                    # Higher val_loss correlates to the model possible bad predicted capabilities in the future Training 
                 val_loss /= len(X_te)
                 print(f"[=] Epoch {epoch:>4}/{epochs}  "
                     f"[=] train_loss={epoch_loss:.6f}  val_loss={val_loss:.6f}")
@@ -2379,6 +2413,9 @@ class LSTMEngine:
         AMR = 1.0 / (1.0 + np.exp(-AME))  # abstract modelling rate
         point = preds_clean[:, 0]   # (T,)
 
+        if np.isnan(AMR) or np.isinf(AMR) or AMR <= 1e-10:
+            AMR = self.pipeline.confidence_threshold + 1e-5
+
         # ── MC dropout sampling ───────────────
         samples = np.stack([
             self._mc_forward(x_seq) for _ in range(self.n_samples)
@@ -2446,12 +2483,12 @@ class LSTMEngine:
         print("\n┌─────────────────────────────────────────┐")
         print("  │          LSTM Architecture Summary      │")
         print("  ├─────────────────────────────────────────┤")
-        print(f" │  Input  size   : {I:<24}│")
-        print(f" │  Hidden size   : {H:<24}│")
-        print(f" │  Output size   : {O:<24}│")
-        print(f" │  LSTM   params : {W_params:<24,}│")
-        print(f" │  Linear params : {Wy_params:<24,}│")
-        print(f" │  Total  params : {total:<24,}│")
+        print(f" │  Input  size   : {I:<24}                │")             
+        print(f" │  Hidden size   : {H:<24}                │")
+        print(f" │  Output size   : {O:<24}                │")
+        print(f" │  LSTM   params : {W_params:<24,}        │")
+        print(f" │  Linear params : {Wy_params:<24,}       │")
+        print(f" │  Total  params : {total:<24,}           │")
         print("  └─────────────────────────────────────────┘")