AbstractIntegratedModule 0.4.0__tar.gz → 0.4.2__tar.gz

{abstractintegratedmodule-0.4.0 → abstractintegratedmodule-0.4.2/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.4.0
+Version: 0.4.2
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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: Beta, 0.4.0.
+- Development Stage: Beta, 0.4.2.
 - 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.
@@ -62,11 +62,11 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Proven Works on ARM64 Environment, Training and Prediction works efficient on Docker ARM64 environment with QEMU, good parallelizing behavior is guaranteed.
    - P2P Works efficiently in ARM64 Docker + QEMU, No conflicting socket and all prediction works efficiently.
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
-
+   - LSTM is Optimized efficiently for scarce data with AWE method.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />
-[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
+
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.4.0 → abstractintegratedmodule-0.4.2}/AbstractIntegratedModule.py

@@ -1442,96 +1442,101 @@ class LSTMCell:
     def _g(self, v): return v[2*self.hidden_size:3*self.hidden_size]
     def _o(self, v): return v[3*self.hidden_size:]
 
-
-    # ── forward ──────────────────────────────
+    # _________ forward method for cell class _____________
     def forward(self, x_seq: np.ndarray, h0=None, c0=None):
-        """
-        x_seq : (T, input_size)
-        returns: hs (T, hidden), cs (T, hidden), cache (for BPTT)
-        """
-        T = x_seq.shape[0]
-        H = self.hidden_size
+        T              = x_seq.shape[0]
+        H              = self.hidden_size
         expected_input = self.input_size
 
         h = np.zeros(H) if h0 is None else h0.copy()
         c = np.zeros(H) if c0 is None else c0.copy()
 
-        hs, cs = np.zeros((T, H)), np.zeros((T, H))
-        cache  = []   # store everything needed for backward
+        hs    = np.zeros((T, H))
+        cs    = np.zeros((T, H))
+        cache = []
+
+        # preallocate xh buffer once
+        xh = np.empty(expected_input + H)
 
         for t in range(T):
-            x  = x_seq[t]
+            x = x_seq[t]
             if x.ndim == 0:
-                x = x.reshape(1)                          # fix zero-dimensional
+                x = x.reshape(1)
             if x.shape[0] < expected_input:
-                x = np.pad(x, (0, expected_input - x.shape[0]))   # pad if too small
+                x = np.pad(x, (0, expected_input - x.shape[0]))
             elif x.shape[0] > expected_input:
-                x = x[:expected_input]                    # truncate if too large
-           
-            xh = np.concatenate([x, h])           # (input+hidden,)
+                x = x[:expected_input]
+
+            # write into buffer, no allocation
+            xh[:expected_input] = x
+            xh[expected_input:] = h
+
+            z      = self.W @ xh + self.b
+            H1, H2, H3 = H, H * 2, H * 3
 
-            z  = self.W @ xh + self.b             # (4H,)
-            f  = sigmoid(self._f(z))              # forget
-            i  = sigmoid(self._i(z))              # input
-            g  = np.tanh(self._g(z))              # candidate
-            o  = sigmoid(self._o(z))              # output
+            # direct slices, no method calls
+            f      = sigmoid(z[:H1])
+            i      = sigmoid(z[H1:H2])
+            g      = np.tanh(z[H2:H3])
+            o      = sigmoid(z[H3:])
 
-            c_new = f * c + i * g
+            c_new  = f * c + i * g
             tanh_c = np.tanh(c_new)
-            h_new = o * tanh_c
+            h_new  = o * tanh_c
 
-            cache.append((x, h, c, f, i, g, o, c_new, tanh_c, xh))
+            # store copies — h/c will be overwritten next iteration 
+            cache.append((x.copy(), h.copy(), c.copy(),
+                        f, i, g, o, c_new, tanh_c, xh.copy()))
             h, c = h_new, c_new
-            hs[t], cs[t] = h, c
+            hs[t] = h
+            cs[t] = c
 
         return hs, cs, cache
 
-    # ── backward (BPTT) ──────────────────────
-    def backward(self, dhs: np.ndarray, cache, dh_next=None, dc_next=None):
-        """
-        dhs : (T, hidden)  — gradient of loss w.r.t. each hidden state
-        Returns: gradients dict + dx_seq
-        """
-        T = len(cache)
+    # ________ backward method for Cell class __________
+    def backward(self, dhs: np.ndarray, cache,
+                dh_next=None, dc_next=None, T_limit=None):
+        # T_limit avoids slicing cache list externally
+        T = T_limit if T_limit is not None else len(cache)
         H = self.hidden_size
 
-        dW  = np.zeros_like(self.W)
-        db  = np.zeros_like(self.b)
-        dh  = np.zeros(H) if dh_next is None else dh_next.copy()
-        dc  = np.zeros(H) if dc_next is None else dc_next.copy()
+        dW     = np.zeros_like(self.W)
+        db     = np.zeros_like(self.b)
+        dh     = np.zeros(H) if dh_next is None else dh_next.copy()
+        dc     = np.zeros(H) if dc_next is None else dc_next.copy()
         dx_seq = np.zeros((T, self.input_size))
 
+        # preallocate dz buffer once
+        dz     = np.empty(4 * H)
+        H1, H2, H3 = H, H * 2, H * 3
+
         for t in reversed(range(T)):
             x, h_prev, c_prev, f, i, g, o, c_new, tanh_c, xh = cache[t]
 
-            dh_total = dhs[t] + dh   # gradient from loss + recurrence
+            dh_total = dhs[t] + dh
 
-            # output gate
             do     = dh_total * tanh_c
             dtanhc = dh_total * o
-
-            # cell state
             dc_new = dtanhc * tanh_deriv(tanh_c) + dc
 
-            # gates
             df = dc_new * c_prev
             di = dc_new * g
             dg = dc_new * i
-            dc = dc_new * f           # flows back to previous cell state
-
-            # pre-activation gradients
-            df_pre = df * sigmoid_deriv(f)
-            di_pre = di * sigmoid_deriv(i)
-            dg_pre = dg * tanh_deriv(g)
-            do_pre = do * sigmoid_deriv(o)
+            dc = dc_new * f
 
-            dz = np.concatenate([df_pre, di_pre, dg_pre, do_pre])
+            # write into preallocated dz buffer
+            dz[:H1]  = df * sigmoid_deriv(f)
+            dz[H1:H2] = di * sigmoid_deriv(i)
+            dz[H2:H3] = dg * tanh_deriv(g)
+            dz[H3:]   = do * sigmoid_deriv(o)
 
-            dW  += np.outer(dz, xh)
+            # nplace accumulation, no intermediate allocation
+            dW  += np.outer(dz, xh)   # unavoidable alloc but outer is C-level
             db  += dz
-            dxh  = self.W.T @ dz
-            dx_seq[t] = dxh[:self.input_size]
-            dh   = dxh[self.input_size:]
+
+            dxh        = self.W.T @ dz
+            dx_seq[t]  = dxh[:self.input_size]
+            dh         = dxh[self.input_size:]
 
         return {"dW": dW, "db": db}, dx_seq, dh, dc
 
@@ -1539,83 +1544,77 @@ class LSTMCell:
 # ─────────────────────────────────────────────
 #  LSTM Network (cell + linear output head)
 # ─────────────────────────────────────────────
-
 class LSTMNetwork:
-    """
-    One LSTM layer + a linear output projection.
-    input_size  → hidden_size  → output_size
-    """
-
     def __init__(self, pipeline, input_size, hidden_size, output_size, seed=0):
-        self.cell = LSTMCell(input_size, hidden_size, seed)
-        H = hidden_size      
-
-        self.weight_shaper = GeometricWeightShaping(output_size, H)         
-        self.Wy = None
-        self.by = np.zeros(output_size)
-        self.pipeline = pipeline
-
+        self.cell         = LSTMCell(input_size, hidden_size, seed)
+        self.weight_shaper = GeometricWeightShaping(output_size, hidden_size)
+        self.Wy           = None
+        self.by           = np.zeros(output_size)
+        self.pipeline     = pipeline
+        self._trained     = False
+
+    # forward method to calculate proper weight for prediction and training.
     def forward(self, x_seq):
+        # also Wy init only here, removed from train_step
         if self.Wy is None:
             self.Wy = self.weight_shaper.weight_shaping(x_seq)
-
         hs, cs, cache = self.cell.forward(x_seq)
-        # linear projection at every timestep
-        preds = hs @ self.Wy.T + self.by        # (T, output_size)
+        preds = hs @ self.Wy.T + self.by   # (T, output_size)
         return preds, hs, cs, cache
 
+    # calculate loss of MSE (Mean squared error.)
     def loss_mse(self, preds, targets, AMR):
-        if preds.shape != targets.shape:
-            if preds.shape[0] > targets.shape[0]:
-                targets = targets[:preds.shape[0], :]
-            if targets.shape[0] > preds.shape[0]:
-                preds = preds[:targets.shape[0], :]
-            else:
-                preds = preds[:targets.shape[0], :targets.shape[1]]
-        
+        # proper and correct shape alignment
+        min_T = min(preds.shape[0], targets.shape[0])
+        min_F = min(preds.shape[1], targets.shape[1])
+        preds   = preds[:min_T, :min_F]
+        targets = targets[:min_T, :min_F]
+
         diff = preds - targets
-        return AMR * np.mean(diff ** 2), diff / len(diff)
+        loss = (1.0 - AMR) * np.mean(diff ** 2)
+        dloss = diff / (min_T * min_F)   # FIX 3 — normalize by full element count
+        return loss, dloss
 
+    # backward method for the network to calculate proper weights with cell backward
     def backward(self, dpreds, hs, cache):
-        # gradient through linear head
-        min_T    = min(dpreds.shape[0], hs.shape[0])
-        dpreds   = dpreds[:min_T, :]    # (min_T, out)
-        hs       = hs[:min_T, :]        # (min_T, hidden)
+        min_T  = min(dpreds.shape[0], hs.shape[0])
+        dpreds = dpreds[:min_T]
+        hs     = hs[:min_T]
 
-        dWy = dpreds.T @ hs                     # (out, hidden)
+        dWy = dpreds.T @ hs
         dby = dpreds.sum(axis=0)
-        dhs = dpreds @ self.Wy                  # (T, hidden)
+        dhs = dpreds @ self.Wy
 
-        cell_grads, dx, _, _ = self.cell.backward(dhs, cache[:min_T])
+        # pass min_T directly, need to avoid creating a sliced list
+        cell_grads, dx, _, _ = self.cell.backward(dhs, cache, T_limit=min_T)
         return cell_grads, {"dWy": dWy, "dby": dby}, dx
 
+    # update ensured proper gradient clipping
     def update(self, cell_grads, out_grads, lr=1e-3, clip=5.0):
-        """SGD with gradient clipping."""
         def clip_and_step(param, grad):
-            grad = np.clip(grad, -clip, clip)
+            np.clip(grad, -clip, clip, out=grad)  
             param -= lr * grad
 
-        clip_and_step(self.cell.W,  cell_grads["dW"])
-        clip_and_step(self.cell.b,  cell_grads["db"])
-        clip_and_step(self.Wy,      out_grads["dWy"])
-        clip_and_step(self.by,      out_grads["dby"])
+        clip_and_step(self.cell.W, cell_grads["dW"])
+        clip_and_step(self.cell.b, cell_grads["db"])
+        clip_and_step(self.Wy,     out_grads["dWy"])
+        clip_and_step(self.by,     out_grads["dby"])
 
-    def train_step(self, x_seq, targets, lr=1e-3):
-        if self.Wy is None:
-            self.Wy = self.weight_shaper.weight_shaping(x_seq)
+    # train step for each LSTM fitting method 
+    def train_step(self, x_seq, targets, lr=1e-3, AMR=None):
+        # accept precomputed AMR 
+        if AMR is None:
+            AME = self.pipeline.AME_Encoder(x_seq)
+            AMR = 1.0 / (1.0 + np.exp(-AME))
 
         preds, hs, cs, cache = self.forward(x_seq)
-
-        AME = self.pipeline.AME_Encoder(x_seq)
-        AMR = 1.0 / (1.0 + np.exp(-AME))
-
-        loss, dloss = self.loss_mse(preds, targets, AMR)
+        loss, dloss          = self.loss_mse(preds, targets, AMR)
         cell_grads, out_grads, _ = self.backward(dloss, hs, cache)
         self.update(cell_grads, out_grads, lr)
-
         return loss, preds
 
 
+
 # ─────────────────────────────────────────────
 #  LSTM Engine
 # ─────────────────────────────────────────────
@@ -1654,147 +1653,265 @@ class LSTMEngine:
         self.residual_mean = None
 
     # ── calibrate on validation set ──────────
-    def calibrate(self, X_val, Y_val):
-        """
-        Collect residuals on clean (no-dropout) val predictions.
-        Must be called before predict().
-        """
-        residuals = []
+    def calibrate_residual(self, X_val, Y_val):
+        if len(X_val) == 0:
+            self.residual_mean = 0.0
+            self.residual_std  = 1.0
+            return
+
+        confidence_errors = []
+
         for j in range(len(X_val)):
             preds, _, _, _ = self.model.forward(X_val[j])
-            err = (preds[:, 0] - Y_val[j, :, 0])
-            residuals.extend(err.tolist())
 
-        residuals = np.array(residuals)
-        self.residual_mean = residuals.mean()
-        self.residual_std  = residuals.std()
+            pred_vals = preds[:, 0] if preds.ndim > 1 else preds
+
+            # get true class
+            true_vals = Y_val[j, :, 0] if Y_val[j].ndim > 1 else Y_val[j]
+            min_len   = min(len(pred_vals), len(true_vals))
+
+            # sigmoid to get predicted probability
+            pred_prob = 1.0 / (1.0 + np.exp(-pred_vals[:min_len]))
+            true_bin  = true_vals[:min_len].astype(float)
+
+            # confidence error — how wrong was the predicted probability
+            # correct prediction   → low error
+            # wrong prediction     → high error
+            err = np.abs(pred_prob - true_bin)
+            confidence_errors.extend(err.tolist())
+
+        errors = np.array(confidence_errors)
+
+        # IQR outlier removal
+        q25, q75     = np.percentile(errors, [25, 75])
+        iqr          = q75 - q25
+        mask         = (errors >= q25 - 1.5 * iqr) & (errors <= q75 + 1.5 * iqr)
+        clean        = errors[mask] if mask.sum() > 0 else errors
+
+        self.residual_mean = float(clean.mean())
+        self.residual_std  = float(max(clean.std(), 1e-6))
+
+        # floor std on small n — can't trust calibration with few samples
+        if len(X_val) < 20:
+            self.residual_std = max(self.residual_std, 0.1)
+            print(f'[!] Small val set ({len(X_val)} samples) — flooring σ to 0.1')
+
+        self.calibration_coverage   = float(mask.mean())
+        self.n_calibration_samples  = len(X_val)
+
         print(f"[=] Calibrated: residual μ={self.residual_mean:.4f} "
-              f"[=] σ={self.residual_std:.4f}")
+            f"σ={self.residual_std:.4f} "
+            f"coverage={self.calibration_coverage:.1%} "
+            f"n={self.n_calibration_samples}")
+
 
     # ── MC dropout forward ────────────────────
