AbstractIntegratedModule 1.2.5__tar.gz → 1.2.6__tar.gz

{abstractintegratedmodule-1.2.5 → abstractintegratedmodule-1.2.6}/AbstractIntegratedModule.egg-info/PKG-INFO

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

@@ -1825,9 +1825,11 @@ class SNNNetwork:
         optimizer.step(self.layers)
         return loss, logits
 
-    def predict(self, input_spikes):
+    def predict(self, input_spikes, task='classification'):
         self.eval()
         logits = self.forward(input_spikes)
+        if task == 'regression':
+            return logits[:, 0], logits
         return np.argmax(logits, axis=1), logits
 
     def firing_rates(self):
@@ -20651,9 +20653,9 @@ class SNNUtility:
 # SNN Network Build
 #-----------------
 def build_snn_network(n_in, n_hidden, n_classes, rng, decay=0.95, 
-                      threshold=0.1, input_noise_std=0.0, reduction='mean'):
+                      threshold=0.1, input_noise_std=0.0, reduction='mean', p=0.2):
     layer1 = LIFDenseLayer(n_in, n_hidden, decay=decay, threshold=threshold, rng=rng)
-    drop1 = SpikeDropout(p=0.2, rng=rng)
+    drop1 = SpikeDropout(p=p, rng=rng)
     readout = ReadoutLayer(n_hidden, n_classes, decay=decay, rng=rng)
     net = SNNNetwork([layer1, drop1, readout], readout_reduction=reduction,
                       input_noise_std=input_noise_std, rng=rng)
@@ -21117,23 +21119,69 @@ def print_confidence_report(results, top_k=3, max_print_threshold=50):
                 f"|| Top-{top_k}: [{top_str}]")
     return pred_cache
 
+def initialize_snn_network(X=None, y=None, label_map=None, n_hidden=64, n_in=None, n_classes=None, seed=0, random_state=42):
+    try:
+        utility = SNNUtility()
+        rng = utility.seed_everything(seed)
+        if n_in is not None and n_classes is not None:
+            net, hidden_layer = build_snn_network(n_in, n_hidden, n_classes, rng)
+        else:
+            X_train, X_test, y_train, y_test, X_val, y_val = _prepare_train_val_split(X=X, y=y, random_state=random_state)
+            n_in = X_train.shape[1]
+            n_classes = max(len(label_map), int(y_train.max() + 1))
+            net, hidden_layer = build_snn_network(n_in, n_hidden, n_classes, rng)
 
+        print(f'[>] Initialized SNN Network with hidden dim: {n_hidden}')
+        return net, hidden_layer, utility
+    except Exception as e:
+        print(f'[>] Error initializing SNN Network and hidden layer: {e}')
+        return None, None, None
 
-def train_snn_network(X=None, y=None, net=None, hidden_layer=None, label_map=None,
+def train_snn_network(X=None, y=None, net=None, hidden_layer=None, utility=None, task='classification', label_map=None,
          epochs=50, batch_size=32, n_steps=20, 
          n_hidden=64, lr=2e-3, seed=0, pretrain_steps=200, unsupervised_stdp=False,
-         random_state=42):
+         random_state=42, ):
     tracker = DiagnosticsTracker()
-    utility = SNNUtility()
     cache = {}
+    reg = (task == 'regression')
+    if utility is None:
+        utility = SNNUtility()
 
     rng = utility.seed_everything(seed)
-    X_train, X_test, y_train, y_test, X_val, y_val = _prepare_train_val_split(X=X, y=y, random_state=random_state)
+    if reg:
+        X = np.asarray(X, dtype=np.float64)
+        y = np.asarray(y, dtype=np.float64)
+        if X.ndim > 2:
+            X = X.reshape(len(X), -1)                         # (N, W, F) -> (N, W*F)
+        if y.ndim == 1:
+            y = y.reshape(-1, 1)
+        if len(X) != len(y):
+            raise ValueError(f'X has {len(X)} samples but y has {len(y)}')
+        n = len(X)
+        a, b = int(0.70 * n), int(0.85 * n)                   # chronological: never shuffle a time series
+        X_train, X_val, X_test = X[:a], X[a:b], X[b:]
+        y_train, y_val, y_test = y[:a], y[a:b], y[b:]
+        lo, hi = X_train.min(0), X_train.max(0)               # [0,1] scaling for spike encoding (train stats)
+        span = np.where(hi - lo < 1e-9, 1.0, hi - lo)
+        scale_x = lambda A: np.clip((A - lo) / span, 0.0, 1.0)
+        X_train, X_val, X_test = scale_x(X_train), scale_x(X_val), scale_x(X_test)
+        y_mu, y_sd = y_train.mean(0), y_train.std(0) + 1e-9   # per-output standardisation
+        y_train_net = (y_train - y_mu) / y_sd
+        n_classes = y.shape[1]                                # readout width = number of regression outputs
+        loss_fn = mse_loss
+    else:
+
+        X_train, X_test, y_train, y_test, X_val, y_val = _prepare_train_val_split(X=X, y=y, random_state=random_state)
+        y_train_net = y_train
+        n_classes = max(len(label_map), int(y_train.max() + 1))
+
     n_in = X_train.shape[1]
-    n_classes = max(len(label_map), int(y_train.max() + 1))
-    if net is None and hidden_layer is None:
+    if net is None or hidden_layer is None:
         net, hidden_layer = build_snn_network(n_in, n_hidden, n_classes, rng)
 
