feat: modernize PSO and add convergence research

Migrate the package and examples to the tensor-native PyTorch implementation, add benchmark evidence, and add the guarded post-training convergence protocol with TensorBoard progress monitoring and hash-verified recovery.

Constraint: Preserve one-shot official-test sealing and auditable research artifacts

Rejected: Commit local .omc runs and downloaded datasets | multi-gigabyte runtime state is machine-local

Confidence: high

Scope-risk: broad

Not-tested: Production CUDA run on pieroot-server

test/seeds.py

@@ -1,23 +1,16 @@
-# %%
-import json
-import os
-import sys
-
 import numpy as np
 import pandas as pd
-import tensorflow as tf
-from keras.layers import Dense
-from keras.models import Sequential
-from keras.utils import to_categorical
+import argparse
+import torch
+import torch.nn as nn
 from sklearn.model_selection import train_test_split
-from tensorflow import keras
+from sklearn.preprocessing import StandardScaler
 
-from pso import optimizer
-
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+from pso import Optimizer
+from cli import add_pso_args, build_optimizer_kwargs
 
 
-def get_data():
+def get_data(seed: int = 42):
     with open("data/seeds/seeds_dataset.txt", "r", encoding="utf-8") as f:
         data = f.readlines()
         df = pd.DataFrame([d.split() for d in data])
@@ -33,80 +26,103 @@ def get_data():
         ]
 
         df = df.astype(float)
-        df["target"] = df["target"].astype(int)
+        df["target"] = df["target"].astype(int) - 1
 
-        x = df.iloc[:, :-1].values.round(0).astype(int)
-        y = df.iloc[:, -1].values
-
-    y_class = to_categorical(y)
+        x = df.iloc[:, :-1].values.astype(np.float32)
+        y = df.iloc[:, -1].values.astype(np.int64)
 
     x_train, x_test, y_train, y_test = train_test_split(
-        x, y_class, test_size=0.2, shuffle=True
+        x, y, test_size=0.2, shuffle=True, random_state=seed
+    )
+    scaler = StandardScaler()
+    x_train = scaler.fit_transform(x_train)
+    x_test = scaler.transform(x_test)
+
+    return (
+        torch.tensor(x_train, dtype=torch.float32),
+        torch.tensor(y_train, dtype=torch.int64),
+        torch.tensor(x_test, dtype=torch.float32),
+        torch.tensor(y_test, dtype=torch.int64),
     )
 
-    return x_train, y_train, x_test, y_test
+
+def make_model(seed: int = 42):
+    torch.manual_seed(seed)
+    return nn.Sequential(
+        nn.Linear(7, 16),
+        nn.ReLU(),
+        nn.Linear(16, 32),
+        nn.ReLU(),
+        nn.Linear(32, 3),
+    )
 
 
-def make_model():
-    model = Sequential()
-    model.add(Dense(16, activation="relu", input_shape=(7,)))
-    model.add(Dense(32, activation="relu"))
-    model.add(Dense(4, activation="softmax"))
+def main():
+    parser = argparse.ArgumentParser(description="PSO Seeds Benchmark Script")
+    add_pso_args(
+        parser,
+        defaults={
+            "method": "original",
+            "initialization": "model_noise",
+            "evaluation": "full",
+            "convergence": "particle_reset",
+            "refinement": "adam",
+            "n_particles": 24,
+            "c0": None,
+            "c1": None,
+            "w_min": None,
+            "w_max": None,
+            "negative_swarm": 0.0,
+            "mutation_swarm": 0.3,
+            "particle_min": -3.0,
+            "particle_max": 3.0,
+            "velocity_limit_ratio": 0.1,
+            "boundary_strategy": "reflect",
+            "seed": 42,
+            "epochs": 80,
+            "renewal": "acc",
+            "output_dir": "output/seeds",
+            "checkpoint_interval": 25,
+            "refinement_epochs": 10,
+            "refinement_lr": 0.001,
+        },
+    )
+    args = parser.parse_args()
 
-    return model
+    model = make_model(seed=args.seed)
+    x_train, y_train, x_test, y_test = get_data(seed=args.seed)
+
+    fitness_size = args.fitness_size if args.evaluation == "fixed_subset" else None
+    refinement_epochs = args.refinement_epochs if args.refinement == "adam" else 0
+
+    kwargs = build_optimizer_kwargs(
+        args,
+        model=model,
+        loss=nn.CrossEntropyLoss(),
+        task="multiclass",
+        inertia_profile={"c0": 0.5, "c1": 1.0, "w_min": 0.7, "w_max": 1.2},
+    )
+    pso_seeds = Optimizer(**kwargs)
+
+    print(f"Optimizer device: {pso_seeds.device}")
+
+    best_score = pso_seeds.fit(
+        x_train,
+        y_train,
+        epochs=args.epochs,
+        batch_size=args.batch_size,
+        fitness_size=fitness_size,
+        renewal=args.renewal,
+        validation_data=(x_test, y_test),
+        output_dir=args.output_dir,
+        checkpoint_interval=25,
+        save_info=True,
+        refinement_epochs=refinement_epochs,
+        refinement_lr=args.refinement_lr,
+    )
+
+    print(f"Done! Best score: {best_score}")
 
 
-# %%
-model = make_model()
-x_train, y_train, x_test, y_test = get_data()
-
-loss = [
-    "mean_squared_error",
-    "categorical_crossentropy",
-    "sparse_categorical_crossentropy",
-    "binary_crossentropy",
-    "kullback_leibler_divergence",
-    "poisson",
-    "cosine_similarity",
-    "log_cosh",
-    "huber_loss",
-    "mean_absolute_error",
-    "mean_absolute_percentage_error",
-]
-
-# rs = random_state()
-
-pso_mnist = optimizer(
-    model,
-    loss="categorical_crossentropy",
-    n_particles=100,
-    c0=0.5,
-    c1=1.0,
-    w_min=0.7,
-    w_max=1.2,
-    negative_swarm=0.0,
-    mutation_swarm=0.3,
-    convergence_reset=True,
-    convergence_reset_patience=10,
-    convergence_reset_monitor="mse",
-    convergence_reset_min_delta=0.0005,
-)
-
-best_score = pso_mnist.fit(
-    x_train,
-    y_train,
-    epochs=500,
-    save_info=True,
-    log=2,
-    log_name="seeds",
-    renewal="acc",
-    check_point=25,
-    empirical_balance=False,
-    dispersion=False,
-    back_propagation=False,
-    validate_data=(x_test, y_test),
-)
-
-print("Done!")
-
-sys.exit(0)
+if __name__ == "__main__":
+    main()