-    def _mc_forward(self, x_seq: np.ndarray) -> Any:
-        """
-        One stochastic forward pass — dropout applied to h
-        between every timestep, scaled to preserve expected value.
-        """
-        T = x_seq.shape[0]
-        H = self.model.cell.hidden_size
+    def _mc_forward(self, x_seq: np.ndarray) -> np.ndarray:
+        T            = x_seq.shape[0]
+        H            = self.model.cell.hidden_size
         expected_input = self.model.cell.input_size
-        p = self.dropout
-
-        h = np.zeros(H)
-        c = np.zeros(H)
-        preds = []
-
-        cell = self.model.cell
+        p            = self.dropout
+        cell         = self.model.cell
+        W            = cell.W
+        b            = cell.b
+        H1, H2, H3  = H, H * 2, H * 3   # slice boundaries precomputed
+
+        # FIX 1 — Wy check once before loop, not T times inside
+        if self.model.Wy is None:
+            self.model.Wy = self.model.weight_shaper.weight_shaping(x_seq)
+        Wy = self.model.Wy
+        by = self.model.by
+
+        h     = np.zeros(H)
+        c     = np.zeros(H)
+        xh    = np.empty(expected_input + H)  # preallocate concat buffer
+        preds = np.empty(T)                   # preallocate output
+
+        # precompute dropout scale factor
+        inv_keep = 1.0 / (1.0 - p)
 
         for t in range(T):