+    if reg:
+        net.regression_scalers = {'lo': lo, 'span': span, 'y_mu': y_mu, 'y_sd': y_sd}
+
     encoder = PoissonEncoder(n_steps=n_steps, max_rate=1.0, rng=rng)
     optimizer = Adam(lr=lr, weight_decay=1e-5)
     homeostasis = ThresholdHomeostasis(target_rate=0.15, adjust_rate=0.05)
@@ -21169,16 +21217,28 @@ def train_snn_network(X=None, y=None, net=None, hidden_layer=None, label_map=Non
 
         # Evaluation
         net.eval()
-        test_spikes = encoder.encode(X_test)
-        train_spikes = encoder.encode(X_train)
-        preds, _ = net.predict(test_spikes)
-        train_preds, _ = net.predict(train_spikes)
-        test_acc = utility.accuracy(preds, y_test)
-        train_acc = utility.accuracy(train_preds, y_train)
-        print(f"[=] Epoch {epoch:2d} || train_loss={np.mean(epoch_losses):.4f}  "
-              f"train_acc={train_acc*100:5.1f} || test_acc={test_acc*100:5.1f}% || hidden_threshold={hidden_layer.threshold:.3f}")
-              
-        tracker.record(net, epoch, loss=loss, test_acc=test_acc)
+        preds, _ = net.predict(encoder.encode(X_test), task=task)
+        train_preds, _ = net.predict(encoder.encode(X_train), task=task)
+        if reg:
+            p_te = np.asarray(preds).reshape(len(X_test), -1) * y_sd + y_mu          # back to original units
+            p_tr = np.asarray(train_preds).reshape(len(X_train), -1) * y_sd + y_mu
+            test_rmse = float(np.sqrt(np.mean((p_te - y_test) ** 2)))
+            test_mae = float(np.mean(np.abs(p_te - y_test)))
+            train_rmse = float(np.sqrt(np.mean((p_tr - y_train) ** 2)))
+            r2 = float(1.0 - np.sum((p_te - y_test) ** 2) / (np.sum((y_test - y_train.mean(0)) ** 2) + 1e-12))
+            print(f"[=] Epoch {epoch:2d} || train_loss={np.mean(epoch_losses):.4f}  train_rmse={train_rmse:,.1f} || "
+                  f"test_rmse={test_rmse:,.1f} test_mae={test_mae:,.1f} R2={r2:.3f} || "
+                  f"hidden_threshold={hidden_layer.threshold:.3f}")
+            test_score = r2
+        else:
+            test_acc = utility.accuracy(preds, y_test)
+            train_acc = utility.accuracy(train_preds, y_train)
+            print(f"[=] Epoch {epoch:2d} || train_loss={np.mean(epoch_losses):.4f}  "
+                  f"train_acc={train_acc*100:5.1f} || test_acc={test_acc*100:5.1f}% || "
+                  f"hidden_threshold={hidden_layer.threshold:.3f}")
+            test_score = test_acc
+ 
+        tracker.record(net, epoch, loss=loss, test_acc=test_score)
 
     report = network_report(net)
     print_report(report)
@@ -21188,8 +21248,25 @@ def train_snn_network(X=None, y=None, net=None, hidden_layer=None, label_map=Non
 
     return encoder, net, report, warnings
 
+def _snn_predict_regression(X, net, encoder, n_mc=20):
+    sc = getattr(net, 'regression_scalers', None)
+    if sc is None:
+        raise ValueError('[>] net has no regression_scalers: train it with train_snn_network(task="regression") first')
+    X = np.asarray(X, dtype=np.float64)
+    X = X.reshape(len(X), -1)                                                    # (N, W*F)
+    Xs = np.clip((X - sc['lo']) / sc['span'], 0.0, 1.0)
+
+    # the Poisson encoder is stochastic, its repeated to get a prediction and a spread
+    outs = np.stack([net.predict(encoder.encode(Xs), task='regression')[1] for _ in range(n_mc)])   # (n_mc, N, n_out)
+    mean = outs.mean(0) * sc['y_sd'] + sc['y_mu']
+    std = outs.std(0) * sc['y_sd']
+
+    if mean.shape[1] == 1:
+        mean, std = mean[:, 0], std[:, 0]
+    return {'prediction': mean, 'std': std}
+
 
-def snn_predict(X=None, y=None, label_map=None, encoder=None, net=None, random_state=42, max_print_threshold=50):
+def snn_predict(X=None, y=None, task='classification', label_map=None, encoder=None, net=None, random_state=42, max_print_threshold=50):
     utility = SNNUtility()
     reverse_map = None
 
@@ -21223,9 +21300,13 @@ def snn_predict(X=None, y=None, label_map=None, encoder=None, net=None, random_s
     if label_map and isinstance(label_map, dict):
         reverse_map = {v: k for k, v in label_map.items()}
 
+    if task == 'regression':
+        result = _snn_predict_regression(X, net, encoder)
+        return result
+
     try:
         test_spikes = encoder.encode(X)
-        preds, logits = net.predict(test_spikes)
+        preds, logits = net.predict(test_spikes, task=task)
         if reverse_map is not None:
             # SNN-specific: uncertainty from the encoder's own stochasticity
             mc_results = mc_confidence(net, encoder, X, n_samples=20, class_names=reverse_map)