secure-fl 2026.3.16.dev1__tar.gz → 2026.3.17.dev2__tar.gz

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/.gitignore

@@ -116,7 +116,7 @@ datasets/
 # ZKP artifacts
 *.r1cs
 *.wtns
-*.circom
+# *.circom
 output/
 witness/
 circuit.wasm

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: secure-fl
-Version: 2026.3.16.dev1
+Version: 2026.3.17.dev2
 Summary: Dual-Verifiable Framework for Federated Learning using Zero-Knowledge Proofs
 Project-URL: Homepage, https://github.com/krishantt/secure-fl
 Project-URL: Bug Reports, https://github.com/krishantt/secure-fl/issues

secure_fl-2026.3.17.dev2/src/secure_fl/.build_number

@@ -0,0 +1 @@
+2026.03.17:2

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/src/secure_fl/benchmarks/__init__.py

@@ -1,10 +1,11 @@
 """Benchmark orchestration helpers for experiment entrypoints."""
 
 from secure_fl.data.benchmark_data import SUPPORTED_DATASETS
+from secure_fl.data.benchmark_data import kfold_split_indices
 from secure_fl.data.benchmark_data import load_dataset
-from secure_fl.data.benchmark_data import maybe_subsample_dataset
 from secure_fl.data.benchmark_data import normalize_datasets
 from secure_fl.data.benchmark_data import partition_dataset
+from secure_fl.data.benchmark_data import subsample_dataset
 from secure_fl.models.factory import model_fn
 
 from .defaults import PAPER_DEFAULT_ROUNDS
@@ -12,6 +13,7 @@ from .defaults import resolve_num_rounds
 from .execution import run_training_rounds
 from .pipeline import run_single
 from .reporting import build_tradeoff_report