-            x  = x_seq[t]
+            x = x_seq[t]
+
+            # shape alignment
             if x.ndim == 0:
-                x = x.reshape(1)                          # fix zero-dimensional
+                x = x.reshape(1)
             if x.shape[0] < expected_input:
-                x = np.pad(x, (0, expected_input - x.shape[0]))   # pad if too small
+                x = np.pad(x, (0, expected_input - x.shape[0]))
             elif x.shape[0] > expected_input:
-                x = x[:expected_input]                    # truncate if too large            
-            xh = np.concatenate([x, h])
-            z  = cell.W @ xh + cell.b
+                x = x[:expected_input]
+
+            # need to write into preallocated buffer instead of np.concatenate
+            xh[:expected_input] = x
+            xh[expected_input:] = h
+
+            z = W @ xh + b                    # (4H,)
 
-            # gate activations
-            f  = sigmoid(cell._f(z))
-            i  = sigmoid(cell._i(z))
-            g  = np.tanh(cell._g(z))
-            o  = sigmoid(cell._o(z))
+            # direct slices instead of method calls
+            f      = sigmoid(z[:H1])
+            i      = sigmoid(z[H1:H2])
+            g      = np.tanh(z[H2:H3])
+            o      = sigmoid(z[H3:])
 
             c      = f * c + i * g
             tanh_c = np.tanh(c)
             h      = o * tanh_c
 
