AbstractIntegratedModule 0.6.2__tar.gz → 0.6.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.6.2
+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.2 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,10 +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.2:
+     - v0.6.3:
           - [=] New features: 
           - 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.2 → abstractintegratedmodule-0.6.3}/AbstractIntegratedModule.py

@@ -2044,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
@@ -2065,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]
@@ -2253,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:]
 
@@ -2270,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
@@ -2288,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}")
@@ -2404,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)
@@ -2471,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("  └─────────────────────────────────────────┘")