+from .reporting import summarize_folds
 from .reporting import summarize_repeats
 
 __all__ = [
@@ -21,10 +23,12 @@ __all__ = [
     "normalize_datasets",
     "load_dataset",
     "partition_dataset",
-    "maybe_subsample_dataset",
+    "subsample_dataset",
+    "kfold_split_indices",
     "model_fn",
     "run_single",
     "run_training_rounds",
+    "summarize_folds",
     "summarize_repeats",
     "build_tradeoff_report",
 ]

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/src/secure_fl/benchmarks/pipeline.py

@@ -10,8 +10,8 @@ from secure_fl import FedJSCMAggregator
 from secure_fl import create_client
 from secure_fl import torch_to_ndarrays
 from secure_fl.data.benchmark_data import load_dataset
-from secure_fl.data.benchmark_data import maybe_subsample_dataset
 from secure_fl.data.benchmark_data import partition_dataset
+from secure_fl.data.benchmark_data import subsample_dataset
 from secure_fl.models.factory import model_fn
 
 from .execution import run_training_rounds
@@ -30,11 +30,26 @@ def run_single(
     min_proof_coverage: float,
     max_train_samples: int,
     max_test_samples: int,
+    train_set_override: torch.utils.data.Dataset | None = None,
+    eval_set_override: torch.utils.data.Dataset | None = None,
 ) -> dict[str, Any]:
     """Run one dataset/config benchmark and return rounds+summary."""
-    train_set, test_set = load_dataset(dataset, seed)
-    train_set = maybe_subsample_dataset(train_set, max_train_samples, seed)
-    test_set = maybe_subsample_dataset(test_set, max_test_samples, seed + 1)
+    if train_set_override is not None and eval_set_override is not None:
+        train_set = train_set_override
+        test_set = eval_set_override
+    else:
+        loaded_train_set, loaded_test_set = load_dataset(dataset, seed)
+        train_set = (
+            train_set_override
+            if train_set_override is not None
+            else subsample_dataset(loaded_train_set, max_train_samples, seed)
+        )
+        test_set = (
+            eval_set_override
+            if eval_set_override is not None
+            else subsample_dataset(loaded_test_set, max_test_samples, seed + 1)
+        )
+
     client_subsets = partition_dataset(train_set, num_clients, config["iid"], seed)
     model_factory = model_fn(dataset)
 

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/src/secure_fl/benchmarks/reporting.py

@@ -7,11 +7,11 @@ from typing import Any
 import numpy as np
 
 
-def summarize_repeats(runs: list[dict[str, Any]]) -> dict[str, float]:
-    """Summarize repeated benchmark runs into mean/std/CI metrics."""
+def summarize_folds(runs: list[dict[str, Any]]) -> dict[str, float]:
+    """Summarize fold-level benchmark runs into mean/std/CI metrics."""
     if not runs:
         return {
-            "repeats": 0.0,
+            "folds": 0.0,
             "final_accuracy_mean": 0.0,
             "final_accuracy_std": 0.0,
             "final_accuracy_ci95": 0.0,
@@ -82,7 +82,7 @@ def summarize_repeats(runs: list[dict[str, Any]]) -> dict[str, float]:
         ci95 = float(1.96 * final_acc.std(ddof=1) / np.sqrt(len(final_acc)))
 
     return {
-        "repeats": float(len(runs)),
+        "folds": float(len(runs)),
         "final_accuracy_mean": float(final_acc.mean()),
         "final_accuracy_std": float(final_acc.std(ddof=0)),
         "final_accuracy_ci95": ci95,
@@ -104,6 +104,11 @@ def summarize_repeats(runs: list[dict[str, Any]]) -> dict[str, float]:
     }
 
 
+def summarize_repeats(runs: list[dict[str, Any]]) -> dict[str, float]:
+    """Backward-compatible alias for fold-based summarization."""
+    return summarize_folds(runs)
+
+
 def build_tradeoff_report(results: dict[str, dict[str, Any]]) -> dict[str, Any]:
     """Build dataset-level baseline vs ZKP comparison report."""
     report: dict[str, Any] = {"datasets": {}}

secure_fl-2026.3.17.dev2/src/secure_fl/cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m secure_fl.cli`."""
+
+from .main import main
+
+if __name__ == "__main__":
+    main()

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/src/secure_fl/cli/handlers.py

@@ -48,19 +48,27 @@ def run_server(
         with open(config) as f:
             cfg = yaml.safe_load(f)
     else:
-        cfg = get_default_config()
+        cfg = get_default_config().to_dict()
 
-    cfg["server"].update({"host": host, "port": port, "num_rounds": rounds})
+    server_cfg = cfg.get("server", {})
+    zkp_cfg = cfg.get("zkp", {})
+    server_runtime_cfg = {"host": host, "port": port, "num_rounds": rounds}
 
-    strategy_config = {**cfg["strategy"], **cfg["aggregation"], **cfg["zkp"]}
+    strategy_config = {
+        "momentum": float(server_cfg.get("momentum", 0.9)),
+        "learning_rate": float(server_cfg.get("learning_rate", 0.01)),
+        "enable_zkp": bool(zkp_cfg.get("enable_client_proofs", enable_zkp)),
+        "proof_rigor": proof_rigor,
+        "blockchain_verification": blockchain,
+    }
     strategy_config.update(
         {
             "min_available_clients": min_clients,
             "min_fit_clients": min_clients,
             "min_evaluate_clients": min_clients,
-            "momentum": momentum,
             "enable_zkp": enable_zkp,
             "proof_rigor": proof_rigor,
+            "momentum": momentum,
             "blockchain_verification": blockchain,
         }
     )
@@ -89,7 +97,11 @@ def run_server(
         console=console,
     ) as progress:
         task = progress.add_task("Starting Secure FL Server...", total=None)
-        server = SecureFlowerServer(strategy=strategy, **cfg["server"])
+        server = SecureFlowerServer(
+            strategy=strategy,
+            **server_runtime_cfg,
+            config=server_cfg,
+        )
         progress.update(task, description="Server ready! Waiting for clients...")
 
         table = Table(title="Server Configuration")

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/src/secure_fl/data/__init__.py

@@ -14,9 +14,9 @@ from torch.utils.data import Dataset
 
 from secure_fl.data.benchmark_data import SUPPORTED_DATASETS
 from secure_fl.data.benchmark_data import load_dataset
-from secure_fl.data.benchmark_data import maybe_subsample_dataset
 from secure_fl.data.benchmark_data import normalize_datasets
 from secure_fl.data.benchmark_data import partition_dataset
+from secure_fl.data.benchmark_data import subsample_dataset
 
 
 class FederatedDataLoader:
@@ -81,5 +81,5 @@ __all__ = [
     "normalize_datasets",
     "load_dataset",
     "partition_dataset",
-    "maybe_subsample_dataset",
+    "subsample_dataset",
 ]

{secure_fl-2026.3.16.dev1 → secure_fl-2026.3.17.dev2}/src/secure_fl/data/benchmark_data.py

@@ -158,19 +158,12 @@ def partition_dataset(
         chunks = np.array_split(indices, num_clients)
         return [Subset(dataset, chunk.tolist()) for chunk in chunks]
 
-    labels = getattr(dataset, "targets", None)
-    if labels is None:
-        if hasattr(dataset, "tensors") and len(dataset.tensors) >= 2:
-            labels = dataset.tensors[1]
-        else:
-            rng.shuffle(indices)
-            chunks = np.array_split(indices, num_clients)
-            return [Subset(dataset, chunk.tolist()) for chunk in chunks]
+    labels_arr = extract_dataset_labels(dataset)
+    if labels_arr is None:
+        rng.shuffle(indices)
+        chunks = np.array_split(indices, num_clients)
+        return [Subset(dataset, chunk.tolist()) for chunk in chunks]
 
-    if isinstance(labels, torch.Tensor):
-        labels_arr = labels.detach().cpu().numpy()
-    else:
-        labels_arr = np.asarray(labels)
     unique_labels = np.unique(labels_arr)
     client_bins: list[list[int]] = [[] for _ in range(num_clients)]
     classes_per_client = max(2, len(unique_labels) // max(1, num_clients // 2))
@@ -190,15 +183,82 @@ def partition_dataset(
     return [Subset(dataset, sorted(set(bin_idx))) for bin_idx in client_bins]
 
 
-def maybe_subsample_dataset(
-    dataset: Dataset[Any], max_samples: int, seed: int
+def extract_dataset_labels(dataset: Dataset[Any]) -> np.ndarray | None:
+    """Extract label array from supported dataset wrappers."""
+    labels = getattr(dataset, "targets", None)
+    if labels is None:
+        labels = getattr(dataset, "labels", None)
+
+    if labels is not None:
+        if isinstance(labels, torch.Tensor):
+            return labels.detach().cpu().numpy().reshape(-1)
+        return np.asarray(labels).reshape(-1)
+
+    if isinstance(dataset, Subset):
+        base_labels = extract_dataset_labels(cast("Dataset[Any]", dataset.dataset))
+        if base_labels is None:
+            return None
+        subset_indices = np.asarray(dataset.indices, dtype=np.int64)
+        return base_labels[subset_indices]
+
+    if hasattr(dataset, "tensors") and len(dataset.tensors) >= 2:
+        labels_tensor = dataset.tensors[1]
+        if isinstance(labels_tensor, torch.Tensor):
+            return labels_tensor.detach().cpu().numpy().reshape(-1)
+        return np.asarray(labels_tensor).reshape(-1)
+
+    return None
+
+
+def kfold_split_indices(
+    dataset: Dataset[Any],
+    k_folds: int,
+    seed: int,
+    *,
+    stratified: bool = True,
+) -> list[tuple[list[int], list[int]]]:
+    """Create train/validation index splits for k-fold cross-validation."""
+    n = len(cast("Sized", dataset))
+    if k_folds < 2:
+        raise ValueError("k_folds must be >= 2")
+    if k_folds > n:
+        raise ValueError("k_folds cannot exceed dataset size")
+
+    rng = np.random.default_rng(seed)
+    all_indices = np.arange(n)
+    labels = extract_dataset_labels(dataset) if stratified else None
+
+    if labels is not None and len(labels) == n:
+        fold_val_indices: list[list[int]] = [[] for _ in range(k_folds)]
+        for cls in np.unique(labels):
+            cls_indices = np.where(labels == cls)[0]
+            rng.shuffle(cls_indices)
+            cls_parts = np.array_split(cls_indices, k_folds)
+            for fold_idx, part in enumerate(cls_parts):
+                fold_val_indices[fold_idx].extend(part.tolist())
+    else:
+        shuffled = all_indices.copy()
+        rng.shuffle(shuffled)
+        fold_val_indices = [part.tolist() for part in np.array_split(shuffled, k_folds)]
+
+    splits: list[tuple[list[int], list[int]]] = []
+    for fold_idx in range(k_folds):
+        val_indices = np.array(sorted(set(fold_val_indices[fold_idx])), dtype=np.int64)
+        train_indices = np.setdiff1d(all_indices, val_indices, assume_unique=False)
+        splits.append((train_indices.tolist(), val_indices.tolist()))
+
+    return splits
+
+
+def subsample_dataset(
+    dataset: Dataset[Any], sample_limit: int, seed: int
 ) -> Dataset[Any]:
-    """Subsample a dataset for faster benchmark runs when requested."""
-    if max_samples <= 0:
+    """Return a deterministic random subset when sample limit is active."""
+    if sample_limit <= 0:
         return dataset
     n = len(cast("Sized", dataset))
-    if max_samples >= n:
+    if sample_limit >= n:
         return dataset
     rng = np.random.default_rng(seed)
-    indices = rng.choice(n, size=max_samples, replace=False)
+    indices = rng.choice(n, size=sample_limit, replace=False)
     return Subset(dataset, indices.tolist())

secure_fl-2026.3.17.dev2/src/secure_fl/proofs/server/aggregation.circom

@@ -0,0 +1,55 @@
+pragma circom 2.0.0;
+// Federated Learning Aggregation Circuit
+
+template FedJSCMAggregation(n_clients, param_size) {
+    signal input client_deltas[n_clients][param_size];
+    signal input old_momentum[param_size];
+    signal input client_weights[n_clients];
+    signal input active_clients[n_clients];
+    signal input momentum_coeff;
+    signal input old_params[param_size];
+
+    signal output new_params[param_size];
+    signal output new_momentum[param_size];
+
+    // Intermediate signals for weighted sum
+    signal weighted_sum[param_size];
+    signal partial_sums[n_clients][param_size];
+
+    var SCALE = 1000000;
+
+    // Enforce active_clients as binary and zero-contribution for inactive slots.
+    for (var j = 0; j < n_clients; j++) {
+        active_clients[j] * (active_clients[j] - 1) === 0;
+        client_weights[j] * (1 - active_clients[j]) === 0;
+        for (var i = 0; i < param_size; i++) {
+            client_deltas[j][i] * (1 - active_clients[j]) === 0;
+        }
+    }
+
+    // Calculate weighted deltas
+    for (var i = 0; i < param_size; i++) {
+        for (var j = 0; j < n_clients; j++) {
+            partial_sums[j][i] <== client_weights[j] * client_deltas[j][i] / SCALE;
+        }
+    }
+
+    // Sum the weighted deltas
+    for (var i = 0; i < param_size; i++) {
+        var sum = 0;
+        for (var j = 0; j < n_clients; j++) {
+            sum += partial_sums[j][i];
+        }
+        weighted_sum[i] <== sum;
+    }
+
+    // Compute momentum and new params
+    signal momentum_term[param_size];
+    for (var i = 0; i < param_size; i++) {
+        momentum_term[i] <== momentum_coeff * old_momentum[i] / SCALE;
+        new_momentum[i] <== momentum_term[i] + weighted_sum[i];
+        new_params[i] <== old_params[i] + new_momentum[i];
+    }
+}
+
+component main = FedJSCMAggregation(8, 50);

secure_fl-2026.3.16.dev1/src/secure_fl/.build_number

@@ -1 +0,0 @@
-2026.03.16:1