-            # ── dropout on h, inverted scaling ──
-            mask = (np.random.rand(H) > p).astype(float) / (1.0 - p)
-            h    = h * mask             # perturb hidden state only
-                                        # cell state c is untouched —
-                                        # preserves long-term memory
-            if self.model.Wy is None:
-                self.model.Wy = self.model.weight_shaper.weight_shaping(x_seq)
+            # FIX 4 — precomputed inv_keep, inplace mask application
+            mask = (np.random.rand(H) > p) * inv_keep
+            h   *= mask
 
-            pred = h @ self.model.Wy.T + self.model.by
-            preds.append(pred[0])
+            preds[t] = (h @ Wy.T + by)[0]
 
-        return np.array(preds)   # (T,)
+        return preds   # (T,)
 
-    # ── gate uncertainty ──────────────────────
-    def _gate_uncertainty(self, x_seq: np.ndarray, AMR: float) -> Any:
+    # ── gate uncertainty for LSTM prediction──────────────────────
+    def _gate_uncertainty(self, x_seq: np.ndarray, AMR: float) -> np.ndarray:
         """
         Structural uncertainty from gate activations.
-
-        High uncertainty when:
-          forget gate (f) is LOW  → model is erasing memory
-          input gate  (i) is HIGH → model is overwriting with new info
-          → transition moment, inherently harder to predict
-
-        Returns per-timestep uncertainty in [0, 1].
+        Vectorized — no Python loop over timesteps.
         """
         _, _, cache = self.model.cell.forward(x_seq)
