AbstractIntegratedModule 1.2.5__tar.gz → 1.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.2.5
+Version: 1.2.7
 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.7}/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):
@@ -10979,12 +10981,17 @@ class AgentDistributedInference:
                 rules = payload.get('rules')
                 X = payload.get('X')
                 y = payload.get('y')
+
                 
                 # Sanitize if needed
                 if test_titles:
                     test_titles = self._sanitize_structured(test_titles)
                 if label_map:
                     label_map = self._sanitize_structured(label_map)
+                if label_map is None or not isinstance(label_map, dict):
+                    raise ValueError('[>] Label map is None or invalid label map instance!')
+
+
                 if rules:
                     rules = self._sanitize_structured(rules)
                 if X is not None:
@@ -10992,10 +10999,12 @@ class AgentDistributedInference:
                 if y is not None:
                     y = self._sanitize_structured(y)
 
-                if X is None or y is None:
-                    print('[=] Got necessary titles, label_map and rules.')
+                if X is None and y is None and test_titles is not None and rules is not None:
+                    print('[=] Got necessary titles, label_map, rules samples')
+                elif X is not None and y is not None and test_titles is None and rules is None:
+                    print('[=] Got necessary titles, rules, label_map, X And Y samples.')
                 else:
-                    print('[=] Got necessary titles, label_map, rules and X And Y samples.')
+                    raise ValueError('[>] All samples are None!')
             else:
                 text = payload.get('text')
                 if text:
@@ -11006,9 +11015,8 @@ class AgentDistributedInference:
             text = str(payload) if payload else None
         
         if not text and not test_titles:
-            print('[===] ERROR: No text or test_titles in message payload!')
-            return {'type': self.MSG_TYPES['PREDICT_RESPONSE'], 'error': 'No text or test_titles provided'}
-        
+            print('[INFO] No text or test_titles in message payload.')
+            
         # Run the actual prediction
         print(f'[=] Initiating prediction method')
         try:
@@ -13340,16 +13348,16 @@ class IntegratedPipeline:
                     if value.shape[0] != num_classes and \
                     (value.ndim < 2 or value.shape[1] != num_classes):
                         return (True,
-                                f"Array shape {value.shape} doesn't match "
+                                f"[>] Array shape {value.shape} doesn't match "
                                 f"{num_classes} classes in key '{key}'",
                                 "Hybrid feature stored incorrectly, clear entry")
                 if value.size == 0:
                     return (True,
-                            f"Empty array in key '{key}'",
+                            f"[>] Empty array in key '{key}'",
                             "Corrupted array, clear entry")
                 if not np.isfinite(value).all():
                     return (True,
-                            f"NaN/Inf values in array at key '{key}'",
+                            f"[>] NaN/Inf values in array at key '{key}'",
                             "Corrupted values, clear entry")
 
             # validate tuple values in dict
@@ -13359,10 +13367,10 @@ class IntegratedPipeline:
                 )
                 if corrupted:
                     return (True,
-                            f"Corrupted tuple value at key '{key}': {reason}",
+                            f"[>] Corrupted tuple value at key '{key}': {reason}",
                             fix)
 
-        return (False, "Valid dict structure", None)
+        return (False, "[>] Valid dict structure", None)
 
 
     def initialize_fitting(self, text):
@@ -13381,23 +13389,22 @@ class IntegratedPipeline:
         unique_in_batch = len(np.unique(y_raw))
 
         if num_classes is None:
-            # no model exists yet — this is the legitimate case where
+            # no model exists — this is the legitimate case where
             # inferring from y_raw is correct (e.g. first-time initialization)
             num_classes = unique_in_batch
             print(f'[=] No existing model — initializing with {num_classes} classes '
                 f'from this batch')
         elif unique_in_batch > num_classes:
-            # batch contains MORE classes than the model supports
-            # this is a real problem — can't onehot-encode into a smaller space
+            # batch contains more classes than the model supports
+            # a problem — can't onehot-encode into a smaller space
             print(f'[⚠️] Batch contains {unique_in_batch} unique classes but model '
                 f'only supports {num_classes} — expanding to {unique_in_batch}')
             num_classes = unique_in_batch
         elif unique_in_batch < num_classes:
             # batch just doesn't happen to contain all classes.
-            # use the model's full num_classes so onehot stays the right width
+            # use model's full num_classes so onehot stays the right width
             print(f'[=] Batch only contains {unique_in_batch}/{num_classes} classes '
                 f'— using full model class count for onehot width')
-            # num_classes stays as the model's true value, no change needed
 
         y_onehot = np.zeros((len(y_raw), num_classes))
 
@@ -13408,9 +13415,7 @@ class IntegratedPipeline:
             else:
                 print(f'[⚠️] Label {label_idx} out of range for {num_classes} classes '
                     f'at sample {idx} — skipping onehot assignment')
-                # leaves that row as all-zeros rather than crashing or
-                # silently assigning to a wrong class
-
+                    
         return y_onehot
 
 
@@ -20651,9 +20656,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 +21122,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 +21220,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 +21251,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 +21303,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)