-        gate_uncertainty = []
-        for entry in cache:
-            _, _, _, f, i, g, o, _, _, _ = entry
-            # mean forget across hidden dims — low = erasing
-            forget_instability = 1.0 - f.mean()
-            # mean input — high = overwriting
-            input_activity     = i.mean()
-            # combined: both high = maximally uncertain transition
-            u = AMR * forget_instability + AMR * input_activity
-            gate_uncertainty.append(u)
 
-        return np.array(gate_uncertainty)   # (T,)
+        # cache[t] = (x, h_prev, c_prev, f, i, g, o, c_new, tanh_c, xh)
+        # need to extract f and i directly as stacked arrays — shape (T, H)
+        T = len(cache)
+        
+        if T == 0:
+            return np.array([0.0])
+
+        # vectorized extraction — one pass instead of T unpacks
+        f_all = np.empty((T, cache[0][3].shape[0]))  # (T, H)
+        i_all = np.empty((T, cache[0][4].shape[0]))  # (T, H)
+
+        for t, entry in enumerate(cache):
+            f_all[t] = entry[3]   # forget gate
+            i_all[t] = entry[4]   # input gate
+
+        # vectorized computation — no per-timestep Python arithmetic
+        forget_instability = 1.0 - f_all.mean(axis=1)   # (T,)
+        input_activity     = i_all.mean(axis=1)           # (T,)
 
+        # precompute scalar factor once
+        scale = 1.0 - AMR
+        gate_uncertainty = scale * (forget_instability + input_activity)
 
-    # empirical quantiles from actual residuals:
+        return np.clip(gate_uncertainty, 0.0, 1.0)      
+
+    # empirical quantiles from actual residuals
     def calibrate(self, X_val, Y_val):
-        residuals = []
+        if len(X_val) == 0:
+            self.residual_mean = 0.0
+            self.residual_std  = 1.0
+            self.quantiles     = {}
+            return
+
+        all_errors = []
         for j in range(len(X_val)):
-            preds, _, _, _ = self.model.forward(X_val[j])          
-            min_T = min(preds.shape[0], Y_val[j].shape[0])
-            err   = preds[:min_T, 0] - Y_val[j, :min_T, 0]         
-            residuals.extend(err.tolist())
-
-        residuals = np.array(residuals)
-        self.residual_std  = residuals.std()
-        self.residual_mean = residuals.mean()
-
-        # store empirical quantiles instead of assuming normality
-        self.quantiles = {
-            0.90: (np.percentile(residuals, 5),
-                np.percentile(residuals, 95)),
-            0.95: (np.percentile(residuals, 2.5),
-                np.percentile(residuals, 97.5)),
-            0.99: (np.percentile(residuals, 0.5),
-                np.percentile(residuals, 99.5)),
-        }
+            preds, _, _, _ = self.model.forward(X_val[j])
+            y         = Y_val[j]
+            pred_vals = preds[:, 0] if preds.ndim > 1 else preds
+            true_vals = y[:, 0]    if y.ndim > 1    else y
+            min_T     = min(len(pred_vals), len(true_vals))
+            all_errors.append(pred_vals[:min_T] - true_vals[:min_T])
+
+        residuals = np.concatenate(all_errors)
+        n         = len(residuals)
+
+        self.residual_mean = float(residuals.mean())
+        self.residual_std  = float(max(residuals.std(), 1e-6))
+
+        # adapt confidence levels to sample size
+        # small n → only compute what's statistically supportable
+        if n < 20:
+            # only 90% interval is reliable — use 10th/90th percentile
+            # wide enough to be honest about uncertainty
+            levels = [10.0, 90.0]
+            p = np.percentile(residuals, levels)
+            self.quantiles = {
+                0.90: (float(p[0]), float(p[1])),
+                0.95: (float(p[0]), float(p[1])),  # same as 90% — honest, not fake precision
+                0.99: (float(p[0]), float(p[1])),
+            }
+            print(f'[!] n={n} too small for tail quantiles — '
+                f'using 10th/90th for all intervals')
+
+        elif n < 50:
+            # 90% and 95% supportable, 99% not reliable
+            levels = [2.5, 5.0, 95.0, 97.5]
+            p = np.percentile(residuals, levels)
+            self.quantiles = {
+                0.90: (float(p[1]), float(p[2])),
+                0.95: (float(p[0]), float(p[3])),
+                0.99: (float(p[0]), float(p[3])),  # same as 95% — honest
+            }
+            print(f'[!] n={n} insufficient for 99% interval — '
+                f'using 95% as proxy')
+
+        else:
+            # full precision justified
+            levels = [0.5, 2.5, 5.0, 95.0, 97.5, 99.5]
+            p = np.percentile(residuals, levels)
+            self.quantiles = {
+                0.90: (float(p[2]), float(p[3])),
+                0.95: (float(p[1]), float(p[4])),
+                0.99: (float(p[0]), float(p[5])),
+            }
+
+        # floor std on small n
+        if n < 20:
+            self.residual_std = max(self.residual_std, 0.1)
+
+        print(f"[=] Calibrated: μ={self.residual_mean:.4f} "
+            f"σ={self.residual_std:.4f} "
+            f"n={n} "
+            f"90%=[{self.quantiles[0.90][0]:.4f}, {self.quantiles[0.90][1]:.4f}]")
 
     # interval to calculate prediction interval from MC mean + empirical quantiles
     def _interval(self, mc_mean, confidence_level):
+        # flatten mc_mean safely — handles scalar, 0-d array, or 1-d array
+        mc_scalar = float(np.asarray(mc_mean).flat[0])
+
+        if confidence_level not in self.quantiles:
+            available = sorted(self.quantiles.keys())
+            if not available:
+                return mc_scalar - self.residual_std, mc_scalar + self.residual_std
+            confidence_level = min(available, key=lambda k: abs(k - confidence_level))
+            print(f'[!] Confidence level not found, using closest: {confidence_level}')
+
         lo_bias, hi_bias = self.quantiles[confidence_level]
-        return mc_mean + lo_bias, mc_mean + hi_bias
 
+        lo = mc_scalar + float(np.asarray(lo_bias).flat[0])
+        hi = mc_scalar + float(np.asarray(hi_bias).flat[0])
+
+        if lo > hi:
+            lo, hi = hi, lo
+
+        return lo, hi
 
     # MC sample counting for label confidence (last timestep)
     def _label_confidence_empirical(self, mc_samples_last, label_bins):
         """
         mc_samples_last : (n_samples,) — raw MC draws at last timestep
         label_bins      : {"Good": (0, 35), "Moderate": (35, 75), ...}
-
-        No distribution assumption — just count what fraction
-        of actual MC samples land in each bin.
         """
-        label_conf = {}
         n = len(mc_samples_last)
+        if n == 0:
+            return {name: 0.0 for name in label_bins}
+
+        names  = list(label_bins.keys())
+        bounds = np.array(list(label_bins.values()))  # (n_bins, 2)
 
-        for name, (lo, hi) in label_bins.items():
-            hits = ((mc_samples_last >= lo) & (mc_samples_last < hi)).sum()
-            label_conf[name] = hits / n
+        # vectorized — broadcast (n_samples,) against (n_bins, 2)
+        # samples shape: (1, n_samples), bounds shape: (n_bins, 1)
+        samples = mc_samples_last[np.newaxis, :]          # (1, n_samples)
+        lo      = bounds[:, 0, np.newaxis]                # (n_bins, 1)
+        hi      = bounds[:, 1, np.newaxis]                # (n_bins, 1)
 
-        return label_conf
+        hits = ((samples >= lo) & (samples < hi)).sum(axis=1)  # (n_bins,)
+        probs = hits / n                                        # (n_bins,)
+
+        return dict(zip(names, probs.tolist()))
 
     # 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):
@@ -1804,7 +1921,7 @@ class LSTMEngine:
         AME = self.pipeline.AME_Encoder(X)
         AMR = 1.0 / (1.0 + np.exp(-AME))
 
-        n_train = int(AMR * len(X))
+        n_train = int((1.0 - AMR) * len(X))
         X_tr, Y_tr = X[:n_train], Y[:n_train]
         X_te, Y_te = X[n_train:], Y[n_train:]
 
@@ -1814,7 +1931,7 @@ class LSTMEngine:
             np.random.shuffle(idx)
             epoch_loss = 0.0
             for j in idx:
-                loss, _ = model.train_step(X_tr[j], Y_tr[j], lr=lr)
+                loss, _ = model.train_step(X_tr[j], Y_tr[j], lr=lr, AMR=AMR)
                 epoch_loss += loss
             epoch_loss /= n_train
 
@@ -1841,7 +1958,10 @@ class LSTMEngine:
 
         print("[=] Training complete!")
         print(f"[=] Final val loss: {val_loss:.6f}")
+        print('===== CALIBRATION METHOD =====')
+        self.calibrate_residual(X_te, Y_te)
 
+    # get optimal lstm samples amount for the model to process
     def lstm_optimal_samples(self, engine, x_seq, tolerance=0.005, max_n=500):
         """
         Run increasing n_samples until std estimate stabilizes.
@@ -1862,7 +1982,7 @@ class LSTMEngine:
             prev_std = current_std
         return max_n
 
-
+    # derive local bins for flexibility in scarce dataset
     def derive_bins_from_data(self, y_values, n_bins=4, labels=None):
         """
         Use percentiles of actual data to set boundaries.
@@ -1915,7 +2035,7 @@ class LSTMEngine:
         return bins
 
 
-    # ── main predict ─────────────────────────
+    # ── main predict function for the whole network ─────────────────────────
     def predict(self, x_seq: np.ndarray,
                 label_bins: dict = None,
                 confidence_level: float = 0.90) -> Any:
@@ -1941,9 +2061,6 @@ class LSTMEngine:
             label_confidence: {label: probability} if label_bins given
             overall        : single scalar confidence for last timestep
         """
-        assert self.residual_std is not None, \
-            "Call calibrate(X_val, Y_val) before predict()"
-
         # ── point prediction ──────────────────
         preds_clean, _, _, _ = self.model.forward(x_seq)
         AME = self.pipeline.AME_Encoder(x_seq)  # geometric complexity scalar
@@ -1969,7 +2086,11 @@ class LSTMEngine:
 
         # ── prediction interval ───────────────
         total_std = np.sqrt(mc_std**2 + self.residual_std**2)        
-        low, high = self._interval(mc_mean, confidence_level)
+        # compute interval for every timestep — always returns (T,) arrays
+        interval_low  = np.empty(len(mc_mean))
+        interval_high = np.empty(len(mc_mean))
+        for t in range(len(mc_mean)):
+            interval_low[t], interval_high[t] = self._interval(mc_mean[t], confidence_level)
 
         # ── label confidence (last timestep) ──
         label_conf = None
@@ -1984,7 +2105,7 @@ class LSTMEngine:
         # ── overall scalar confidence ─────────
         # weighted combination of MC confidence and gate stability
         gate_stability = 1.0 - gate_unc[-1]           # high = stable
-        overall = AMR * mc_confidence[-1] + \
+        overall = (1.0 - AMR) * mc_confidence[-1] + \
                   self.pipeline.confidence_threshold * gate_stability     
 
         return {
@@ -1993,16 +2114,15 @@ class LSTMEngine:
             "mc_std"          : mc_std,
             "mc_confidence"   : mc_confidence,
             "gate_uncertainty": gate_unc,
-            "interval_low"    : low,
-            "interval_high"   : high,
+            "interval_low"    : interval_low,
+            "interval_high"   : interval_high,
             "label_confidence": label_conf,
             "overall"         : overall,
         }
         
     # ─────────────────────────────────────────────
-    #  Architecture summary helper
+    #  Architecture summary helper to visualize results
     # ─────────────────────────────────────────────
-
     def architectural_summary(self, model: LSTMNetwork):
         H = model.cell.hidden_size
         I = model.cell.input_size
@@ -7515,7 +7635,11 @@ class IntegratedPipeline:
         elif isinstance(a, np.ndarray) and np.issubdtype(a.dtype, np.character):
             # catches arrays filled with string text
             clean_str = ' '.join(a.astype(str).flatten()).replace('[', '').replace(']', '')
-            a = np.fromstring(clean_str, sep=' ')
+            try:
+                a = np.fromstring(clean_str, sep=' ')
+            except:
+                clean_string = clean_str.strip(",")  
+                a = np.fromstring(clean_string, sep=' ')                              
         else:
             # Ensure standard float array if it was integers or objects
             a = np.asarray(a, dtype=float)
@@ -8358,18 +8482,18 @@ class IntegratedPipeline:
 
                 if choose_method == 'Y':
                     self.autonomous = True
-                    probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method='dynamic') 
+                    probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method='dynamic', embedded=True) 
 
                 else:
                     method = input('|| Choose one method (ex: dynamic): ')
                     if method:
-                        probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method=method)
+                        probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method=method, embedded=True)
                     else:
                         print('|| Invalid Method.. returning to dynamic prediction..')
-                        probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method='dynamic')    
+                        probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method='dynamic', embedded=True)    
             else:
                 print('[+] Autonomous dynamic prediction: ')
-                probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method='dynamic') 
+                probs, details = self.ensemble.predict_ensemble(input_ids, X, y, method='dynamic', embedded=True) 
 
             self.modular_prediction_saving(input_ids, X, probs)
             print('🚀 Memory Added!')
@@ -11772,6 +11896,21 @@ class PipelinePredictionManager:
             if sequence_ids is not None:
                 print("\n[🔍] Using sequence encoding for transformer input due to low anisotropy.")
                 input_ids = sequence_ids.copy()
+
+            target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
+            target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
+            target_pred_indices = np.argmax(target_probs, axis=1)    
+
+            if self.pipeline.cache and 'label_bins' in self.pipeline.cache:
+                print('[=] label_bins cache found!')
+                label_bins = self.pipeline.cache['label_bins']
+                lstm_probs, _ = self.pipeline.ensemble._get_lstm_probs(input_ids, X, label_bins=label_bins)      
+            else:
+                lstm_probs = None
+
+            results = []
+            attention_data = [] if return_attention else None
+
             target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
             target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
             target_pred_indices = np.argmax(target_probs, axis=1)          
@@ -11797,15 +11936,16 @@ class PipelinePredictionManager:
                 mlp_confidence = mlp_probs[i][mlp_class_idx]
                 mlp_label = reverse_map.get(mlp_class_idx, f"unknown_{mlp_class_idx}")
 
-                target_confidence = mlp_confidence
-                target_probs = mlp_probs
-                target_pred_indices = mlp_pred_indices
-                target_class_idx = mlp_class_idx
+                if lstm_probs is not None:
+                    lstm_pred_indices = np.argmax(lstm_probs, axis=1)
+                    lstm_class_idx = lstm_pred_indices[i]              
+                    lstm_confidence = lstm_probs[i][lstm_class_idx]
+                else:
+                    lstm_confidence = None
+
+                target_class_idx = target_pred_indices[i]
+                target_confidence = target_probs[i][target_class_idx]
             
-                if float(mlp_confidence) < self.pipeline.confidence_threshold:
-                    target_class_idx = target_pred_indices[i]
-                    target_confidence = target_probs[i][target_class_idx]
-                
                 # Transformer prediction and blending
                 if trans_probs is not None:
                     trans_probs_i = trans_probs[i]
@@ -11821,14 +11961,18 @@ class PipelinePredictionManager:
                     # Blend predictions (MLP decides class, transformer calibrates confidence)
                     mlp_weight = mlp_confidence / (target_confidence + trans_confidence + eps)
                     trans_weight = trans_confidence / (target_confidence + trans_confidence + eps)
+                    if lstm_confidence is not None:
+                        lstm_weight = lstm_confidence / (target_confidence + lstm_confidence + eps)
                         
                     calibration_weighting = calibration[target_class_idx] if target_class_idx < len(calibration) else 0.0
                         
                     # Weighted blend: calibration_weighting * calibrated + (1-weight) * mlp
-                    final_probs = mlp_weight * target_probs[i][:len(calibration)] + trans_weight * calibration[i][:len(calibration)]
-                 
-                    final_class_idx = target_class_idx
+                    if 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)]
 
+                    final_class_idx = target_class_idx
                     try:
                         final_confidence = final_probs[final_class_idx]
                     except IndexError:
@@ -11944,7 +12088,7 @@ class PipelinePredictionManager:
 
                 elif not results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold:
                     if final_confidence is not None and confidence < self.pipeline.confidence_threshold:
-                        print("\n[⚠️] High confidence detected, but both models don't agree. Using calibrated probabilities for final decision to ensure robustness.")
+                        print("\n[⚠️] Low confidence detected, but both models don't agree. Using calibrated probabilities for final decision to ensure robustness.")
                         final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset)
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx
@@ -11953,6 +12097,16 @@ class PipelinePredictionManager:
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                             print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
                         final_idx = int(final_idx)  
+                    else:
+                        print('[🎯] Stable confidence established, But both Models doesnt Agree, Re-evaluating...')   
+                        final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset)
+                        final_idx = final_probs[0].argmax()
+                        original_idx = final_idx
+
+                        if final_idx > len(reverse_map):
+                            final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
+                        final_idx = int(final_idx)    
 
                     chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
                     try:

{abstractintegratedmodule-0.4.0/AbstractIntegratedModule.egg-info → abstractintegratedmodule-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.4.0
+Version: 0.4.2
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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: Beta, 0.4.0.
+- Development Stage: Beta, 0.4.2.
 - 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.
@@ -62,11 +62,11 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Proven Works on ARM64 Environment, Training and Prediction works efficient on Docker ARM64 environment with QEMU, good parallelizing behavior is guaranteed.
    - P2P Works efficiently in ARM64 Docker + QEMU, No conflicting socket and all prediction works efficiently.
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
-
+   - LSTM is Optimized efficiently for scarce data with AWE method.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />
-[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
+
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.4.0 → abstractintegratedmodule-0.4.2}/README.md

@@ -10,7 +10,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: Beta, 0.4.0.
+- Development Stage: Beta, 0.4.2.
 - 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.
@@ -30,11 +30,11 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Proven Works on ARM64 Environment, Training and Prediction works efficient on Docker ARM64 environment with QEMU, good parallelizing behavior is guaranteed.
    - P2P Works efficiently in ARM64 Docker + QEMU, No conflicting socket and all prediction works efficiently.
    - AWE setup Proven Efficient on Hard-uncontrolled dataset such as Activity Recognition from the given Database.
-
+   - LSTM is Optimized efficiently for scarce data with AWE method.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />
-[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
+
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.4.0 → abstractintegratedmodule-0.4.2}/setup.py

@@ -8,7 +8,7 @@ class BinaryDistribution(Distribution):
 
 setup(
     name="AbstractIntegratedModule",
-    version="0.4.0",
+    version="0.4.2",
     description="Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",